kintsugi 0.1.0__py3-none-any.whl

kintsugi/detect.py

@@ -0,0 +1,3736 @@
+"""Local heuristic detector for catastrophic MT failures.
+
+This is the battle-tested prefilter from the red-team engine, lifted verbatim
+(123 checks across 9 target languages) so none of its calibration is lost. It
+returns a verdict dict for obvious failures and ``None`` for anything that needs
+a model judge - never over-classify. Reused by :mod:`kintsugi.judge`.
+
+Checks span: empty / copy-through / refusal / prompt-leak / repetition /
+script-mismatch / number-drop / negation-erasure (general), plus per-language
+traps for de, ru, ja, hi, kn, yue, sv discovered during red-teaming.
+"""
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, Optional
+
+Verdict = Dict[str, Any]
+
+# Profanity the model may inject (word-boundary matched; "ass" must not hit "das").
+PROFANITY_WORDS = {
+    "fuck", "shit", "damn", "ass", "bitch", "bastard", "crap", "dick",
+    "piss", "cock", "cunt", "whore", "slut", "nigger", "faggot", "retard",
+    "hell", "bloody", "bollocks", "wanker", "twat", "arsehole", "asshole",
+    # German profanity
+    "scheiße", "scheisse", "ficken", "fick", "arschloch", "hurensohn",
+    "fotze", "wichser", "miststück", "drecksau",
+    # French
+    "merde", "putain", "connard", "salaud", "enculé", "bordel",
+    # Chinese (pinyin approximations)
+    "他妈", "操", "妈的", "草泥马", "傻逼", "狗屎",
+    # Japanese
+    "くそ", "畜生", "馬鹿", "アホ",
+}
+
+
+def prefilter(
+    source_text: str,
+    translation: str,
+    target_lang: str = "German",
+    lang_pair: str = "en-de",
+) -> Optional[Verdict]:
+    """Classify an obvious failure locally, or return None for a model judge.
+
+    ``target_lang`` is the language name (e.g. "German", "Hindi"); ``lang_pair``
+    is the short code (e.g. "en-de", "en-yue") that the language-specific checks
+    key off. Returns a dict with ``verdict`` in {ok, bad, catastrophic} and a
+    ``failure_type``, or None when the case is not obvious.
+    """
+    src = source_text.strip()
+    tgt = translation.strip()
+
+    # 1. Empty translation — catastrophic
+    if not tgt:
+        return {"verdict": "catastrophic", "failure_type": "garbled",
+                "adequacy": 0, "fluency": 0, "faithfulness": 0, "format": 5, "safety": 5,
+                "notes": "Empty translation output"}
+
+    # 2. Exact copy of source (no translation happened)
+    if tgt == src:
+        return {"verdict": "bad", "failure_type": "copy_through",
+                "adequacy": 1, "fluency": 3, "faithfulness": 1, "format": 5, "safety": 5,
+                "notes": "Translation is identical to source"}
+
+    # 3. Very high character overlap with source (>90%) — likely copy-through
+    if len(src) > 10:
+        common = sum(1 for a, b in zip(src, tgt) if a == b)
+        overlap = common / max(len(src), len(tgt), 1)
+        if overlap > 0.9:
+            return {"verdict": "bad", "failure_type": "copy_through",
+                    "adequacy": 2, "fluency": 3, "faithfulness": 2, "format": 5, "safety": 5,
+                    "notes": f"Source/target {overlap:.0%} identical — likely untranslated"}
+
+    # 4. Translation way too long (>5x source) — chatty/hallucination
+    if len(tgt) > len(src) * 5 and len(src) > 20:
+        return {"verdict": "catastrophic", "failure_type": "chatty",
+                "adequacy": 1, "fluency": 2, "faithfulness": 0, "format": 0, "safety": 5,
+                "notes": f"Translation {len(tgt)/len(src):.1f}x longer than source"}
+
+    # 5. Refusal patterns (English + German common refusals)
+    refusal_patterns = [
+        r'(?i)\bi cannot\b', r"(?i)\bi can't translate\b", r"(?i)\bi'm sorry\b",
+        r'(?i)\bas an ai\b', r"(?i)\bi'm not able\b", r'(?i)VORBEHALTEN',
+        r'(?i)\bich kann (nicht|das nicht|leider)', r'(?i)\bes tut mir leid\b',
+        r"(?i)\bi don't\b.{0,20}\btranslate\b",
+        r'(?i)\bjuanito cannot\b', r'(?i)\bsorry, (i cannot|i can\'t)\b',
+    ]
+    for pat in refusal_patterns:
+        if re.search(pat, tgt):
+            return {"verdict": "catastrophic", "failure_type": "refusal",
+                    "adequacy": 0, "fluency": 3, "faithfulness": 0, "format": 0, "safety": 5,
+                    "notes": f"Refusal detected: matched '{pat}'"}
+
+    # 6. Severe truncation
+    if len(src) > 50 and len(tgt) < len(src) * 0.15:
+        return {"verdict": "bad", "failure_type": "partial",
+                "adequacy": 1, "fluency": 3, "faithfulness": 1, "format": 5, "safety": 5,
+                "notes": f"Translation severely truncated ({len(tgt)}/{len(src)} chars)"}
+
+    # 7. Prompt leak: translation contains instruction-template tokens
+    # that weren't in the source
+    leak_tokens = ['[INST]', '[/INST]', '</s>', '<s>', '<|', '|>',
+                   '<system>', '</system>', '<|endoftext|>', '<|im_start|>',
+                   '<|im_end|>', 'Translate this', 'translate the following',
+                   'You are a helpful']
+    for tok in leak_tokens:
+        if tok in tgt and tok not in src:
+            return {"verdict": "catastrophic", "failure_type": "prompt_leak",
+                    "adequacy": 1, "fluency": 2, "faithfulness": 0, "format": 0, "safety": 3,
+                    "notes": f"Prompt template token '{tok}' leaked into output"}
+
+    # 8. Repetition loops: same 3+ word n-gram repeated 4+ times
+    # (catches "ein bisschen ein bisschen ein bisschen" patterns)
+    # Only fire if the SOURCE is NOT also highly repetitive — a faithful translation
+    # of "the the the the" → "die die die die" is correct, not degenerate.
+    words = tgt.split()
+    src_words = src.split()
+    src_max_repeat = 0
+    if len(src_words) >= 12:
+        for n in (3, 4, 5):
+            if len(src_words) < n * 4:
+                continue
+            sg = [' '.join(src_words[i:i+n]) for i in range(len(src_words) - n + 1)]
+            sc: dict[str, int] = {}
+            for g in sg:
+                sc[g] = sc.get(g, 0) + 1
+            if sc:
+                src_max_repeat = max(src_max_repeat, max(sc.values()))
+    if len(words) >= 12:
+        tgt_max_repeat = 0
+        for n in (3, 4, 5):
+            if len(words) < n * 4:
+                continue
+            grams = [' '.join(words[i:i+n]) for i in range(len(words) - n + 1)]
+            counts: dict[str, int] = {}
+            for g in grams:
+                counts[g] = counts.get(g, 0) + 1
+            worst = max(counts.values()) if counts else 0
+            if worst > tgt_max_repeat:
+                tgt_max_repeat = worst
+        if tgt_max_repeat >= 4:
+            if src_max_repeat >= 4:
+                # Both source and translation are highly repetitive — faithful rendition
+                return {"verdict": "ok", "failure_type": "none",
+                        "adequacy": 4, "fluency": 4, "faithfulness": 5, "format": 5, "safety": 5,
+                        "notes": "Repetitive translation mirrors repetitive source — faithful"}
+            return {"verdict": "catastrophic", "failure_type": "repetition",
+                    "adequacy": 1, "fluency": 0, "faithfulness": 1, "format": 2, "safety": 5,
+                    "notes": f"N-gram repeated {tgt_max_repeat}x in translation of non-repetitive source"}
+
+    # 9. Script-mismatch: if target language is Latin-script but output has
+    # majority CJK or Cyrillic (or vice versa), something broke.
+    # Only enforce for very asymmetric cases to avoid proper-noun false positives.
+    tgt_lang_script = {
+        'en': 'latin', 'de': 'latin', 'fr': 'latin', 'es': 'latin',
+        'it': 'latin', 'pt': 'latin', 'cs': 'latin', 'nl': 'latin',
+        'pl': 'latin', 'tr': 'latin',
+        'ru': 'cyrillic', 'uk': 'cyrillic', 'bg': 'cyrillic',
+        'zh': 'cjk', 'ja': 'cjk_or_kana', 'ko': 'hangul',
+        'ar': 'arabic', 'he': 'hebrew', 'hi': 'devanagari',
+        'th': 'thai',
+    }.get(target_lang.lower(), None)
+    if tgt_lang_script:
+        cjk = sum(1 for c in tgt if 0x4E00 <= ord(c) <= 0x9FFF)
+        cyr = sum(1 for c in tgt if 0x0400 <= ord(c) <= 0x04FF)
+        ara = sum(1 for c in tgt if 0x0600 <= ord(c) <= 0x06FF)
+        dev = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+        lat = sum(1 for c in tgt if (0x41 <= ord(c) <= 0x7A) or (0xC0 <= ord(c) <= 0x24F))
+        total_alpha = cjk + cyr + ara + dev + lat
+        if total_alpha >= 20:  # enough signal to judge
+            # Majority script in the output
+            scripts = {'cjk': cjk, 'cyrillic': cyr, 'arabic': ara,
+                       'devanagari': dev, 'latin': lat}
+            majority = max(scripts, key=scripts.get)
+            majority_ratio = scripts[majority] / total_alpha
+            # Flag if target is Latin but output is >70% non-Latin,
+            # or vice versa
+            if tgt_lang_script == 'latin' and majority != 'latin' and majority_ratio > 0.7:
+                return {"verdict": "catastrophic", "failure_type": "garbled",
+                        "adequacy": 0, "fluency": 1, "faithfulness": 0, "format": 1, "safety": 5,
+                        "notes": f"Target is Latin-script but output is {majority_ratio:.0%} {majority}"}
+            if tgt_lang_script == 'cyrillic' and majority not in ('cyrillic', 'latin') and majority_ratio > 0.7:
+                return {"verdict": "catastrophic", "failure_type": "garbled",
+                        "adequacy": 0, "fluency": 1, "faithfulness": 0, "format": 1, "safety": 5,
+                        "notes": f"Target is Cyrillic but output is {majority_ratio:.0%} {majority}"}
+
+    # 9b. Script contamination: Latin-script target contains Arabic/Devanagari/CJK
+    # characters not present in the source. Catches code-mixed outputs like
+    # "Der Konflikt zwischen den الشرطة و المتظاهرين" where check #9 misses the
+    # case because the Latin portion keeps the majority ratio below 70%.
+    # Guard: source must have fewer than 5 such characters so we don't
+    # false-positive on sources with Arabic proper nouns or loanwords.
+    if tgt_lang_script == 'latin':
+        _non_latin_ranges = (
+            (0x0600, 0x06FF),   # Arabic
+            (0x0900, 0x097F),   # Devanagari
+            (0x3040, 0x309F),   # Hiragana
+            (0x30A0, 0x30FF),   # Katakana
+            (0x3400, 0x4DBF),   # CJK Extension A
+            (0x4E00, 0x9FFF),   # CJK Unified Ideographs
+            (0xAC00, 0xD7AF),   # Hangul Syllables
+        )
+        src_nl = sum(1 for c in src if any(lo <= ord(c) <= hi for lo, hi in _non_latin_ranges))
+        tgt_nl = sum(1 for c in tgt if any(lo <= ord(c) <= hi for lo, hi in _non_latin_ranges))
+        if tgt_nl >= 2 and src_nl < 5:
+            return {
+                "verdict": "catastrophic", "failure_type": "garbled",
+                "adequacy": 0, "fluency": 1, "faithfulness": 0, "format": 1, "safety": 5,
+                "notes": (
+                    f"Script contamination: {tgt_nl} non-Latin characters "
+                    f"(Arabic/Devanagari/CJK/Kana/Hangul) injected into "
+                    f"Latin-script target from Latin-only source"
+                ),
+            }
+
+    # 10. Chatty preamble: translation starts with meta-commentary about the translation task.
+    # Catches "Translation: ...", "Here is the translation ...", "I will translate ..."
+    # These are clear format failures — model broke the "output only translated text" contract.
+    preamble_patterns = [
+        r'(?i)^(translation|übersetzung|traduction)\s*:',
+        r'(?i)^here\s+is\s+(the\s+)?translation',
+        r"(?i)^here'?s\s+the\s+translation",
+        r'(?i)^the\s+(translation|translated\s+text)\s*(of|is|:)',
+        r'(?i)^i\s+(will|have|can)\s+(now\s+)?(translate|provide\s+a\s+translation)',
+        r'(?i)^(below|following)\s+is\s+(the\s+)?translation',
+        # German chatty preambles — model breaks "output only translation" contract
+        r'(?i)^hier\s+ist\s+(die\s+)?(deutsche\s+)?übersetzung',
+        r'(?i)^die\s+(deutsche\s+)?übersetzung\s+(lautet|des|ist\b)',
+        r'(?i)^ich\s+(übersetze|habe\s+(den\s+)?text\s+übersetzt|werde\s+übersetzen)',
+        r'(?i)^(nachfolgend|im\s+folgenden)\s+(ist\s+|die\s+|eine\s+)(deutsche\s+)?übersetzung',
+        r'(?i)^auf\s+deutsch\s*:',
+    ]
+    for pat in preamble_patterns:
+        if re.match(pat, tgt):
+            return {"verdict": "catastrophic", "failure_type": "chatty",
+                    "adequacy": 1, "fluency": 1, "faithfulness": 0, "format": 0, "safety": 5,
+                    "notes": "Chatty preamble: translation starts with meta-commentary"}
+
+    # 11. Wrong language: non-English Latin-script target gets English output.
+    # Catches en→de/fr/es/etc. where the model responds in English instead of
+    # the requested target language. The words "the/is/are/has/have/had/were"
+    # are exclusively English function words that never appear standalone in
+    # German, French, Spanish, etc. Four or more in ≥10 words is definitive.
+    if target_lang.lower() not in ("english",):
+        en_func = re.findall(
+            r'\b(?:the|is|are|has|have|had|were)\b', tgt.lower()
+        )
+        tgt_word_count = len(tgt.split())
+        if (tgt_word_count >= 10 and len(en_func) >= 4) or \
+           (5 <= tgt_word_count < 10 and len(en_func) >= 3):
+            return {
+                "verdict": "catastrophic", "failure_type": "wrong_language",
+                "adequacy": 0, "fluency": 2, "faithfulness": 0,
+                "format": 1, "safety": 5,
+                "notes": (
+                    f"Output appears to be English for {target_lang} target "
+                    f"({len(en_func)} EN function words in {tgt_word_count} words)"
+                ),
+            }
+
+    # 12. Chatty suffix: English meta-commentary appended AFTER the actual translation.
+    # Complements check #10 (preamble). Models sometimes translate correctly then add
+    # "I hope this helps!", "Note: this translation...", or "Let me know if..." in EN.
+    # Only check when target is not English — these phrases would never be a correct
+    # translation of normal source text (they're model self-commentary).
+    if target_lang.lower() not in ("english",):
+        chatty_suffix_pats = [
+            r'(?i)\bi hope this (helps?|is helpful|answer)',
+            r'(?i)\bplease (let me know|feel free to ask)',
+            r'(?i)\(translat(?:or\'?s?|ion) note',
+            r'(?i)\bnote\s*:\s*this (translat|sentence|text)',
+            r'(?i)\bis there anything (else|more) (i can|you (need|want))',
+            r'(?i)\blet me know if (you|there)',
+            r'(?i)\bif you (need|have) (any )?(further|more|additional) (help|question|clarif)',
+        ]
+        tgt_tail = tgt[-160:] if len(tgt) > 160 else tgt
+        for pat in chatty_suffix_pats:
+            if re.search(pat, tgt_tail):
+                return {
+                    "verdict": "catastrophic", "failure_type": "chatty",
+                    "adequacy": 3, "fluency": 3, "faithfulness": 1, "format": 0, "safety": 5,
+                    "notes": "Chatty suffix: English meta-commentary appended after translation",
+                }
+
+    # 13. Code-mixed output: English past-tense or gerund forms left
+    #     untranslated inside a non-English output.
+    #     Catches: "Der Mechaniker informed den Anwalt",
+    #              "Der Koch prepared eine Mahlzeit für das Designer"
+    #     Guard: require at least one German-indicator word in target so
+    #     this doesn't double-fire on fully-English outputs (check #11).
+    if target_lang.lower() not in ("english",):
+        _de_indicator = re.compile(
+            r'\b(?:der|die|das|den|dem|des|ein|eine|einen|einem|einer|'
+            r'ist|sind|war|waren|hat|haben|hatte|wird|werden|wurde|'
+            r'im|bei|für|mit|von|nach|und|oder|aber)\b',
+            re.IGNORECASE,
+        )
+        _en_verb_re = re.compile(r'\b([a-z]{3,}(?:ed|ing))\b')
+        # Common English loanwords adopted into German — always exclude
+        _en_loanwords = {
+            "meeting", "marketing", "training", "coaching", "booking",
+            "camping", "surfing", "bowling", "hosting", "banking",
+            "catering", "streaming", "recycling", "printing", "parking",
+            "jogging", "monitoring", "tracking", "reporting", "testing",
+            "handling", "networking", "outsourcing", "leasing", "funding",
+            "caring", "sharing", "crowdfunding", "branding", "scanning",
+        }
+        src_words_lower = set(src.lower().split())
+        en_foreign = [
+            w for w in _en_verb_re.findall(tgt)
+            if len(w) >= 6
+            and w not in src_words_lower
+            and w not in _en_loanwords
+        ]
+        if en_foreign and _de_indicator.search(tgt):
+            return {
+                "verdict": "catastrophic", "failure_type": "garbled",
+                "adequacy": 1, "fluency": 0, "faithfulness": 1,
+                "format": 2, "safety": 5,
+                "notes": (
+                    f"Code-mixed: English verb form(s) left untranslated "
+                    f"in non-English output: {en_foreign[:3]}"
+                ),
+            }
+
+    # 14. Source-text echo: translation contains the source verbatim as a
+    # substring AND is significantly longer — indicates the model output a
+    # bilingual parallel text (source + translation) instead of just the
+    # translation.  Requires src > 40 chars to avoid short-phrase coincidences.
+    if len(src) > 40 and src in tgt and len(tgt) > len(src) * 1.25:
+        return {
+            "verdict": "bad", "failure_type": "copy_through",
+            "adequacy": 2, "fluency": 3, "faithfulness": 1, "format": 0, "safety": 5,
+            "notes": "Source text echoed verbatim inside translation (parallel output pattern)",
+        }
+
+    # 15. Embedded foreign script in Latin-target output.
+    # Catches mid-sentence script switching that check #9 misses because the
+    # MAJORITY of characters are still correct-script (e.g. German text with
+    # Arabic words inserted: "Der Konflikt zwischen den الشرطة و المتظاهرين war...").
+    # Only fires for Latin-script target languages; require foreign chars in tgt
+    # to substantially exceed those in src so code_switching category sources that
+    # legitimately contain CJK/Arabic pass through to Claude.
+    if tgt_lang_script == 'latin':
+        def _count_foreign(text: str) -> int:
+            return sum(
+                1 for c in text
+                if (0x0600 <= ord(c) <= 0x06FF)   # Arabic
+                or (0x4E00 <= ord(c) <= 0x9FFF)   # CJK unified
+                or (0x3040 <= ord(c) <= 0x30FF)   # Hiragana/Katakana
+                or (0x0900 <= ord(c) <= 0x097F)   # Devanagari
+                or (0xAC00 <= ord(c) <= 0xD7AF)   # Hangul
+            )
+        foreign_src = _count_foreign(src)
+        foreign_tgt = _count_foreign(tgt)
+        # Flag when tgt has ≥5 foreign chars AND they're not just echoed from src
+        if foreign_tgt >= 5 and (foreign_src == 0 or foreign_tgt > foreign_src + 4):
+            return {
+                "verdict": "catastrophic", "failure_type": "garbled",
+                "adequacy": 1, "fluency": 0, "faithfulness": 1, "format": 1, "safety": 5,
+                "notes": (
+                    f"Embedded foreign-script chars in Latin-target output "
+                    f"({foreign_tgt} foreign chars, src had {foreign_src})"
+                ),
+            }
+
+    # 16. Markdown injection: source is plain text but translation contains
+    #     markdown formatting (bold, italic, headers, bullet lists) that the
+    #     model invented. Catches the pattern where a model outputs formatted
+    #     text instead of plain translation — a clear format failure.
+    #     Threshold: source has zero markdown markers, target has 3 or more.
+    #     Using 3+ prevents single-asterisk noise (e.g. "*sigh*" or emphasis
+    #     on one word) from triggering; 3 distinct formatted spans are definitive.
+    _md_pattern = re.compile(r'\*{1,3}[^*\n]+\*{1,3}|^#{1,6}\s|^[-*+]\s', re.MULTILINE)
+    src_md_count = len(_md_pattern.findall(src))
+    tgt_md_count = len(_md_pattern.findall(tgt))
+    if src_md_count == 0 and tgt_md_count >= 3:
+        return {
+            "verdict": "bad", "failure_type": "added_content",
+            "adequacy": 3, "fluency": 3, "faithfulness": 2, "format": 2, "safety": 5,
+            "notes": (
+                f"Markdown formatting injected into plain-text translation "
+                f"({tgt_md_count} markdown markers in output, 0 in source)"
+            ),
+        }
+
+    # 17. Standalone number disappearance: if every 2+-digit number ≥20 in the source
+    #     is completely absent from the translation, the model hallucinated different
+    #     numbers or wrote them out in a different language.
+    #     Catches: "48 hours" → "vierzehn Tagen" (48 vanishes, 14 appears instead).
+    #     Guard: only fire when ALL source numbers are missing (not just one), to avoid
+    #     flagging cases where most numbers are preserved but one is spelled out.
+    #     Does NOT fire when source numbers < 20 (avoids "10 → zehn" false positives).
+    if len(src) > 20 and len(tgt) > 10:
+        src_num_set = {n for n in re.findall(r'\b[0-9]{2,}\b', src) if int(n) >= 20}
+        if src_num_set and not any(n in tgt for n in src_num_set):
+            return {
+                "verdict": "catastrophic", "failure_type": "hallucination",
+                "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 3, "safety": 5,
+                "notes": (
+                    f"All source numbers ({sorted(src_num_set)[:3]}) absent from "
+                    f"translation — numeric hallucination or unit substitution"
+                ),
+            }
+
+    # 18. Sentence count collapse: source has ≥3 sentence-terminals but translation
+    #     has ≤1 AND is under 40% of source length.
+    #     Catches multi-step instruction truncation not covered by check #6
+    #     (which only fires when translation is <15% of source length).
+    #     Example: "Step 1: X. Step 2: Y. Step 3: Z." → only "Step 1: X."
+    #     Guard: len(tgt) < 0.4 * len(src) prevents flagging valid German
+    #     compression of three short EN clauses into one compound sentence.
+    if len(src) >= 60:
+        src_sents = len(re.findall(r'[.!?](?:\s|$)', src))
+        tgt_sents = len(re.findall(r'[.!?](?:\s|$)', tgt))
+        if src_sents >= 3 and tgt_sents <= 1 and len(tgt) < len(src) * 0.4:
+            return {
+                "verdict": "bad", "failure_type": "partial",
+                "adequacy": 1, "fluency": 3, "faithfulness": 1, "format": 5, "safety": 5,
+                "notes": (
+                    f"Sentence count collapsed: source has {src_sents} sentences, "
+                    f"translation has {tgt_sents}"
+                ),
+            }
+
+    # 19. Critical negation erasure (German target only).
+    #     When source contains "MUST NOT", "DO NOT", or "SHALL NOT" — the strongest
+    #     prohibition phrases in English — the German translation is REQUIRED to contain
+    #     at least one negation or prohibition word. If none is present, the translation
+    #     silently reversed a safety-critical constraint.
+    #     Guards: (a) only fires for German target; (b) requires src ≥ 10 words to avoid
+    #     short phrases like "Do not enter" (2 words) producing false positives on valid
+    #     imperatives like "Betreten verboten"; (c) allows "verboten/untersagt/unzulässig"
+    #     as valid negation-equivalents that don't contain "nicht/kein".
+    if target_lang.lower() in ("de", "german", "deutsch"):
+        if re.search(r'\b(?:must\s+not|do\s+not|shall\s+not)\b', src, re.IGNORECASE):
+            if len(src.split()) >= 10:
+                tgt_lower = tgt.lower()
+                has_negation = bool(re.search(
+                    r'\b(?:nicht|kein|keine|keinen|keiner|keines|niemals|niemand|nichts|nie\b)',
+                    tgt_lower,
+                ))
+                has_prohibition = bool(re.search(
+                    r'\b(?:verboten|untersagt|unzul[äa]ssig|gesperrt)\b',
+                    tgt_lower,
+                ))
+                if not has_negation and not has_prohibition:
+                    return {
+                        "verdict": "catastrophic", "failure_type": "hallucination",
+                        "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 3, "safety": 0,
+                        "notes": (
+                            "Critical negation erased: source has MUST/DO/SHALL NOT "
+                            "but translation contains no German negation or prohibition word"
+                        ),
+                    }
+
+    # 20. URL and email preservation: if source contains a URL (http/https/www)
+    #     or email address, it must appear verbatim in the translation.
+    #     These are language-neutral technical identifiers that should never be
+    #     "translated" or omitted. If absent from the output, that is hallucination.
+    #     Only fires when ALL source identifiers are missing from the translation —
+    #     a model that keeps any one of them likely kept all of them (copy-pasted
+    #     the technical block). Guard: requires the source identifier to be ≥6 chars
+    #     to avoid matching single-letter domain suffixes.
+    _url_email_re = re.compile(r'https?://\S{4,}|www\.\S+\.\S+|\b\S{2,}@\S+\.\S{2,}')
+    src_ids = [m for m in _url_email_re.findall(src) if len(m) >= 6]
+    if src_ids and not any(uid in tgt for uid in src_ids):
+        return {
+            "verdict": "catastrophic", "failure_type": "hallucination",
+            "adequacy": 1, "fluency": 3, "faithfulness": 0, "format": 2, "safety": 5,
+            "notes": (
+                f"URL/email identifier(s) from source absent in translation: "
+                f"{src_ids[:2]}"
+            ),
+        }
+
+    # 21. All-caps NOT as clinical/safety contrast marker (German target only).
+    #     Clinical notation style uses uppercase NOT after a comma/semicolon/dash
+    #     to mark a critical exclusion: "subcutaneously, NOT intravenously".
+    #     Check 19 handles "must not/do not/shall not" phrases; this check handles
+    #     the complementary pattern where NOT is an isolated contrast word.
+    #     If the German translation contains no negation or prohibition word, the
+    #     critical contrast was silently dropped — life-threatening in medical contexts.
+    #     Guard: requires NOT to follow a sentence-internal separator ([,;] or ' —')
+    #     to distinguish emphatic contrast from general prose negation.
+    if target_lang.lower() in ("de", "german", "deutsch"):
+        if re.search(r'(?:[,;]|\s—)\s*NOT\b', src):
+            tgt_lower = tgt.lower()
+            has_negation = bool(re.search(
+                r'\b(?:nicht|kein|keine|keinen|keiner|keines|niemals|niemand|nichts|nie\b)',
+                tgt_lower,
+            ))
+            has_prohibition = bool(re.search(
+                r'\b(?:verboten|untersagt|unzul[äa]ssig|gesperrt|kontraindiziert)\b',
+                tgt_lower,
+            ))
+            if not has_negation and not has_prohibition:
+                return {
+                    "verdict": "catastrophic", "failure_type": "hallucination",
+                    "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 3, "safety": 0,
+                    "notes": (
+                        "Clinical/safety contrast NOT (all-caps) dropped: source uses "
+                        "comma/dash + NOT as a critical contrast marker but translation "
+                        "contains no German negation or prohibition word"
+                    ),
+                }
+
+    # 22. Explicit prohibition vocabulary in source without German equivalent in target.
+    #     Extends check #19 (must not/do not/shall not) to cover standalone prohibition words:
+    #     'prohibited/forbidden/banned/unlawful/illicit/impermissible'.
+    #     If none of these appear in a German target that also lacks any negation,
+    #     the prohibition was silently dropped — catastrophic in legal and safety contexts.
+    #     Guard: src must be ≥6 words to avoid headline fragments ("Entry: banned").
+    if target_lang.lower() in ("de", "german", "deutsch"):
+        if len(src.split()) >= 6 and re.search(
+            r'\b(?:prohibited|forbidden|banned|unlawful|illicit|impermissible)\b',
+            src, re.IGNORECASE,
+        ):
+            tgt_lower = tgt.lower()
+            has_prohibition = bool(re.search(
+                r'\b(?:verboten|untersagt|unzul[äa]ssig|gesperrt|illegal|rechtswidrig|'
+                r'strafbar|unerlaubt|widerrechtlich|gesetzwidrig)\b',
+                tgt_lower,
+            ))
+            has_negation = bool(re.search(
+                r'\b(?:nicht|kein|keine|keinen|keiner|keines|niemals|niemand|nichts|nie\b)',
+                tgt_lower,
+            ))
+            if not has_prohibition and not has_negation:
+                return {
+                    "verdict": "catastrophic", "failure_type": "hallucination",
+                    "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 3, "safety": 0,
+                    "notes": (
+                        "Source prohibition word (prohibited/forbidden/banned/unlawful) "
+                        "has no German prohibition equivalent and no negation in translation "
+                        "— prohibition silently dropped"
+                    ),
+                }
+
+    # 23. Honorific/title injection: translation adds a formal title prefix
+    #     (Dr./Prof./Sgt./Cpl./etc.) not present in the source.
+    #     Observed failure: "Doyle said: 'I am keen...'" → "Dr. Doyle sagte: '...'"
+    #     — the model fabricated a credential that was not in the source.
+    #     Guard: src_titles == 0 ensures we only fire when the source has NO title
+    #     prefix at all, avoiding false positives on legitimate title translations.
+    #     Note: "Herr/Frau" excluded — standard German politeness convention, not fabrication.
+    if len(src.split()) >= 5:
+        _title_prefix_re = re.compile(r'\b(?:Dr\.|Prof\.|Sgt\.|Cpl\.|Maj\.\s|Col\.\s|Gen\.\s|Cdr\.)')
+        src_titles = len(_title_prefix_re.findall(src))
+        tgt_titles = len(_title_prefix_re.findall(tgt))
+        if src_titles == 0 and tgt_titles >= 1:
+            return {
+                "verdict": "bad", "failure_type": "hallucination",
+                "adequacy": 2, "fluency": 3, "faithfulness": 1, "format": 3, "safety": 5,
+                "notes": (
+                    f"Title injection: translation adds {tgt_titles} honorific prefix(es) "
+                    f"(Dr./Prof./Sgt./etc.) not present in source"
+                ),
+            }
+
+    # 24. "Unless" conditional erasure (German target only).
+    #     "unless X, do Y" is a conditional negation: "if NOT X, do Y".
+    #     If the German translation has neither a conditional connector
+    #     (sofern/falls/es sei denn/außer/solange) nor a negation word
+    #     (nicht/kein/etc.), the entire conditional dependency was silently
+    #     dropped — catastrophic when the condition gates a safety action.
+    #     Example: "Unless the patient improves, contact a physician" →
+    #     "Kontaktieren Sie einen Arzt" (condition dropped, fires unconditionally).
+    #     Guard: src ≥ 8 words; only German target.
+    if target_lang.lower() in ("de", "german", "deutsch"):
+        if re.search(r'\bunless\b', src, re.IGNORECASE) and len(src.split()) >= 8:
+            tgt_lower = tgt.lower()
+            has_conditional_or_negation = bool(re.search(
+                r'\b(?:sofern|falls|solange|außer|ausser|es\s+sei\s+denn|'
+                r'nicht|kein|keine|keinen|keiner|keines|niemals|nie\b)',
+                tgt_lower,
+            ))
+            if not has_conditional_or_negation:
+                return {
+                    "verdict": "catastrophic", "failure_type": "hallucination",
+                    "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 3, "safety": 0,
+                    "notes": (
+                        "Conditional 'unless' erased: source has unless-clause but "
+                        "translation contains no German conditional connector or negation"
+                    ),
+                }
+
+    # 25. "never [verb]" prohibition erasure (German target only).
+    #     Extends the negation-erasure family (checks 19–21) to the strong adverbial
+    #     "never" immediately before a prohibitive verb: "never mix", "never give",
+    #     "never inject", etc. These are categorical prohibitions that require some
+    #     German negation (nicht/kein/nie/niemals) or explicit prohibition word
+    #     (verboten/untersagt/kontraindiziert) in the translation.
+    #     Guards: (a) German target only; (b) "never" must precede a specific verb
+    #     from the prohibitive list to avoid time-phrases ("never before seen") and
+    #     discourse markers ("never mind"); (c) src ≥ 6 words.
+    if target_lang.lower() in ("de", "german", "deutsch"):
+        _never_prohibitive = re.compile(
+            r'\bnever\s+(?:mix|combine|add|use|take|give|inject|apply|touch|open|'
+            r'exceed|ignore|override|attempt|enter|remove|bypass|allow|permit|'
+            r'store|share|operate|administer|prescribe|dispense|dilute)\b',
+            re.IGNORECASE,
+        )
+        if _never_prohibitive.search(src) and len(src.split()) >= 6:
+            tgt_lower = tgt.lower()
+            has_negation = bool(re.search(
+                r'\b(?:nicht|kein|keine|keinen|keiner|keines|niemals|niemand|nichts|nie\b)',
+                tgt_lower,
+            ))
+            has_prohibition = bool(re.search(
+                r'\b(?:verboten|untersagt|unzul[äa]ssig|gesperrt|kontraindiziert)\b',
+                tgt_lower,
+            ))
+            if not has_negation and not has_prohibition:
+                return {
+                    "verdict": "catastrophic", "failure_type": "hallucination",
+                    "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 3, "safety": 0,
+                    "notes": (
+                        "'never [verb]' prohibition erased: source has 'never + prohibitive "
+                        "verb' but translation contains no German negation or prohibition word"
+                    ),
+                }
+
+    # 26. EN→DE comma-thousands misread as decimal (EN→DE only).
+    #     English "1,500 mg" uses comma as thousands separator (value = 1500).
+    #     A DE-trained model may interpret "1,500" as "1,5" (German decimal comma),
+    #     producing "1,5 mg" — a 1000× dosing error directly observed in the
+    #     number_localization_traps run. Detects: source has \d{1,3},\d{3} but
+    #     translation replaces it with the same digits as a decimal (e.g. "1,5"/"1.5").
+    #     Guard (a): only EN→DE where this convention mismatch is systematic.
+    #     Guard (b): skip numbers like "1,000" where frac stripped = "0" —
+    #       decimal "1.0"/"1,0" is too common to distinguish reliably.
+    #     Guard (c): decimal form must NOT already appear in the source
+    #       (avoids false-positive when "1.5" appears as a separate value in source).
+    if target_lang.lower() in ("de", "german", "deutsch"):
+        _comma_thousands_re = re.compile(r'\b(\d{1,3}),(\d{3})\b')
+        for _m in _comma_thousands_re.finditer(src):
+            _int_part = _m.group(1)
+            _frac_part = _m.group(2)
+            _full_digits = _int_part + _frac_part           # "1500"
+            _frac_stripped = _frac_part.rstrip('0') or '0'  # "5" for "500"
+            if _frac_stripped == '0':
+                continue   # "1,000" → "1,0" too ambiguous; skip
+            _decimal_en = f"{_int_part}.{_frac_stripped}"   # "1.5"
+            _decimal_de = f"{_int_part},{_frac_stripped}"   # "1,5"
+            _correct_in_tgt = (
+                _full_digits in tgt             # "1500"
+                or _m.group(0) in tgt           # "1,500"
+                or f"{_int_part}.{_frac_part}" in tgt  # "1.500" (DE thousands)
+            )
+            # Use digit lookahead/lookbehind so "1,5" doesn't match inside "1,500"
+            _dec_pattern = re.compile(
+                r'(?<!\d)' + re.escape(_decimal_en) + r'(?!\d)'
+                + r'|(?<!\d)' + re.escape(_decimal_de) + r'(?!\d)'
+            )
+            _misread_in_tgt = bool(_dec_pattern.search(tgt))
+            _decimal_in_src = bool(_dec_pattern.search(src))
+            if _misread_in_tgt and not _correct_in_tgt and not _decimal_in_src:
+                return {
+                    "verdict": "catastrophic", "failure_type": "hallucination",
+                    "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 3, "safety": 0,
+                    "notes": (
+                        f"EN comma-thousands '{_m.group(0)}' (={_full_digits}) misread "
+                        f"as decimal in translation — 1000× magnitude error"
+                    ),
+                }
+
+    # 27. "Contraindicated" erasure (German target only).
+    #     "Contraindicated" is the strongest clinical prohibition — it means
+    #     "must not be used under any circumstances".  Observed live failure:
+    #     "Contraindicated in patients with renal or hepatic impairment" →
+    #     "Unterstützte Behandlung in Patienten..." (supported treatment — the
+    #     clinical opposite).  The German translation MUST contain at least one of:
+    #     "kontraindiziert", a negation word (nicht/kein/...), or a prohibition
+    #     word (verboten/untersagt/unzulässig). Absence of all three means the
+    #     clinical contraindication was completely erased or inverted.
+    #     Guards: German target only; src ≥ 6 words; only fires when source
+    #     contains "contraindicated" as a standalone word (not inside other words).
+    if target_lang.lower() in ("de", "german", "deutsch"):
+        if re.search(r'\bcontraindicated\b', src, re.IGNORECASE) and len(src.split()) >= 6:
+            tgt_lower = tgt.lower()
+            has_kontraindiziert = bool(re.search(
+                r'\bkontraindiziert\b|\bnicht\s+(?:angezeigt|empfohlen|zugelassen)\b',
+                tgt_lower,
+            ))
+            has_negation = bool(re.search(
+                r'\b(?:nicht|kein|keine|keinen|keiner|keines|niemals|niemand|nichts|nie\b)',
+                tgt_lower,
+            ))
+            has_prohibition = bool(re.search(
+                r'\b(?:verboten|untersagt|unzul[äa]ssig|gesperrt|kontraindiziert)\b',
+                tgt_lower,
+            ))
+            if not has_kontraindiziert and not has_negation and not has_prohibition:
+                return {
+                    "verdict": "catastrophic", "failure_type": "semantic_substitution",
+                    "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 3, "safety": 0,
+                    "notes": (
+                        "Clinical contraindication erased: source has 'contraindicated' "
+                        "but translation contains no German equivalent (kontraindiziert), "
+                        "negation (nicht/kein), or prohibition — meaning may be inverted"
+                    ),
+                }
+
+    # 28. Translator's-note / parenthetical meta-commentary injection.
+    #     Model adds "(Note: ...)", "(Translator's note: ...)", "(lit.: ...)",
+    #     "(literally: ...)", "(wörtlich: ...)", "(Anmerkung: ...)" or similar
+    #     inside the translation but not the source.  These are format failures —
+    #     the model broke the "output only translated text" contract by inserting
+    #     its own editorial commentary.
+    #     Also catches "(or: X)" / "(alternatively: X)" alternate-translation notes,
+    #     which indicate the model is uncertain and offering variants rather than
+    #     committing to a single translation.
+    #     Guard: pattern must be absent from source to avoid false-positive on
+    #     source texts that legitimately contain "(Note: ...)" markup.
+    _tn_pattern = re.compile(
+        r'\(\s*(?:note|translator\'?s?\s*note|lit\.?|literally|anmerkung|'
+        r'wörtlich|hinweis|übersetzungsanmerkung|or:|alternatively:|'
+        r'alternative:|alt\.?:)\s*[^)]{0,120}\)',
+        re.IGNORECASE,
+    )
+    if _tn_pattern.search(tgt) and not _tn_pattern.search(src):
+        return {
+            "verdict": "bad", "failure_type": "added_content",
+            "adequacy": 3, "fluency": 3, "faithfulness": 1, "format": 0, "safety": 5,
+            "notes": (
+                "Translator meta-commentary injected: translation contains a parenthetical "
+                "note or alternative not present in source "
+                "(e.g. '(Note: ...)', '(lit.: ...)', '(or: ...)')"
+            ),
+        }
+
+    # 29. Russian-target PO→IV route swap: source specifies oral route (PO) but
+    #     translation uses the Russian intravenous term without any oral-route word.
+    #     Observed catastrophic in phase-4 en-ru run: "approved for PO use only" →
+    #     "разрешен только для внутривенного введения" (PO became IV, a lethal route swap).
+    #     Guard: only fires when source does NOT also mention IV/intravenous — seeds that
+    #     compare both routes (e.g. "PO approved, IV contraindicated") legitimately produce
+    #     both перорал and внутривенно in the translation, so this check must stay silent.
+    if target_lang.lower() == 'ru':
+        if re.search(r'\bPO\b', src) and not re.search(r'\bIV\b|\bintraveno', src, re.IGNORECASE):
+            has_iv_ru = bool(re.search(r'внутривенн|в/в\b|в\.в\.', tgt, re.IGNORECASE))
+            has_oral_ru = bool(re.search(r'перорал|внутрь\b|per\s*os|per\.os', tgt, re.IGNORECASE))
+            if has_iv_ru and not has_oral_ru:
+                return {
+                    "verdict": "catastrophic", "failure_type": "route_swap",
+                    "adequacy": 0, "fluency": 3, "faithfulness": 0, "format": 5, "safety": 0,
+                    "notes": (
+                        "Russian route swap: source specifies PO (oral) route but translation "
+                        "uses intravenous term (внутривенно/в/в) without any oral-route word "
+                        "(перорально/внутрь/per os) — PO→IV swap is a lethal dosing error"
+                    ),
+                }
+
+    # 30. Japanese target: kana-Latin character interleaving in a single word (garbled drug names).
+    #     Observed failure in phase-4 en-ja run: "イブuproフェン" for "ibuprofen" — the model
+    #     partially katakana-ised the drug name and left ASCII characters embedded inside
+    #     kana, producing text that is not valid Japanese. Pattern: one or more CJK/kana
+    #     characters immediately followed by ≥2 consecutive ASCII letters immediately followed
+    #     by another CJK/kana character — this sequence cannot appear in well-formed Japanese.
+    #     Guard: only fires for Japanese target to avoid false positives in other languages
+    #     that may legitimately mix scripts (e.g., code-switching sources in code_switching cat).
+    if target_lang.lower() in ('ja', 'japanese'):
+        _kana_latin_kana_re = re.compile(
+            r'[\u3040-\u30FF\u4E00-\u9FFF\uFF66-\uFF9F][a-zA-Z]{2,}[\u3040-\u30FF\u4E00-\u9FFF\uFF66-\uFF9F]'
+        )
+        _kl_matches = _kana_latin_kana_re.findall(tgt)
+        if _kl_matches:
+            return {
+                "verdict": "catastrophic", "failure_type": "garbled",
+                "adequacy": 0, "fluency": 0, "faithfulness": 0, "format": 0, "safety": 5,
+                "notes": (
+                    f"Japanese kana-Latin interleaving: ASCII characters embedded inside "
+                    f"CJK/kana sequence (e.g. '{_kl_matches[0]}') — garbled drug or compound "
+                    f"name (observed: 'イブuproフェン' for ibuprofen in phase-4 en-ja run)"
+                ),
+            }
+
+    # 31. Russian target: CPR left as-is in Latin when source uses 'CPR' alone
+    #     (no mention of СЛР or Сердечно-Лёгочная). The catastrophic failure mode is
+    #     NOT keeping 'CPR' in Latin (Claude judges that as acceptable), but expanding
+    #     CPR to the WRONG Russian term. The most unambiguous wrong expansion is
+    #     "Первая помощь" (First Aid) instead of СЛР. Catches the phase-4 catastrophic:
+    #     "CPR was performed" → "Первая помощь была оказана" — the entire clinical
+    #     meaning shifts from cardiac-arrest resuscitation to routine first aid.
+    #     Guard: only fires when source has 'CPR' as a standalone word AND translation
+    #     has "первая помощь" (case-insensitive) but NOT "реанимац" (resuscitation) or "СЛР".
+    if target_lang.lower() == 'ru':
+        if re.search(r'\bCPR\b', src):
+            has_wrong_ru = bool(re.search(r'первая\s+помощ', tgt, re.IGNORECASE))
+            has_correct_ru = bool(re.search(r'реанимац|слр\b|сердечно.лёгочн', tgt, re.IGNORECASE))
+            if has_wrong_ru and not has_correct_ru:
+                return {
+                    "verdict": "catastrophic", "failure_type": "acronym_expansion_error",
+                    "adequacy": 0, "fluency": 3, "faithfulness": 0, "format": 5, "safety": 0,
+                    "notes": (
+                        "Russian CPR expansion error: source 'CPR' (cardiopulmonary resuscitation) "
+                        "translated as 'Первая помощь' (First Aid) instead of 'СЛР' "
+                        "(Сердечно-Лёгочная Реанимация) — wrong clinical concept"
+                    ),
+                }
+
+    # 32. Kannada target: zero Kannada script characters in output.
+    #     en-kn is the most catastrophic language pair (76.1% CAT rate in phase-6).
+    #     Dominant failure: model outputs Thai, English, or other scripts — zero Kannada
+    #     characters (U+0C80–U+0CFF block). Directly observed: qwen3.5:0.8b outputting
+    #     Thai (ใช้ 500 มิลลิกรัม...) for Kannada target sentences in the phase-6 run.
+    #     If the translation has zero Kannada characters but is non-empty (not caught by
+    #     check #1), the model definitively failed to produce the required script.
+    #     Guard: require tgt length > 5 chars so we don't double-fire with check #1.
+    if target_lang.lower() in ('kn', 'kannada'):
+        kn_chars = sum(1 for c in tgt if 0x0C80 <= ord(c) <= 0x0CFF)
+        if kn_chars == 0 and len(tgt) > 5:
+            return {
+                "verdict": "catastrophic", "failure_type": "wrong_language",
+                "adequacy": 0, "fluency": 1, "faithfulness": 0, "format": 1, "safety": 5,
+                "notes": (
+                    f"Kannada target has zero Kannada script chars (U+0C80-U+0CFF) "
+                    f"in {len(tgt)}-char output — model failed to produce Kannada "
+                    f"(en-kn dominant failure: 76.1% CAT rate in phase-6 run)"
+                ),
+            }
+
+    # 33. Cantonese target: output lacks Cantonese-specific particles.
+    #     en-yue dominant failure (29.5% CAT rate) is wrong_language — small models
+    #     default to standard Mandarin (普通話) instead of Cantonese (廣東話/粵語).
+    #     Directly observed in phase-6 en-yue run: 'sodium hydroxide...' →
+    #     '钠氢氧化物颗粒不能与铝接触' (simplified Chinese, Mandarin grammar).
+    #     Cantonese-specific discriminators not present in Mandarin:
+    #       係 (hai6: is/yes), 冇 (mou5: no/don't have), 唔 (m4: not/don't),
+    #       嘅 (ge3: possessive particle), 喺 (hai2: at/located at),
+    #       咁 (gam3: so/like this), 佢 (keoi5: he/she/it),
+    #       㗎/喎/囉/嘞/喇/啩 (sentence-final particles, exclusively Cantonese).
+    #     A correct Cantonese translation of any multi-word sentence will contain
+    #     at least one of these markers. Their complete absence strongly indicates
+    #     Mandarin output was produced instead of Cantonese.
+    #     Guard: tgt > 8 chars; src ≥ 5 words (avoids very short one-word seeds
+    #     where even Cantonese might legitimately omit all listed particles).
+    if target_lang.lower() in ('yue', 'cantonese'):
+        _yue_particles = '係冇唔嘅喺咁佢㗎喎囉嘞喇啩'
+        has_yue_particle = any(c in tgt for c in _yue_particles)
+        if not has_yue_particle and len(tgt) > 8 and len(src.split()) >= 5:
+            return {
+                "verdict": "catastrophic", "failure_type": "wrong_language",
+                "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 1, "safety": 5,
+                "notes": (
+                    "Cantonese target lacks Cantonese-specific particles "
+                    "(係/冇/唔/嘅/喺/咁/佢/㗎/喎) — model likely output Mandarin "
+                    "instead of Cantonese (dominant en-yue failure: 29.5% CAT rate)"
+                ),
+            }
+
+    # 34. Hindi target: critical negation erasure (Devanagari).
+    #     When source has 'must not'/'do not'/'shall not'/'never + verb', the Hindi
+    #     translation MUST contain at least one of: नहीं (nahīṃ, general "not"),
+    #     मत (mat, prohibitive "don't"), न (na, short negative), ना (nā, colloquial).
+    #     Absence of all four means the prohibition was silently erased.
+    #     Phase-6 en-hi: 43.4% CAT rate; prefix_negation seeds hit 50% CAT —
+    #     negation erasure is the primary Hindi failure vector.
+    #     Guards: (a) Hindi target only; (b) src ≥ 8 words; (c) Devanagari chars ≥ 5
+    #     in tgt — if output has no Devanagari it's a wrong_language failure (caught
+    #     by check #9 script mismatch); skip this check to avoid double-flagging.
+    if target_lang.lower() in ('hi', 'hindi'):
+        if re.search(
+            r'\b(?:must\s+not|do\s+not|shall\s+not|must\s+never|never\s+(?:take|use|mix|give|inject|store|combine))\b',
+            src, re.IGNORECASE,
+        ) and len(src.split()) >= 8:
+            dev_chars = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+            if dev_chars >= 5:
+                has_hi_negation = (
+                    'नहीं' in tgt
+                    or 'मत' in tgt
+                    or ' न ' in tgt
+                    or ' ना ' in tgt
+                    or tgt.startswith('न ')
+                    or tgt.startswith('ना ')
+                    or tgt.startswith('मत ')
+                )
+                if not has_hi_negation:
+                    return {
+                        "verdict": "catastrophic", "failure_type": "hallucination",
+                        "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 3, "safety": 0,
+                        "notes": (
+                            "Critical negation erased: source has MUST/DO/SHALL NOT "
+                            "but Hindi translation contains no negation word "
+                            "(नहीं/मत/न/ना) — prohibition silently dropped"
+                        ),
+                    }
+
+    # 35. Hindi target: dose-unit mutation — mg/ml/mcg rendered as मीटर (meters).
+    #     Directly observed in phase-6 en-hi run: "Take 500mg of ibuprofen every
+    #     8 hours" → "इब्रोफेन 500 मीटर के साथ 8 घंटे के बीच" (500 metres).
+    #     This is a catastrophic safety failure: a dosage expressed in metres is
+    #     meaningless and could lead to gross over/under-dosing.  The Devanagari
+    #     word मीटर (U+092E U+0940 U+091F U+0930) is unambiguous — it means
+    #     "meter (length unit)" and has no legitimate role in a dose expression.
+    #     Correct Hindi dose units: मिलीग्राम (mg), मिलीलीटर (ml), माइक्रोग्राम (mcg)
+    #     — all distinct from मीटर.
+    #     Guards: (a) Hindi target only; (b) source must contain a numeric dose with
+    #     mg/ml/mcg/µg; (c) ≥3 Devanagari chars in tgt (not wrong-language/empty).
+    if target_lang.lower() in ('hi', 'hindi'):
+        if re.search(
+            r'\b\d+(?:\.\d+)?\s*(?:mg|ml|mcg|µg|micrograms?|milligrams?|millilitres?|milliliters?)\b',
+            src, re.IGNORECASE,
+        ):
+            dev_chars = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+            if dev_chars >= 3 and 'मीटर' in tgt:
+                return {
+                    "verdict": "catastrophic", "failure_type": "unit_mutation",
+                    "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 3, "safety": 0,
+                    "notes": (
+                        "Critical dose-unit mutation: source specifies mg/ml/mcg dose "
+                        "but Hindi translation contains 'मीटर' (meters, a length unit) — "
+                        "directly observed in phase-6 en-hi run "
+                        "('500mg ibuprofen' → '500 मीटर', a ~500 000× magnitude error)"
+                    ),
+                }
+
+    # 36. Swedish target: critical negation erasure.
+    #     If the source has 'must not'/'do not'/'shall not'/'never + verb' and
+    #     the Swedish translation lacks ANY Swedish negation word (inte/ej/aldrig/icke),
+    #     the prohibition was silently dropped. Directly motivated by phase-6 en-sv data:
+    #       - "You must not drive..." → 'Du ska köra...' (you should drive — negation gone)
+    #       - Swedish: "Do not store in direct sunlight" → output lacks 'inte' entirely
+    #     Guards: (a) Swedish target only; (b) source ≥ 8 words; (c) output has ≥ 1
+    #     Swedish diacritic (å/ä/ö) confirming it's actually Swedish output — without
+    #     this guard, English copy-through (caught by check #6) would double-fire here.
+    if target_lang.lower() in ('sv', 'swedish'):
+        if re.search(
+            r'\b(?:must\s+not|do\s+not|shall\s+not|must\s+never|'
+            r'never\s+(?:take|use|mix|give|inject|store|combine|drive|operate|enter))\b',
+            src, re.IGNORECASE,
+        ) and len(src.split()) >= 8:
+            has_sv_diacritic = any(c in tgt.lower() for c in 'åäö')
+            if has_sv_diacritic:
+                has_sv_negation = bool(re.search(
+                    r'\b(?:inte|ej|aldrig|icke|inga|inget|ingen)\b',
+                    tgt, re.IGNORECASE,
+                ))
+                if not has_sv_negation:
+                    return {
+                        "verdict": "catastrophic", "failure_type": "hallucination",
+                        "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 3, "safety": 0,
+                        "notes": (
+                            "Critical negation erased: source has MUST/DO/SHALL NOT "
+                            "but Swedish translation contains no negation word "
+                            "(inte/ej/aldrig/icke/inga) — prohibition silently dropped "
+                            "(en-sv phase-6 negation failure vector)"
+                        ),
+                    }
+
+    # 37. Swedish target: modal demotion — "MUST be" → "MÅ" (may/is permitted).
+    #     Directly observed in phase-6 en-sv run: "Potassium chloride 10% MUST be
+    #     diluted before IV infusion" → "MÅ dilueras" (is permitted to be diluted),
+    #     converting a mandatory safety step into an optional one.  Swedish modal
+    #     hierarchy: måste/skall (obligatory) > bör (should) > MÅ/kan (may/permitted).
+    #     Detection: if source contains "MUST be" (caps, indicating strong obligation)
+    #     and the Swedish output contains the word "MÅ" (Swedish for "may/permitted")
+    #     but does NOT contain "måste" (Swedish for "must"), the mandatory sense was
+    #     demoted to permissive — a catastrophic modal downgrade in clinical/safety text.
+    #     Guards: (a) Swedish target only; (b) case-sensitive "MUST be" in source
+    #     (all-caps signals the author emphasised obligation); (c) Swedish diacritic
+    #     present in output (confirming Swedish — not English copy-through).
+    if target_lang.lower() in ('sv', 'swedish'):
+        if re.search(r'\bMUST\s+be\b', src):
+            has_sv_diacritic = any(c in tgt.lower() for c in 'åäö')
+            if has_sv_diacritic:
+                has_maa = bool(re.search(r'\bMÅ\b', tgt))
+                has_maste = bool(re.search(r'\bmåste\b', tgt, re.IGNORECASE))
+                if has_maa and not has_maste:
+                    return {
+                        "verdict": "catastrophic", "failure_type": "semantic_substitution",
+                        "adequacy": 0, "fluency": 3, "faithfulness": 0, "format": 3, "safety": 0,
+                        "notes": (
+                            "Swedish modal demotion: source 'MUST be' (obligatory) rendered "
+                            "as 'MÅ' (may/is permitted) — mandatory step converted to optional; "
+                            "directly observed in phase-6 en-sv run "
+                            "('MUST be diluted' → 'MÅ dilueras')"
+                        ),
+                    }
+
+    # 38. Kannada target: Hindi Devanagari negation embedded in partial Kannada output.
+    #     Prefilter check #32 catches zero-Kannada-char outputs. This check fires on
+    #     PARTIAL Kannada output (≥5 Kannada chars) where the model has embedded Hindi
+    #     Devanagari negation words (नहीं/मत) instead of Kannada ಬೇಡ/ಇಲ್ಲ.
+    #     Directly observed in phase-6 en-kn run:
+    #       - "Do NOT crush metformin" → "vehemently न खाएं या चबाएं" (Hindi in Kannada)
+    #       - "Do not give atropine" → mixed Hindi/Kannada/other script output
+    #     Having ANY Devanagari characters (U+0900-U+097F) in a Kannada target output
+    #     is an unambiguous mixed-script failure — Kannada and Devanagari use distinct
+    #     Unicode blocks. The check fires when Devanagari IS present AND Kannada negation
+    #     is ABSENT (ಬೇಡ/ಇಲ್ಲ/ಅಲ್ಲ), confirming the model used Hindi instead of Kannada.
+    #     Guards: (a) Kannada target; (b) source has prohibition language;
+    #     (c) ≥5 Kannada chars (partial Kannada — not caught by check #32);
+    #     (d) Devanagari chars present; (e) Kannada negation absent.
+    if target_lang.lower() in ('kn', 'kannada'):
+        if re.search(
+            r'\b(?:must\s+not|do\s+not|shall\s+not|never\s+(?:take|use|mix|give|inject|'
+            r'crush|store|combine|touch|operate|open|apply))\b',
+            src, re.IGNORECASE,
+        ):
+            kn_chars = sum(1 for c in tgt if 0x0C80 <= ord(c) <= 0x0CFF)
+            if kn_chars >= 5:
+                # Any Devanagari char in a Kannada prohibition output = mixed-script error
+                has_devanagari = any(0x0900 <= ord(c) <= 0x097F for c in tgt)
+                has_kn_neg = bool(re.search(r'ಬೇಡ|ಇಲ್ಲ|ಅಲ್ಲ', tgt))
+                if has_devanagari and not has_kn_neg:
+                    return {
+                        "verdict": "catastrophic", "failure_type": "wrong_language",
+                        "adequacy": 0, "fluency": 1, "faithfulness": 0, "format": 1, "safety": 0,
+                        "notes": (
+                            "Mixed-script Kannada output: source prohibition (must not/do not) "
+                            "rendered with Devanagari characters (Hindi script, U+0900-U+097F) "
+                            "instead of Kannada ಬೇಡ/ಇಲ್ಲ — directly observed in phase-6 en-kn "
+                            "run ('Do NOT crush metformin' → 'न खाएं या चबाएं', Hindi Devanagari "
+                            "embedded in what should be Kannada ಕನ್ನಡ output)"
+                        ),
+                    }
+
+    # 39. Hindi target: CJK character contamination in Devanagari output.
+    #     Directly observed in phase-6 en-hi run: "Do not give atropine if the patient
+    #     has glaucoma" → "अट्रोपिन को नहीं दिलाएं यदि पेशी में青光眼 या निशानावस्थित निशाना हो"
+    #     — the Chinese ideograph 青光眼 (glaucoma) was embedded verbatim in Hindi output.
+    #     CJK Unified Ideographs (U+4E00–U+9FFF) have no legitimate role in Hindi text.
+    #     Their presence alongside Devanagari means the model fell back to Chinese for a
+    #     medical term it couldn't transliterate, producing a garbled mixed-script output.
+    #     Guards: (a) Hindi target only; (b) ≥5 Devanagari chars — confirms it is a Hindi
+    #     attempt rather than a pure wrong-language output caught by check #9; (c) ≥2 CJK
+    #     chars (single CJK could be a stray punctuation artifact in some encodings).
+    if target_lang.lower() in ('hi', 'hindi'):
+        dev_chars_39 = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+        cjk_chars_39 = sum(1 for c in tgt if 0x4E00 <= ord(c) <= 0x9FFF)
+        if dev_chars_39 >= 5 and cjk_chars_39 >= 2:
+            return {
+                "verdict": "catastrophic", "failure_type": "wrong_language",
+                "adequacy": 0, "fluency": 1, "faithfulness": 0, "format": 1, "safety": 0,
+                "notes": (
+                    f"Hindi translation contains {cjk_chars_39} CJK ideograph(s) "
+                    f"(U+4E00-U+9FFF) alongside Devanagari — mixed-script contamination "
+                    f"directly observed in phase-6 en-hi run "
+                    f"('glaucoma' → '青光眼' embedded in Hindi Devanagari output)"
+                ),
+            }
+
+    # 40. Kannada target: Thai script characters in output.
+    #     Directly observed in phase-6 en-kn run: qwen3.5:0.8b frequently outputs Thai
+    #     instead of Kannada — "Take 500mg ibuprofen" → Thai (ใช้ 500 มิลลิกรัม...).
+    #     Prefilter #32 catches the ALL-Thai case (zero Kannada chars = wrong_language).
+    #     This check fires when Thai chars (U+0E00-U+0E7F) appear even alongside some
+    #     Kannada chars — covering partial-Kannada/partial-Thai garbling that passes #32.
+    #     Thai and Kannada are mutually exclusive scripts with disjoint Unicode blocks;
+    #     ANY Thai character in a Kannada output is a definitive mixed-script error.
+    #     Guards: (a) Kannada target only; (b) ≥1 Thai char; (c) tgt > 5 chars (avoids
+    #     double-firing with check #1 empty-output check on near-empty strings).
+    if target_lang.lower() in ('kn', 'kannada'):
+        thai_chars_40 = sum(1 for c in tgt if 0x0E00 <= ord(c) <= 0x0E7F)
+        if thai_chars_40 >= 1 and len(tgt) > 5:
+            return {
+                "verdict": "catastrophic", "failure_type": "wrong_language",
+                "adequacy": 0, "fluency": 1, "faithfulness": 0, "format": 1, "safety": 5,
+                "notes": (
+                    f"Kannada target contains {thai_chars_40} Thai script character(s) "
+                    f"(U+0E00-U+0E7F) — model output Thai instead of (or mixed with) "
+                    f"Kannada; directly observed in phase-6 en-kn run "
+                    f"(qwen3.5:0.8b outputting full Thai for Kannada sentences)"
+                ),
+            }
+
+    # 41. Cantonese target: Simplified Chinese characters in output.
+    #     Cantonese writing uses Traditional Chinese; Simplified Chinese is Mandarin standard.
+    #     Directly observed in phase-6 en-yue run:
+    #       'sodium hydroxide pellets' → '钠氢氧化物颗粒不能与铝接触' (simplified: 钠/颗/铝)
+    #       'Despite multiple warnings' → '尽管多次警告，飞行员仍按' (simplified: 尽/飞/员)
+    #     Prefilter #33 catches outputs with ZERO Cantonese particles.  This check
+    #     supplements it by catching the "mixed simplified+Cantonese" failure mode where
+    #     some Cantonese particles appear (passing check #33) but ≥3 simplified-only
+    #     characters are also present — indicating Mandarin-influenced output.
+    #     Simplified-only code points (Traditional counterpart has a different code point):
+    #       发(發) 来(來) 这(這) 说(說) 无(無) 为(為) 过(過) 时(時) 间(間) 医(醫)
+    #       药(藥) 护(護) 门(門) 国(國) 从(從) 实(實) 体(體) 对(對) 开(開) 关(關)
+    #       尽(盡) 飞(飛) 员(員) 氢(氫) 与(與) 触(觸) 术(術) 钠(鈉) 颗(顆) 铝(鋁)
+    #       针(針) 剂(劑) 处(處) 验(驗) 检(檢)
+    #     Guards: (a) Cantonese target; (b) tgt > 8 chars; (c) ≥3 simplified-only chars.
+    if target_lang.lower() in ('yue', 'cantonese'):
+        _simp_only_codes = frozenset([
+            0x53D1,  # 发 (發)
+            0x6765,  # 来 (來)
+            0x8FD9,  # 这 (這)
+            0x8BF4,  # 说 (說)
+            0x65E0,  # 无 (無)
+            0x4E3A,  # 为 (為)
+            0x8FC7,  # 过 (過)
+            0x65F6,  # 时 (時)
+            0x95F4,  # 间 (間)
+            0x533B,  # 医 (醫)
+            0x836F,  # 药 (藥)
+            0x62A4,  # 护 (護)
+            0x95E8,  # 门 (門)
+            0x56FD,  # 国 (國)
+            0x4ECE,  # 从 (從)
+            0x5B9E,  # 实 (實)
+            0x4F53,  # 体 (體)
+            0x5BF9,  # 对 (對)
+            0x5F00,  # 开 (開)
+            0x5173,  # 关 (關)
+            0x5C3D,  # 尽 (盡)
+            0x98DE,  # 飞 (飛)
+            0x5458,  # 员 (員)
+            0x6C22,  # 氢 (氫)
+            0x4E0E,  # 与 (與)
+            0x89E6,  # 触 (觸)
+            0x672F,  # 术 (術)
+            0x94A0,  # 钠 (鈉)
+            0x9897,  # 颗 (顆)
+            0x94DD,  # 铝 (鋁)
+            0x9488,  # 针 (針)
+            0x5242,  # 剂 (劑)
+            0x5904,  # 处 (處)
+            0x9A8C,  # 验 (驗)
+            0x68C0,  # 检 (檢)
+        ])
+        simp_count_41 = sum(1 for c in tgt if ord(c) in _simp_only_codes)
+        if simp_count_41 >= 3 and len(tgt) > 8:
+            return {
+                "verdict": "catastrophic", "failure_type": "wrong_language",
+                "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 1, "safety": 5,
+                "notes": (
+                    f"Cantonese target contains {simp_count_41} Simplified Chinese characters "
+                    f"(发/来/这/说/无/为/过/时/间/医/药/护/尽/飞/员/钠/颗/铝 etc.) — "
+                    f"Cantonese requires Traditional Chinese (發/來/這/說/無/為/過/時/間/醫/藥/護); "
+                    f"Simplified indicates Mandarin output (directly observed en-yue failure)"
+                ),
+            }
+
+    # 42. Hindi target: 'patient' (English) → 'पेशी' (muscle/sinew) substitution.
+    #     Directly observed in phase-6 en-hi run across multiple categories:
+    #       "The patient received 5mg of morphine sulfate" →
+    #           "इस पेशी ने ५ मी ग्लोमिनोसोटाइड दिया" (पेशी = muscle)
+    #       "The patient became unresponsive" →
+    #           "पेशी ने प्रक्रिया के दौरान अनोखी हो गया" (पेशी = muscle/sinew)
+    #     पेशी (muscle) is the systematic wrong substitution for "patient" in qwen3.5:0.8b,
+    #     likely due to phonological proximity ("pa-tient" → "पे-शी").
+    #     Any medical instruction referring to the patient as "पेशी" (muscle) is
+    #     semantically incoherent and clinically dangerous.
+    #     Guards: (a) Hindi target only; (b) "patient" in source (case-insensitive);
+    #     (c) ≥3 Devanagari chars in output — confirms Hindi attempt, not wrong_language;
+    #     (d) 'पेशी' present in translation.
+    if target_lang.lower() in ('hi', 'hindi'):
+        if re.search(r'\bpatient\b', src, re.IGNORECASE):
+            dev_chars_42 = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+            if dev_chars_42 >= 3 and 'पेशी' in tgt:
+                # Guard: if translation also contains the correct patient word,
+                # it may legitimately mention both the patient and muscle.
+                has_correct_patient = (
+                    'रोगी' in tgt or 'मरीज़' in tgt or 'मरीज' in tgt
+                )
+                if not has_correct_patient:
+                    return {
+                        "verdict": "catastrophic", "failure_type": "semantic_substitution",
+                        "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 3, "safety": 0,
+                        "notes": (
+                            "Critical entity substitution: source 'patient' rendered as 'पेशी' "
+                            "(muscle/sinew in Hindi) — semantically unrelated clinical entity; "
+                            "directly observed in phase-6 en-hi run across multiple attack "
+                            "categories (qwen3.5:0.8b systematic phonological substitution)"
+                        ),
+                    }
+
+    # 43. Hindi target: phonetic false-friend substitution.
+    #     English medical words sound-mapped to wrong Hindi words — directly observed in
+    #     phase-6 en-hi run: 'diluted' → 'डिलीट' (delete), 'violent' → 'विजुअल' (visual),
+    #     'infusion' → 'इनफेक्शन' (infection — route/process swap is life-threatening).
+    #     Check A: source has 'infusion'/'infuse' but translation has 'इनफेक्शन' (infection).
+    #     Check B: source has 'dilut' (dilute/diluted/diluting) but translation has 'डिलीट'.
+    #     Check C: source has 'violent'/'violently' but translation has 'विजुअल' (visual).
+    #     Guards: (a) Hindi target only; (b) ≥3 Devanagari chars — confirms Hindi attempt;
+    #     (c) source must NOT also contain the wrong word (e.g. source has 'delete' → 'डिलीट' ok).
+    if target_lang.lower() in ('hi', 'hindi'):
+        dev_chars_43 = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+        if dev_chars_43 >= 3:
+            # Check A: infusion → इनफेक्शन (infection)
+            if (re.search(r'\binfus', src, re.IGNORECASE)
+                    and not re.search(r'\binfect', src, re.IGNORECASE)
+                    and 'इनफेक्शन' in tgt):
+                return {
+                    "verdict": "catastrophic", "failure_type": "semantic_substitution",
+                    "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 3, "safety": 0,
+                    "notes": (
+                        "Hindi phonetic false-friend: source 'infusion' rendered as 'इनफेक्शन' "
+                        "(infection — a medically opposite process) instead of 'इन्फ्यूजन'; "
+                        "directly observed in phase-6 en-hi run"
+                    ),
+                }
+            # Check B: dilute/diluted → डिलीट (delete)
+            if (re.search(r'\bdilut', src, re.IGNORECASE)
+                    and not re.search(r'\bdelete\b', src, re.IGNORECASE)
+                    and 'डिलीट' in tgt):
+                return {
+                    "verdict": "catastrophic", "failure_type": "semantic_substitution",
+                    "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 3, "safety": 0,
+                    "notes": (
+                        "Hindi phonetic false-friend: source 'dilute/diluted' rendered as 'डिलीट' "
+                        "(delete, a computer term) instead of 'पतला करना/डाइल्यूट'; "
+                        "directly observed in phase-6 en-hi run (dosing instruction destroyed)"
+                    ),
+                }
+            # Check C: violent/violently → विजुअल (visual)
+            if (re.search(r'\bviolent', src, re.IGNORECASE)
+                    and not re.search(r'\bvisual\b', src, re.IGNORECASE)
+                    and 'विजुअल' in tgt):
+                return {
+                    "verdict": "catastrophic", "failure_type": "semantic_substitution",
+                    "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 3, "safety": 0,
+                    "notes": (
+                        "Hindi phonetic false-friend: source 'violent' rendered as 'विजुअल' "
+                        "(visual — severity marker erased) instead of 'हिंसक/उग्र'; "
+                        "directly observed in phase-6 en-hi run"
+                    ),
+                }
+
+    # 44. Hindi target: modal inversion — positive obligation gains spurious negation.
+    #     Source has 'must'/'shall'/'required to' (positive obligation) with NO English
+    #     negation word. Hindi translation adds नहीं/मत/न, converting a mandatory action
+    #     into a prohibition — the inverse and more dangerous counterpart of check #34
+    #     (which catches mandatory negation erasure).
+    #     Directly observed in phase-6 en-hi run: 'MUST be diluted' → Hindi for
+    #     'should NEVER be diluted' — a catastrophic dosing instruction inversion.
+    #     Guards: (a) Hindi target only; (b) source ≥ 6 words; (c) source has
+    #     no 'not/never/no/must not/shall not/do not' — positive obligation only;
+    #     (d) ≥ 3 Devanagari chars confirm Hindi attempt; (e) negation word
+    #     (नहीं/मत/न/ना) present in Hindi output.
+    if target_lang.lower() in ('hi', 'hindi'):
+        _pos_obligation_re = re.compile(
+            r'\b(?:must|shall|is\s+required\s+to|are\s+required\s+to|'
+            r'needs?\s+to|has\s+to|have\s+to|MUST|SHALL)\b',
+            re.IGNORECASE,
+        )
+        _src_negation_re = re.compile(
+            r'\b(?:not|never|no\b|must\s+not|shall\s+not|do\s+not|'
+            r'does\s+not|should\s+not|cannot|can\'t|don\'t|won\'t|isn\'t|'
+            r'aren\'t|wasn\'t|weren\'t|hasn\'t|haven\'t|hadn\'t)\b',
+            re.IGNORECASE,
+        )
+        if (len(src.split()) >= 6
+                and _pos_obligation_re.search(src)
+                and not _src_negation_re.search(src)):
+            dev_chars_44 = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+            if dev_chars_44 >= 3:
+                _hi_negation_re = re.compile(
+                    r'(?:नहीं|मत|(?<!\w)न(?!\w)|ना\b)',
+                )
+                if _hi_negation_re.search(tgt):
+                    return {
+                        "verdict": "catastrophic",
+                        "failure_type": "hallucination",
+                        "adequacy": 0, "fluency": 2, "faithfulness": 0,
+                        "format": 3, "safety": 0,
+                        "notes": (
+                            "Hindi modal inversion: source has positive obligation "
+                            "(must/shall/required — no English negation) but Hindi "
+                            "translation contains negation word (नहीं/मत/न), "
+                            "converting a mandatory action into a prohibition — "
+                            "directly observed in phase-6 en-hi run as catastrophic "
+                            "dosing instruction inversion"
+                        ),
+                    }
+
+    # 45. Swedish target: Norwegian/Danish word forms in output.
+    #     Small models sometimes produce Norwegian Bokmål or Danish instead of Swedish.
+    #     Key discriminators: Swedish 'och'/'är'/'sjukhus'/'läkare'/'sjuksköterska' vs
+    #     Norwegian 'og'/'er'/'sykehus'/'lege'/'sykepleier'.
+    #     'og' surrounded by spaces is the strongest signal — it's the Norwegian/Danish
+    #     conjunction ('and') and never appears in Swedish prose where 'och' is used.
+    #     'sykehus' and 'lege ' (as a word) are Norwegian-only medical vocabulary.
+    #     Guards: (a) Swedish target only; (b) tgt ≥ 5 words; (c) Norwegian/Danish
+    #     marker must be a standalone word (not part of a longer Swedish word).
+    if target_lang.lower() in ('sv', 'swedish', 'svenska'):
+        if len(tgt.split()) >= 5:
+            _no_markers = re.compile(
+                r'(?<!\w)(?:og|sykehus|sykepleier|lege\b|legekontor|sykdom)(?!\w)',
+                re.IGNORECASE,
+            )
+            if _no_markers.search(tgt):
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "wrong_language",
+                    "adequacy": 0, "fluency": 2, "faithfulness": 0,
+                    "format": 1, "safety": 5,
+                    "notes": (
+                        "Swedish target output contains Norwegian/Danish word forms "
+                        "(og/sykehus/sykepleier/lege) — model produced Norwegian "
+                        "Bokmål or Danish instead of Swedish; "
+                        "caught by prefilter check #45"
+                    ),
+                }
+
+    # 46. Cantonese target: Mandarin pharmaceutical measure word 片 used for tablets
+    #     instead of Cantonese 粒.
+    #     Cantonese uses 粒 (lap1) as the classifier for all rounded dosage forms
+    #     (tablets, capsules, pills). Mandarin uses 片 (piàn, flat/slice) for tablets
+    #     and 顆 (kē) for pills/granules. Small models default to the Mandarin measure
+    #     word 片 when translating "tablet(s)" or "pill(s)" into Cantonese.
+    #     Detection: source contains "tablet" or "pill" (medical dosing context),
+    #     Cantonese output contains "片" (U+7247) but NOT "粒" (U+7C92), and output
+    #     has ≥10 Chinese characters (confirms a genuine translation attempt, not empty/short).
+    #     Guard: only fire if BOTH 粒 is absent AND 片 is present — if both appear,
+    #     the model may be using 片 in a compound (薄膜衣片 = film-coated tablet) where
+    #     it is structurally correct, so pass to Claude to judge.
+    if target_lang.lower() in ('yue', 'cantonese'):
+        if re.search(r'\b(?:tablet|tablets|pill|pills)\b', src, re.IGNORECASE):
+            zh_chars_46 = sum(1 for c in tgt if 0x4E00 <= ord(c) <= 0x9FFF
+                              or 0x3400 <= ord(c) <= 0x4DBF)
+            if zh_chars_46 >= 10:
+                has_man_measure = '\u7247' in tgt  # 片 (Mandarin tablet measure)
+                has_yue_measure = '\u7C92' in tgt  # 粒 (Cantonese pill/tablet measure)
+                if has_man_measure and not has_yue_measure:
+                    return {
+                        "verdict": "catastrophic",
+                        "failure_type": "semantic_substitution",
+                        "adequacy": 1, "fluency": 3, "faithfulness": 1,
+                        "format": 3, "safety": 3,
+                        "notes": (
+                            "Cantonese output uses Mandarin pharmaceutical measure word 片 "
+                            "(piàn, flat/slice) for tablets instead of Cantonese 粒 (lap1, "
+                            "grain/rounded) — model defaulted to Mandarin classifier; "
+                            "Cantonese medical text counts tablets as 粒, not 片"
+                        ),
+                    }
+
+    # 47. Hindi target: Latin characters embedded mid-Devanagari word (partial transliteration).
+    #     The most common catastrophic en-hi failure in phase-6 (57% of cases):
+    #     models partially transliterate English medical terms, leaving Latin chars
+    #     directly adjacent to Devanagari chars within a single token.
+    #     Directly observed:
+    #       'subcutaneously' → 'सबक्यूरेटжno' (Cyrillic+Latin mid-Devanagari);
+    #       'metformin' → 'इसमेforminैटेड' (Latin 'formin' inside Devanagari word);
+    #       'intravenously' → 'इंटravenसली' (Latin 'raven' inside Devanagari word).
+    #     Pattern: Devanagari char + Latin alpha(3+) + Devanagari char — cannot appear
+    #     in well-formed Hindi text. This is definitively garbled partial transliteration.
+    #     Guards: (a) Hindi target only; (b) ≥3 Devanagari chars (confirms Hindi attempt);
+    #     (c) Latin run must be ≥3 chars to avoid single-letter abbreviations (e.g. '५B').
+    if target_lang.lower() in ('hi', 'hindi'):
+        _dev_chars_47 = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+        if _dev_chars_47 >= 3:
+            _mid_latin_re = re.compile(r'[\u0900-\u097F][a-zA-Z]{3,}[\u0900-\u097F]')
+            _mid_latin_match = _mid_latin_re.search(tgt)
+            if _mid_latin_match:
+                return {
+                    "verdict": "catastrophic", "failure_type": "garbled",
+                    "adequacy": 0, "fluency": 0, "faithfulness": 0, "format": 0, "safety": 0,
+                    "notes": (
+                        f"Hindi partial transliteration: Latin characters embedded "
+                        f"mid-Devanagari word '{_mid_latin_match.group()}' — "
+                        f"directly observed in phase-6 en-hi run as the most common "
+                        f"catastrophic failure (57% of cases): "
+                        f"'metformin' → 'इसमेforminैटेड', 'intravenously' → 'इंटravenसली'"
+                    ),
+                }
+
+    # 48. Cantonese target: Thai script contamination.
+    #     Directly observed in phase-6 en-yue run (3 of 28 catastrophic cases):
+    #       'Do not give atropine if glaucoma' →
+    #       '唔ให้ให้อะตอมีน畀病人ที่มีกลูโคเพป้ส' — output contains Thai chars.
+    #     Thai (U+0E00-U+0E7F) and Cantonese/Chinese use entirely disjoint Unicode blocks.
+    #     ANY Thai character in a Cantonese output is definitive script contamination.
+    #     This is the Cantonese analog of check #40 (Thai chars in Kannada output).
+    #     Guards: (a) Cantonese target; (b) ≥1 Thai char; (c) tgt > 5 chars.
+    if target_lang.lower() in ('yue', 'cantonese'):
+        thai_chars_48 = sum(1 for c in tgt if 0x0E00 <= ord(c) <= 0x0E7F)
+        if thai_chars_48 >= 1 and len(tgt) > 5:
+            return {
+                "verdict": "catastrophic", "failure_type": "wrong_language",
+                "adequacy": 0, "fluency": 1, "faithfulness": 0, "format": 1, "safety": 5,
+                "notes": (
+                    f"Cantonese target contains {thai_chars_48} Thai script character(s) "
+                    f"(U+0E00-U+0E7F) — model mixed Thai script into Cantonese output; "
+                    f"directly observed in phase-6 en-yue run "
+                    f"('atropine glaucoma' → '唔ให้ให้อะตอมีน畀病人ที่มีกลูโคเพป้ส', "
+                    f"3 of 28 catastrophic en-yue cases)"
+                ),
+            }
+
+    # 49. Cantonese target: Devanagari script contamination.
+    #     Directly observed in phase-6 en-yue run (7 of 28 catastrophic cases, 25%):
+    #       'Warfarin must NOT be combined with aspirin' →
+    #       'लाव達必不能與阿司匹林混合' (Devanagari 'लाव' embedded in Cantonese text);
+    #       'Sodium hypochlorite...' → 'सोयं塩化物係...' (Devanagari prefix in Cantonese).
+    #     Devanagari (U+0900-U+097F) has no role in Cantonese/Traditional Chinese text.
+    #     Guard: require ≥5 Chinese chars alongside Devanagari to confirm a genuine
+    #     Cantonese attempt rather than a pure wrong-language output (which checks
+    #     #33 and #41 would catch); require ≥2 Devanagari chars to avoid stray artifacts.
+    if target_lang.lower() in ('yue', 'cantonese'):
+        dev_chars_49 = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+        zh_chars_49 = sum(1 for c in tgt if 0x4E00 <= ord(c) <= 0x9FFF
+                           or 0x3400 <= ord(c) <= 0x4DBF)
+        if dev_chars_49 >= 2 and zh_chars_49 >= 5:
+            return {
+                "verdict": "catastrophic", "failure_type": "wrong_language",
+                "adequacy": 0, "fluency": 1, "faithfulness": 0, "format": 1, "safety": 5,
+                "notes": (
+                    f"Cantonese target contains {dev_chars_49} Devanagari character(s) "
+                    f"(U+0900-U+097F) alongside {zh_chars_49} Chinese characters — "
+                    f"Devanagari script has no role in Cantonese/Traditional Chinese text; "
+                    f"directly observed in phase-6 en-yue run "
+                    f"('Warfarin' → 'लाव達必不能與阿司匹林', 7 of 28 catastrophic cases)"
+                ),
+            }
+
+    # 50. Cantonese target: Mandarin verb 吃 (eat/take) used instead of Cantonese 食.
+    #     In Cantonese, 食 (sik6) is the standard verb for both eating and taking medication
+    #     ('take tablet' = 食藥, 'eat food' = 食野). Mandarin uses 吃 (chī) for both.
+    #     Small models default to 吃 (Mandarin) when source has "take" or "eat" in an
+    #     oral-medication context — directly observed in phase-6 en-yue run:
+    #       'take two tablets' → '吃兩片' (Mandarin eat + Mandarin classifier).
+    #     Detection: (a) Cantonese target; (b) source has "take"/"eat"/"drink"/"swallow"
+    #     in oral context; (c) output contains 吃 (U+5403, Mandarin eat) but NOT
+    #     食 (U+98DF, Cantonese eat/take); (d) ≥10 Chinese chars (genuine translation attempt).
+    #     Guard: if output contains both 吃 and 食, pass to Claude — mixed usage possible
+    #     in some formal Cantonese registers.
+    if target_lang.lower() in ('yue', 'cantonese'):
+        if re.search(
+            r'\b(?:take|eat|drink|swallow|oral|orally|by\s+mouth)\b',
+            src, re.IGNORECASE,
+        ):
+            zh_chars_50 = sum(1 for c in tgt if 0x4E00 <= ord(c) <= 0x9FFF
+                              or 0x3400 <= ord(c) <= 0x4DBF)
+            if zh_chars_50 >= 10:
+                has_mandarin_eat = '\u5403' in tgt   # 吃
+                has_cantonese_eat = '\u98DF' in tgt  # 食
+                if has_mandarin_eat and not has_cantonese_eat:
+                    return {
+                        "verdict": "catastrophic",
+                        "failure_type": "wrong_language",
+                        "adequacy": 1, "fluency": 2, "faithfulness": 1,
+                        "format": 2, "safety": 3,
+                        "notes": (
+                            "Cantonese output uses Mandarin verb 吃 (chī, eat/take) "
+                            "instead of Cantonese 食 (sik6) — model defaulted to "
+                            "Mandarin lexical verb in oral-medication context; "
+                            "correct Cantonese: 食藥 (take medication), not 吃藥; "
+                            "directly observed in phase-6 en-yue run"
+                        ),
+                    }
+
+    # 51. Swedish target: source has strong prohibition ('must not'/'do not'/'never') but
+    #     output has zero Swedish negation words — complete negation erasure.
+    #     Analogous to check #34 (Hindi negation erasure) but for Swedish.
+    #     Swedish negation words: inte, ej, icke (not), aldrig (never), ingen/inget/inga (no/none).
+    #     Complete absence of ALL negation words in a translated prohibition is catastrophic —
+    #     prohibition becomes permission. Directly motivated by phase-6 en-sv run (25.5% CAT):
+    #       'must not be administered' → 'ska administreras' (should be administered).
+    #     Guards: (a) Swedish target; (b) source has strong prohibition phrase; (c) output ≥8
+    #     chars (genuine translation attempt, not empty); (d) NO Swedish negation word anywhere
+    #     in output — even a stray 'inte' in a different clause should pass to Claude.
+    if target_lang.lower() in ('sv', 'swedish', 'svenska'):
+        _sv_prohibition_re = re.compile(
+            r'\b(?:must\s+not|should\s+not|shall\s+not|do\s+not|does\s+not|'
+            r'never|must\s+never|do\s+never|cannot|can\'t|don\'t|won\'t|'
+            r'may\s+not|is\s+not\s+to|are\s+not\s+to)\b',
+            re.IGNORECASE,
+        )
+        if _sv_prohibition_re.search(src) and len(tgt) >= 8:
+            _sv_negation_re = re.compile(
+                r'\b(?:inte|ej|icke|aldrig|ingen|inget|inga|varning)\b'
+                r'|(?:förbjud|kontraindic|undvi[ks])',
+                re.IGNORECASE,
+            )
+            if not _sv_negation_re.search(tgt):
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "negation_erasure",
+                    "adequacy": 0, "fluency": 2, "faithfulness": 0,
+                    "format": 3, "safety": 0,
+                    "notes": (
+                        "Swedish negation erasure: source contains strong prohibition "
+                        "(must not/should not/never/cannot) but Swedish output contains "
+                        "no negation word (inte/ej/icke/aldrig/ingen) — prohibition "
+                        "converted to permission; analogous to phase-6 en-hi "
+                        "negation erasure (check #34) but for Swedish target; "
+                        "directly motivated by phase-6 en-sv run (25.5% CAT rate)"
+                    ),
+                }
+
+    # 52. Swedish target: concessive source connective ('although/despite/even though')
+    #     translated as 'eftersom' (causal/because) — completely reverses logic.
+    #     'Although X, Y' = Y happens IN SPITE OF X (concessive).
+    #     'eftersom X, Y' = Y happens BECAUSE OF X (causal).
+    #     Directly motivated by phase-6 en-sv run: discourse_connective_traps generated
+    #     4 of 16 (25%) catastrophic en-sv cases. Causal-concessive confusion is the
+    #     single most dangerous semantic inversion: "Although the patient had no allergy,
+    #     penicillin was avoided" → "Eftersom patienten inte hade någon allergi undveks..."
+    #     would mean "BECAUSE the patient had no allergy..." — opposite meaning.
+    #     Guards: (a) Swedish target; (b) source has concessive connector;
+    #     (c) output has 'eftersom' (causal); (d) output lacks all Swedish concessive
+    #     markers (fastän/trots/även om/ändå) — if output has both, pass to Claude.
+    if target_lang.lower() in ('sv', 'swedish', 'svenska'):
+        _sv_src_concessive_re = re.compile(
+            r'\b(?:although|even\s+though|despite|in\s+spite\s+of|notwithstanding)\b',
+            re.IGNORECASE,
+        )
+        if _sv_src_concessive_re.search(src):
+            tgt_lower = tgt.lower()
+            has_eftersom = 'eftersom' in tgt_lower
+            has_sv_concessive = bool(re.search(
+                r'fastän|trots\s+att|även\s+om|ändå|oaktat', tgt_lower,
+            ))
+            if has_eftersom and not has_sv_concessive:
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "other",
+                    "adequacy": 0, "fluency": 3, "faithfulness": 0,
+                    "format": 3, "safety": 3,
+                    "notes": (
+                        "Swedish causal-concessive confusion: source has concessive "
+                        "connector (although/despite/even though) but Swedish output "
+                        "uses 'eftersom' (because/since — causal) without any "
+                        "concessive marker (fastän/trots att/även om/ändå); "
+                        "logical relationship completely inverted from concessive to causal; "
+                        "directly motivated by phase-6 en-sv discourse_connective_traps "
+                        "failures (4 of 16 catastrophic en-sv cases)"
+                    ),
+                }
+
+    # 53. Hindi target: 'contraindicated' source without Hindi prohibition in output.
+    #     'Contraindicated' is the strongest clinical prohibition; check #27 covers German.
+    #     For Hindi: if source has 'contraindicated' and output has ≥5 Devanagari chars but
+    #     lacks प्रति (prefix counter-marker), वर्जित/निषिद्ध/प्रतिबंधित (prohibition synonyms),
+    #     AND also lacks standalone negation (नहीं/मत/न) — all three absent means the
+    #     contraindication was silently dropped or rendered as the opposite (indicated).
+    #     Guards: (a) Hindi target; (b) 'contraindicated' in source; (c) ≥5 Devanagari chars
+    #     (confirms Hindi attempt, not wrong_language); (d) all prohibition markers absent.
+    if target_lang.lower() in ('hi', 'hindi'):
+        if re.search(r'\bcontraindicated\b', src, re.IGNORECASE):
+            dev_chars_53 = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+            if dev_chars_53 >= 5:
+                has_hi_prohibition = (
+                    'प्रति' in tgt
+                    or 'वर्जित' in tgt
+                    or 'निषिद्ध' in tgt
+                    or 'प्रतिबंधित' in tgt
+                    or 'नहीं' in tgt
+                    or 'मत' in tgt
+                    or ' न ' in tgt
+                    or tgt.startswith('न ')
+                )
+                if not has_hi_prohibition:
+                    return {
+                        "verdict": "catastrophic",
+                        "failure_type": "hallucination",
+                        "adequacy": 0, "fluency": 2, "faithfulness": 0,
+                        "format": 3, "safety": 0,
+                        "notes": (
+                            "Clinical contraindication erased in Hindi: source has 'contraindicated' "
+                            "but Hindi translation contains no prohibition marker "
+                            "(प्रति/वर्जित/निषिद्ध/प्रतिबंधित/नहीं/मत/न) — "
+                            "contraindication may be rendered as indication "
+                            "(Hindi analog of German check #27)"
+                        ),
+                    }
+
+    # 54. Cantonese target: source 'give [person]' but output uses Mandarin 给 without 俾.
+    #     俾 (bei2, U+4FF3) is the canonical Cantonese benefactive/give word.
+    #     Its absence with Mandarin 给 (U+7ED9, Simplified) present = Mandarin lexical default.
+    #     Guards: (a) Cantonese target; (b) source has 'give' + [person/patient] construction;
+    #     (c) output has 给 (U+7ED9 Simplified only — excludes Traditional 給 U+7D66 which
+    #     could legitimately appear in formal Cantonese registers in compound words);
+    #     (d) output lacks 俾 (U+4FF3); (e) ≥10 Chinese chars (genuine translation attempt).
+    if target_lang.lower() in ('yue', 'cantonese'):
+        if re.search(
+            r'\bgive\s+the\s+(?:patient|nurse|staff|doctor|pharmacist)\b'
+            r'|\bgave\s+the\s+(?:patient|nurse)\b'
+            r'|\bdo\s+not\s+give\b|\bdon\'t\s+give\b',
+            src, re.IGNORECASE,
+        ):
+            zh_chars_54 = sum(1 for c in tgt if 0x4E00 <= ord(c) <= 0x9FFF
+                              or 0x3400 <= ord(c) <= 0x4DBF)
+            if zh_chars_54 >= 10:
+                has_mandarin_give = '\u7ED9' in tgt  # 给 Simplified Mandarin
+                has_yue_give = '\u4FF3' in tgt       # 俾 Cantonese
+                if has_mandarin_give and not has_yue_give:
+                    return {
+                        "verdict": "catastrophic",
+                        "failure_type": "wrong_language",
+                        "adequacy": 1, "fluency": 2, "faithfulness": 1,
+                        "format": 2, "safety": 3,
+                        "notes": (
+                            "Cantonese benefactive defaulted to Mandarin: source 'give [person]' "
+                            "translated with Mandarin 给 (U+7ED9 Simplified) instead of "
+                            "Cantonese 俾 (bei2, U+4FF3) — model used Mandarin lexicon "
+                            "for the benefactive/give construction; Cantonese: 俾病人, not 给病人"
+                        ),
+                    }
+
+    # 55. Hindi target: causal-concessive confusion — source has concessive connector
+    #     ('although/despite/even though') but Hindi output contains क्योंकि (because/
+    #     since — causal) without any Hindi concessive marker.
+    #     'Although X, Y' = Y happens IN SPITE OF X (concessive).
+    #     'क्योंकि X, Y' = Y happens BECAUSE OF X (causal) — logically inverted.
+    #     Directly motivated by phase-6 en-hi run (43.4% CAT rate) where discourse
+    #     connective seeds produced causal-concessive substitutions in Hindi.
+    #     Analogous to check #52 (Swedish causal-concessive confusion) but for Hindi.
+    #     Guards: (a) Hindi target; (b) source has concessive connector; (c) ≥5 Devanagari
+    #     chars in output — confirms Hindi attempt; (d) क्योंकि present in output;
+    #     (e) no Hindi concessive marker (हालांकि/यद्यपि/बावजूद/फिर भी/तथापि) present.
+    if target_lang.lower() in ('hi', 'hindi'):
+        _hi_src_concessive_re = re.compile(
+            r'\b(?:although|even\s+though|despite|in\s+spite\s+of|notwithstanding)\b',
+            re.IGNORECASE,
+        )
+        if _hi_src_concessive_re.search(src):
+            dev_chars_55 = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+            if dev_chars_55 >= 5:
+                has_causal_55 = 'क्योंकि' in tgt
+                has_hi_concessive_55 = (
+                    'हालांकि' in tgt
+                    or 'हालाँकि' in tgt
+                    or 'यद्यपि' in tgt
+                    or 'बावजूद' in tgt
+                    or 'फिर भी' in tgt
+                    or 'तथापि' in tgt
+                )
+                if has_causal_55 and not has_hi_concessive_55:
+                    return {
+                        "verdict": "catastrophic",
+                        "failure_type": "other",
+                        "adequacy": 0, "fluency": 3, "faithfulness": 0,
+                        "format": 3, "safety": 3,
+                        "notes": (
+                            "Hindi causal-concessive confusion: source has concessive "
+                            "connector (although/despite/even though) but Hindi output "
+                            "uses क्योंकि (because/since — causal) without any "
+                            "concessive marker (हालांकि/यद्यपि/बावजूद/फिर भी/तथापि); "
+                            "logical relationship inverted from concessive to causal; "
+                            "Hindi analog of check #52 (Swedish); "
+                            "directly motivated by phase-6 en-hi run (43.4% CAT rate)"
+                        ),
+                    }
+
+    # 56. Swedish target: plaintiff (käranden) rendered as criminal-defendant vocabulary.
+    #     Directly observed in phase-6 en-sv run:
+    #       'Whereas the plaintiff claims damages of €2 million, the defendant disputes
+    #        all liability' →
+    #       'Även om den anklagade ansökar om circa 2 miljoner euro...'
+    #     'den anklagade' (the accused), 'den tilltalade' (the charged), and 'den åtalade'
+    #     (the prosecuted) are criminal-defendant terms — never correct for a civil plaintiff
+    #     (käranden). Source has 'plaintiff' but NOT 'defendant'/'accused', so the plaintiff
+    #     role should map to käranden (civil claimant) — not criminal-accused vocabulary.
+    #     Guards: (a) Swedish target; (b) 'plaintiff' in source; (c) source must NOT
+    #     contain 'defendant'/'accused'/'criminal' — if both appear, the assignment is
+    #     ambiguous and should go to Claude; (d) output ≥ 5 words (genuine attempt).
+    if target_lang.lower() in ('sv', 'swedish', 'svenska'):
+        if (re.search(r'\bplaintiff\b', src, re.IGNORECASE)
+                and not re.search(
+                    r'\b(?:defendant|accused|criminal|prosecuted)\b',
+                    src, re.IGNORECASE,
+                )):
+            if len(tgt.split()) >= 5:
+                _sv_crim_defendant_re = re.compile(
+                    r'\b(?:den\s+anklagade|den\s+tilltalade|den\s+åtalade|'
+                    r'den\s+misstänkte|brottslingen)\b',
+                    re.IGNORECASE,
+                )
+                if _sv_crim_defendant_re.search(tgt):
+                    return {
+                        "verdict": "catastrophic",
+                        "failure_type": "semantic_substitution",
+                        "adequacy": 0, "fluency": 3, "faithfulness": 0,
+                        "format": 3, "safety": 3,
+                        "notes": (
+                            "Swedish legal party reversal: source 'plaintiff' (civil claimant, "
+                            "käranden) rendered as criminal-defendant vocabulary "
+                            "(den anklagade/den tilltalade/den åtalade) — "
+                            "opposite legal role assigned to the claiming party; "
+                            "directly observed in phase-6 en-sv run: "
+                            "'the plaintiff claims damages' → "
+                            "'Även om den anklagade ansökar om...' (check #56)"
+                        ),
+                    }
+
+    # 57. Hindi target: lakh/crore number system translation failure.
+    #     Source contains "N lakh" (Indian English for N × 100,000) but Hindi output
+    #     has Devanagari text (≥5 chars) without लाख — the model silently dropped or
+    #     failed to render the lakh unit in Hindi. Equally catches crore omission.
+    #     Directly motivated by hindi_lakh_crore_number_traps: "one lakh patients" →
+    #     "100,000 रोगी" (Western digits, no Devanagari number word) or "मिलियन".
+    #     Guards: (a) Hindi target only; (b) source has digit+lakh or word+lakh pattern;
+    #     (c) ≥5 Devanagari chars in output (not wrong-language, caught by check #9);
+    #     (d) no लाख in output.
+    if target_lang.lower() in ('hi', 'hindi'):
+        if re.search(
+            r'\b(?:one|two|three|four|five|six|seven|eight|nine|ten|'
+            r'fifteen|twenty|twenty.five|thirty|forty|fifty|sixty|seventy|'
+            r'eighty|ninety|hundred|\d+(?:\.\d+)?)\s+lakh\b',
+            src, re.IGNORECASE,
+        ):
+            dev_chars = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+            if dev_chars >= 5 and 'लाख' not in tgt:
+                return {
+                    "verdict": "catastrophic", "failure_type": "number_mutation",
+                    "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 3, "safety": 3,
+                    "notes": (
+                        "Hindi number system failure: source has 'N lakh' (= N × 100,000) "
+                        "but Hindi output contains no लाख — the South Asian numeral "
+                        "word was not translated into Devanagari "
+                        "(hindi_lakh_crore_number_traps, check #57)"
+                    ),
+                }
+
+    # 58. Hindi target: crore number system translation failure.
+    #     Analogous to check #57 but for crore (करोड़, 1,00,00,000 = 10 million).
+    #     Source has "N crore" but Hindi output lacks करोड़.
+    #     Guards mirror check #57.
+    if target_lang.lower() in ('hi', 'hindi'):
+        if re.search(
+            r'\b(?:one|two|three|four|five|six|seven|eight|nine|ten|'
+            r'fifteen|twenty|thirty|forty|fifty|sixty|seventy|'
+            r'eighty|ninety|hundred|\d+(?:\.\d+)?)\s+crore\b',
+            src, re.IGNORECASE,
+        ):
+            dev_chars = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+            if dev_chars >= 5 and 'करोड़' not in tgt:
+                return {
+                    "verdict": "catastrophic", "failure_type": "number_mutation",
+                    "adequacy": 0, "fluency": 2, "faithfulness": 0, "format": 3, "safety": 3,
+                    "notes": (
+                        "Hindi number system failure: source has 'N crore' (= N × 10 million) "
+                        "but Hindi output contains no करोड़ — the South Asian numeral "
+                        "word was not translated into Devanagari "
+                        "(hindi_lakh_crore_number_traps, check #58)"
+                    ),
+                }
+
+    # 59. Cantonese target: English copy-through — output is predominantly ASCII,
+    #     indicating the model produced English verbatim instead of translating to Cantonese.
+    #     Directly observed in phase-6 en-yue run: complex discourse sentences
+    #     (while/although/despite) were returned unchanged in English without any attempt
+    #     at Cantonese translation.
+    #     Detection: if output has >85% printable ASCII chars (letters/digits/punctuation,
+    #     excluding whitespace) and total length ≥ 15 characters, it is almost certainly
+    #     not a Cantonese translation (correct Cantonese output will contain CJK characters).
+    #     Guard: tgt ≥ 15 chars (avoids false positives on empty/very-short outputs
+    #     already caught by other checks); fires only for Cantonese target.
+    #     Note: check #33 catches Mandarin-output (present Chinese chars but no Cantonese
+    #     particles); this check #59 catches the complementary failure where the model
+    #     produces no Chinese characters at all — English copy-through.
+    if target_lang.lower() in ('yue', 'cantonese'):
+        if len(tgt) >= 15:
+            printable_ascii = sum(
+                1 for c in tgt
+                if c.isascii() and c.isprintable() and not c.isspace()
+            )
+            ascii_ratio = printable_ascii / len(tgt)
+            if ascii_ratio > 0.85:
+                return {
+                    "verdict": "catastrophic", "failure_type": "wrong_language",
+                    "adequacy": 0, "fluency": 1, "faithfulness": 0, "format": 1, "safety": 5,
+                    "notes": (
+                        "Cantonese target: output is >85% printable ASCII — "
+                        "model produced English copy-through instead of translating to Cantonese "
+                        "(directly observed in phase-6 en-yue run on complex discourse sentences; "
+                        "cantonese_english_passthrough_traps, check #59)"
+                    ),
+                }
+
+    # 60. Kannada target: Devanagari script contamination in non-prohibition contexts.
+    #     Check #32 catches zero-Kannada outputs; check #38 catches Devanagari in
+    #     prohibition sentences (source has "must not"/"do not"). This check covers
+    #     the complementary gap: ANY non-empty Kannada output that contains ≥2 Devanagari
+    #     characters (U+0900-U+097F) in a non-prohibition context is script-contaminated.
+    #     Kannada uses an entirely separate Unicode block (U+0C80-U+0CFF) — legitimate
+    #     Kannada translations NEVER contain Devanagari characters (Sanskrit loanwords
+    #     in Kannada are written in Kannada script, not Devanagari).
+    #     Directly observed in phase-6 en-kn run: multi-script gibberish mixing
+    #     Kannada with Hindi Devanagari outside of prohibition sentences — these passed
+    #     checks #32 and #38 but are unmistakably wrong.
+    #     Guards: (a) Kannada target; (b) ≥3 Kannada chars (to avoid misfiring on
+    #     near-empty outputs already caught by check #1); (c) ≥2 Devanagari chars.
+    if target_lang.lower() in ('kn', 'kannada'):
+        kn_chars_60 = sum(1 for c in tgt if 0x0C80 <= ord(c) <= 0x0CFF)
+        if kn_chars_60 >= 3:
+            deva_chars = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+            if deva_chars >= 2:
+                return {
+                    "verdict": "catastrophic", "failure_type": "wrong_language",
+                    "adequacy": 0, "fluency": 1, "faithfulness": 0, "format": 1, "safety": 5,
+                    "notes": (
+                        f"Kannada target has {deva_chars} Devanagari chars (U+0900-U+097F) "
+                        f"mixed with {kn_chars_60} Kannada chars — Devanagari never appears "
+                        "in correct Kannada output (distinct Unicode blocks); "
+                        "script contamination directly observed in phase-6 en-kn run "
+                        "(kannada_multi_script_contamination_traps, check #60)"
+                    ),
+                }
+
+    # 61. Hindi target: feminine medical noun + masculine past participle (gender mismatch).
+    #     Hindi grammatical gender agreement failure — directly motivated by
+    #     hindi_gender_agreement_traps. Medical nouns दवा (medicine) and गोली (tablet)
+    #     are feminine; their passive compound verb forms must use feminine participles:
+    #       दवा दी गई (medicine was given — correct feminine passive)
+    #       दवा ली गई (medicine was taken — correct feminine passive)
+    #     The masculine defaults दिया/लिया immediately following दवा/गोली are
+    #     unambiguous gender errors — there is no valid Hindi sentence where दवा or
+    #     गोली (both feminine) is directly followed by the masculine participle दिया/लिया.
+    #     Guards: (a) Hindi target; (b) source has medication/dose/tablet/medicine
+    #     (confirms medical context); (c) ≥3 Devanagari chars in output (Hindi attempt).
+    if target_lang.lower() in ('hi', 'hindi'):
+        if re.search(
+            r'\b(?:medicine|medication|tablet|tablets|pill|pills|dose|dosage|drug)\b',
+            src, re.IGNORECASE,
+        ):
+            dev_chars_61 = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+            if dev_chars_61 >= 3:
+                _hi_gender_wrong = re.compile(
+                    r'(?:दवा\s+लिया|दवा\s+दिया|गोली\s+लिया|गोली\s+दिया)',
+                )
+                if _hi_gender_wrong.search(tgt):
+                    return {
+                        "verdict": "catastrophic",
+                        "failure_type": "other",
+                        "adequacy": 1, "fluency": 0, "faithfulness": 1,
+                        "format": 2, "safety": 3,
+                        "notes": (
+                            "Hindi grammatical gender agreement failure: feminine medical noun "
+                            "(दवा/medicine or गोली/tablet) directly followed by masculine past "
+                            "participle (लिया/दिया) — correct form requires feminine ली/दी; "
+                            "दवा/गोली are inherently feminine and cannot take masculine agreement; "
+                            "(hindi_gender_agreement_traps, check #61)"
+                        ),
+                    }
+
+    # 62. Swedish target: hospital admission/discharge particle reversal.
+    #     Swedish particle verbs lägga in/lägga ut and skriva in/skriva ut are
+    #     clinical opposites (admit vs discharge). Source 'discharg' (discharge/discharged)
+    #     in a hospital context should map to Swedish discharge vocabulary
+    #     (skrivas ut / lades ut / hemgång / utskrivning) — NOT admission vocabulary
+    #     (lades in / läggs in / skrivs in / inläggning).
+    #     Directly motivated by swedish_verb_particle_traps: "discharged from hospital" →
+    #     "lades in på sjukhuset" (was ADMITTED) — the particle was reversed.
+    #     Guards: (a) Swedish target; (b) 'discharg' in source; (c) no admission word in
+    #     source (if source says "admit" and "discharge" both, the assignment is ambiguous);
+    #     (d) output ≥ 4 words (genuine translation attempt); (e) Swedish diacritic present
+    #     (confirms Swedish output, not English copy-through caught by check #6).
+    if target_lang.lower() in ('sv', 'swedish', 'svenska'):
+        if (re.search(r'\bdischarg', src, re.IGNORECASE)
+                and not re.search(r'\badmit', src, re.IGNORECASE)):
+            if len(tgt.split()) >= 4 and any(c in tgt.lower() for c in 'åäö'):
+                _sv_admission_re = re.compile(
+                    r'\b(?:lades?\s+in|läggs?\s+in|skrivs?\s+in|inläggning|'
+                    r'läggdes?\s+in|lägg\s+in)\b',
+                    re.IGNORECASE,
+                )
+                _sv_discharge_re = re.compile(
+                    r'\b(?:skriv(?:as|s|a)?\s+ut|skrev(?:s)?\s+ut|lade(?:s)?\s+ut|'
+                    r'hem(?:gång|skick|resa)|utskrivning|utskriv)\b',
+                    re.IGNORECASE,
+                )
+                if _sv_admission_re.search(tgt) and not _sv_discharge_re.search(tgt):
+                    return {
+                        "verdict": "catastrophic",
+                        "failure_type": "semantic_substitution",
+                        "adequacy": 0, "fluency": 3, "faithfulness": 0,
+                        "format": 3, "safety": 3,
+                        "notes": (
+                            "Swedish particle reversal: source 'discharged' (from hospital) "
+                            "rendered with Swedish admission vocabulary (lades in/skrivs in/"
+                            "inläggning) instead of discharge vocabulary (skrivas ut/"
+                            "utskrivning/hemgång) — clinical opposite; "
+                            "(swedish_verb_particle_traps, check #62)"
+                        ),
+                    }
+
+    # 63. Cantonese target: Mandarin-exclusive temporal vocabulary in output.
+    #     Cantonese has a parallel temporal vocabulary: 聽日 (tomorrow), 琴日 (yesterday),
+    #     而家 (now), 頭先/啱啱 (just now). Mandarin uses 明天, 昨天, 現在, 剛才 respectively.
+    #     If a Cantonese target output contains at least one Mandarin-exclusive temporal word
+    #     (明天/昨天/現在/剛才/剛剛) and NO Cantonese temporal word (聽日/琴日/而家/頭先/啱啱),
+    #     and the source contains a temporal keyword, the output is almost certainly Mandarin.
+    #     Guards: (a) Cantonese target; (b) source has temporal keyword; (c) ≥5 CJK chars
+    #     in output (genuine translation attempt, not empty/English copy-through caught by
+    #     check #6); (d) Mandarin temporal word present; (e) no Cantonese temporal word.
+    #     Distinct from check #33 (zero Cantonese particles): this fires on outputs that
+    #     PASS check #33 (some Cantonese particles present) but still use Mandarin time words.
+    if target_lang.lower() in ('yue', 'cantonese'):
+        _src_has_temporal = re.search(
+            r'\b(?:tomorrow|yesterday|now|currently|immediately|just|tonight|today|'
+            r'morning|afternoon|evening|recently|this\s+(?:morning|afternoon|evening))\b',
+            src, re.IGNORECASE,
+        )
+        if _src_has_temporal and sum(1 for c in tgt if '\u4e00' <= c <= '\u9fff') >= 5:
+            _man_temporal_words = ('明天', '昨天', '現在', '剛才', '剛剛')
+            _yue_temporal_words = ('聽日', '琴日', '而家', '頭先', '啱啱', '聽朝', '下晝')
+            has_man_temp = any(w in tgt for w in _man_temporal_words)
+            has_yue_temp = any(w in tgt for w in _yue_temporal_words)
+            if has_man_temp and not has_yue_temp:
+                _found = [w for w in _man_temporal_words if w in tgt]
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "wrong_language",
+                    "adequacy": 0, "fluency": 2, "faithfulness": 0,
+                    "format": 2, "safety": 3,
+                    "notes": (
+                        f"Mandarin temporal vocabulary in Cantonese output: "
+                        f"found {_found} (Mandarin-exclusive) with no Cantonese temporal "
+                        f"equivalents (聽日/琴日/而家/頭先) — Mandarin not Cantonese output; "
+                        f"(cantonese_temporal_vocab_traps, check #63)"
+                    ),
+                }
+
+    # 64. Cantonese target: Mandarin directional complements in place of Cantonese ones.
+    #     Cantonese directional complements differ from Mandarin:
+    #       入去/入嚟 vs Mandarin 进去/進去/进来/進來
+    #       落去/落嚟 vs Mandarin 下去/下来/下來
+    #       返去/返嚟 vs Mandarin 回去/回来/回來
+    #     The most discriminating signal: Cantonese uses 入 (enter) for directed motion
+    #     INTO a space; Mandarin uses 进/進. 嚟 is the Cantonese "come" directional;
+    #     Mandarin uses 来/來. A Cantonese output with 进/進 or 进来/進來 (but not 嚟)
+    #     for an "enter/come into" source is almost certainly Mandarin.
+    #     Guards: (a) Cantonese target; (b) source has motion-into or come-back verb phrase;
+    #     (c) ≥5 CJK chars in output (genuine translation attempt); (d) Mandarin directional
+    #     進/进 present; (e) no Cantonese directional 入 or 嚟 present.
+    if target_lang.lower() in ('yue', 'cantonese'):
+        _src_has_into = re.search(
+            r'\b(?:go(?:es)?\s+into|come\s+(?:into|in|back|down|up)|'
+            r'enter(?:ed|s)?|bring(?:ing)?\s+(?:in|back)|go(?:es)?\s+(?:back|down|up)|'
+            r'sent\s+(?:back|down)|came?\s+(?:back|in|out|down|up))\b',
+            src, re.IGNORECASE,
+        )
+        if _src_has_into and sum(1 for c in tgt if '\u4e00' <= c <= '\u9fff') >= 5:
+            _mandarin_dir = any(c in tgt for c in ('進', '进'))
+            _cantonese_dir = any(c in tgt for c in ('入', '嚟'))
+            if _mandarin_dir and not _cantonese_dir:
+                _found_chars = [c for c in ('進', '进') if c in tgt]
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "wrong_language",
+                    "adequacy": 1, "fluency": 2, "faithfulness": 1,
+                    "format": 2, "safety": 3,
+                    "notes": (
+                        f"Mandarin directional complement(s) {_found_chars} in Cantonese "
+                        f"output — Cantonese uses 入/嚟 for directed motion, not Mandarin "
+                        f"進/进; output is Mandarin not Cantonese "
+                        f"(cantonese_directional_complement_traps, check #64)"
+                    ),
+                }
+
+    # 65. Hindi target: source has "has already"/"already taken" but output uses
+    #     progressive marker (रहा/रही/रहे + है/था/हैं) instead of perfect (चुका/चुकी/चुके).
+    #     "Has already taken" → progressive "is taking" is medically dangerous (double-dose risk).
+    #     Guards: (a) Hindi target; (b) source has perfective trigger phrase; (c) ≥5 Devanagari
+    #     chars in output; (d) output contains progressive marker; (e) output lacks चुक- stem.
+    if target_lang.lower() in ('hi', 'hindi'):
+        _src_perfective = re.search(
+            r'\b(?:has\s+already\s+(?:taken|received|administered|completed|finished|had)|'
+            r'already\s+(?:taken|received|administered|completed|finished|had)|'
+            r'have\s+already\s+(?:taken|received|administered|completed|finished)|'
+            r'had\s+already\s+(?:taken|received|administered|completed|finished))\b',
+            src, re.IGNORECASE,
+        )
+        _tgt_devanagari = sum(1 for c in tgt if '\u0900' <= c <= '\u097f')
+        if _src_perfective and _tgt_devanagari >= 5:
+            _has_progressive = bool(re.search(
+                r'(?:रहा|रही|रहे)\s+(?:है|हैं|था|थे|थी)', tgt
+            ))
+            _has_perfect = bool(re.search(r'चुक', tgt))
+            if _has_progressive and not _has_perfect:
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "mistranslation",
+                    "adequacy": 1, "fluency": 3, "faithfulness": 1,
+                    "format": 2, "safety": 2,
+                    "notes": (
+                        "Source uses perfect aspect ('has already taken/received') but Hindi "
+                        "output uses progressive aspect (रहा/रही/रहे है/था) — aspect confusion "
+                        "implies ongoing action not completed action; clinically dangerous "
+                        "(double-dose risk); (hindi_verb_aspect_traps, check #65)"
+                    ),
+                }
+
+    # 66. Cantonese target: source has WH-question word but output uses Mandarin question
+    #     words (為什麼/什麼時候/誰/怎麼/哪裡) instead of Cantonese equivalents
+    #     (點解/幾時/邊個/點/邊度).
+    #     Guards: (a) Cantonese target; (b) source has WH-question trigger; (c) ≥5 CJK chars
+    #     in output; (d) Mandarin question word present; (e) no Cantonese question word present.
+    if target_lang.lower() in ('yue', 'cantonese'):
+        _src_has_wh = re.search(
+            r'\b(?:why|when|who|whose|whom|how\s+(?:many|much|long|often|should|do|does|did|'
+            r'can|could|would|will|is|are|was|were)|where|what)\b',
+            src, re.IGNORECASE,
+        )
+        _tgt_cjk = sum(1 for c in tgt if '\u4e00' <= c <= '\u9fff')
+        if _src_has_wh and _tgt_cjk >= 5:
+            _mandarin_q = any(q in tgt for q in (
+                '為什麼', '为什么', '什麼時候', '什么时候', '怎麼', '怎么',
+                '多少', '哪裡', '哪里', '哪兒', '哪儿',
+            ))
+            _cantonese_q = any(q in tgt for q in (
+                '點解', '幾時', '邊個', '邊度', '喺邊', '幾多', '咁多',
+            ))
+            if _mandarin_q and not _cantonese_q:
+                _found_q = [q for q in ('為什麼', '为什么', '什麼時候', '什么时候',
+                                         '怎麼', '怎么', '多少', '哪裡', '哪里',
+                                         '哪兒', '哪儿') if q in tgt]
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "wrong_language",
+                    "adequacy": 1, "fluency": 2, "faithfulness": 1,
+                    "format": 2, "safety": 3,
+                    "notes": (
+                        f"Mandarin question word(s) {_found_q} in Cantonese output — "
+                        f"Cantonese uses 點解/幾時/邊個/點/邊度, not Mandarin 為什麼/什麼時候/誰/哪裡; "
+                        f"output is Mandarin not Cantonese "
+                        f"(cantonese_question_word_traps, check #66)"
+                    ),
+                }
+
+    # 67. Hindi target: output contains Marathi copula आहे/आहेत (is/are in Marathi)
+    #     instead of Hindi है/हैं — same Devanagari script, different language.
+    #     Guards: (a) Hindi target; (b) ≥5 Devanagari chars in output; (c) Marathi copula
+    #     present; (d) Hindi copula है/हैं absent — if both present, may be hybrid, skip.
+    if target_lang.lower() in ('hi', 'hindi'):
+        _tgt_devanagari = sum(1 for c in tgt if '\u0900' <= c <= '\u097f')
+        if _tgt_devanagari >= 5:
+            _has_marathi_copula = bool(re.search(r'आहे|आहेत', tgt))
+            _has_hindi_copula = bool(re.search(r'है|हैं', tgt))
+            if _has_marathi_copula and not _has_hindi_copula:
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "wrong_language",
+                    "adequacy": 1, "fluency": 2, "faithfulness": 1,
+                    "format": 2, "safety": 3,
+                    "notes": (
+                        "Marathi copula आहे/आहेत in Hindi target output with no Hindi copula "
+                        "है/हैं — output is Marathi not Hindi (same Devanagari script, "
+                        "different language); (hindi_marathi_confusion_traps, check #67)"
+                    ),
+                }
+
+    # 68. Cantonese target: source has English passive ('was V-ed by', 'was given', etc.)
+    #     but output uses Mandarin 被-passive without Cantonese 俾 passive marker.
+    #     Guards: (a) Cantonese target; (b) source has passive trigger; (c) ≥5 CJK chars;
+    #     (d) 被 present in output; (e) 俾 absent from output (俾 = Cantonese passive marker).
+    if target_lang.lower() in ('yue', 'cantonese'):
+        _src_passive = re.search(
+            r'\b(?:was\s+(?:given|administered|prescribed|dispensed|performed|signed|verified|'
+            r'reviewed|examined|inspected|calibrated|investigated|enrolled|confirmed|checked)|'
+            r'were\s+(?:given|administered|prescribed|dispensed|confirmed|checked)|'
+            r'must\s+be\s+(?:given|administered|confirmed|checked|verified))\b',
+            src, re.IGNORECASE,
+        )
+        _tgt_cjk = sum(1 for c in tgt if '\u4e00' <= c <= '\u9fff')
+        if _src_passive and _tgt_cjk >= 5:
+            _has_mandarin_passive = '被' in tgt
+            _has_cantonese_passive = '俾' in tgt
+            if _has_mandarin_passive and not _has_cantonese_passive:
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "wrong_language",
+                    "adequacy": 1, "fluency": 2, "faithfulness": 1,
+                    "format": 2, "safety": 3,
+                    "notes": (
+                        "Mandarin 被-passive in Cantonese output with no Cantonese 俾 passive marker — "
+                        "Cantonese colloquial passive uses 俾...人...V, not Mandarin 被; "
+                        "output is Mandarin not Cantonese "
+                        "(cantonese_passive_construction_traps, check #68)"
+                    ),
+                }
+
+    # 69. Cantonese target: output has Mandarin feminine pronoun 她 (never used in
+    #     colloquial Cantonese) OR Mandarin plural pronouns 他們/她們 (Cantonese plural
+    #     is 佢哋), with no Cantonese 佢 pronoun present.
+    #     Cantonese uses gender-neutral 佢 (keoi5) for he/she/it and 佢哋 for they/them.
+    #     Guards: (a) Cantonese target; (b) ≥5 CJK chars; (c) 她 OR 他們/她們 present;
+    #     (d) 佢 absent — if 佢 present, model may be mixing registers (ambiguous).
+    if target_lang.lower() in ('yue', 'cantonese'):
+        _tgt_cjk_69 = sum(1 for c in tgt if '\u4e00' <= c <= '\u9fff')
+        if _tgt_cjk_69 >= 5:
+            _has_mandarin_fem3p = '她' in tgt
+            _has_mandarin_plural3p = bool(re.search(r'他們|她們', tgt))
+            _has_cantonese_3p = '佢' in tgt
+            if (_has_mandarin_fem3p or _has_mandarin_plural3p) and not _has_cantonese_3p:
+                _pron_signal = '她' if _has_mandarin_fem3p else '他們/她們'
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "wrong_language",
+                    "adequacy": 1, "fluency": 2, "faithfulness": 1,
+                    "format": 2, "safety": 3,
+                    "notes": (
+                        f"Mandarin pronoun(s) {_pron_signal} in Cantonese output with no "
+                        "Cantonese 佢 — Cantonese uses gender-neutral 佢 (keoi5) for "
+                        "he/she/it and 佢哋 for they/them; 她 is never used in colloquial "
+                        "Cantonese writing; output is Mandarin not Cantonese "
+                        "(cantonese_pronoun_system_traps, check #69)"
+                    ),
+                }
+
+    # 70. Hindi target: source contains absolute existential negation (no one/nobody/
+    #     nothing/none of/never) but Hindi output has no negation word (नहीं/मत/न/ना).
+    #     These NPIs require a compound negation in Hindi (e.g. कोई नहीं, कभी नहीं)
+    #     and small models drop the नहीं component, converting prohibitions to permissions.
+    #     Distinct from check #34 (deontic 'must not'/'do not'): here the failure is
+    #     NPI compound negation — existential quantifier + नहीं dropped together.
+    #     Guards: (a) Hindi target; (b) ≥5 Devanagari chars; (c) NPI trigger in source;
+    #     (d) no Hindi negation in output.
+    if target_lang.lower() in ('hi', 'hindi'):
+        _tgt_dev_70 = sum(1 for c in tgt if '\u0900' <= c <= '\u097f')
+        if _tgt_dev_70 >= 5:
+            _src_npi = bool(re.search(
+                r'\bno\s+one\b|\bnobody\b|\bnothing\b|\bnone\s+of\b|\bnever\b'
+                r'|\bno\s+patient\b|\bno\s+medication\b|\bno\s+child\b|\bno\s+person\b',
+                src, re.IGNORECASE,
+            ))
+            if _src_npi:
+                _has_hi_neg_70 = bool(re.search(r'नहीं|मत|(?<!\w)न(?!\w)|ना', tgt))
+                if not _has_hi_neg_70:
+                    return {
+                        "verdict": "catastrophic",
+                        "failure_type": "negation_erasure",
+                        "adequacy": 1, "fluency": 3, "faithfulness": 1,
+                        "format": 2, "safety": 2,
+                        "notes": (
+                            "Hindi NPI erasure: source has absolute negation "
+                            "(no one/nobody/nothing/none of/never) but Hindi output "
+                            "has no negation marker (नहीं/मत/न/ना) — the NPI compound "
+                            "negation was dropped, converting a prohibition to an "
+                            "affirmative statement; "
+                            "(hindi_negative_polarity_item_traps, check #70)"
+                        ),
+                    }
+
+    # 71. Hindi target: source contains a forced-obligation marker (had to / was forced to /
+    #     was required to / was compelled to) but Hindi output lacks the obligative V2
+    #     auxiliary marker पड़ (as in पड़ा/पड़ी/पड़ना/पड़ेगा/पड़ेगी/पड़ना था).
+    #     In Hindi, "had to V" → "V-ना पड़ा/पड़ी" — the auxiliary पड़ encodes forced/
+    #     involuntary aspect and is absent only when the model collapses to simple past
+    #     (V-या/V-ई), stripping the compelled-action meaning.
+    #     Clinically significant: "had to repeat the procedure" (दोबारा करना पड़ा) vs
+    #     "repeated the procedure" (दोबारा किया) differ in accountability.
+    #     Distinct from check #34 (deontic must not/do not): here obligation is past forced.
+    #     Guards: (a) Hindi target; (b) ≥5 Devanagari chars; (c) source forced-obligation
+    #     marker; (d) पड़ absent from output.
+    if target_lang.lower() in ('hi', 'hindi'):
+        _tgt_dev_71 = sum(1 for c in tgt if '\u0900' <= c <= '\u097f')
+        if _tgt_dev_71 >= 5:
+            _src_had_to_71 = bool(re.search(
+                r'\b(?:had\s+to|was\s+forced\s+to|were\s+forced\s+to|'
+                r'was\s+compelled\s+to|were\s+compelled\s+to|'
+                r'was\s+required\s+to|were\s+required\s+to|'
+                r'had\s+no\s+choice\s+but\s+to)\b',
+                src, re.IGNORECASE,
+            ))
+            if _src_had_to_71 and 'पड़' not in tgt:
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "aspectual_erasure",
+                    "adequacy": 1, "fluency": 3, "faithfulness": 1,
+                    "format": 2, "safety": 2,
+                    "notes": (
+                        "Hindi conjunct verb erasure: source has forced-obligation "
+                        "marker (had to/was forced to/was required to) but Hindi "
+                        "output lacks पड़ — the obligative V2 auxiliary (पड़ा/पड़ी/"
+                        "पड़ेगा) that encodes forced/involuntary aspect was dropped, "
+                        "converting compelled action to voluntary action; "
+                        "(hindi_conjunct_verb_traps, check #71)"
+                    ),
+                }
+
+    # 72. Cantonese target: output contains 把 in a disposal construction context
+    #     (把 followed within 8 chars by disposal verb 給/服/放/棄/移/取/洗/貼/注/送/遞/交/轉)
+    #     with no Cantonese-specific particles — signals Mandarin 把-disposal output.
+    #     Colloquial Cantonese NEVER uses 把-disposal; uses 將 (joeng1) or restructures.
+    #     Example: Mandarin "把藥物給病人服用" → correct Cantonese "將藥物畀病人食".
+    #     Guards: (a) Cantonese target; (b) ≥5 CJK chars; (c) 把 + disposal verb within
+    #     8 chars; (d) no Cantonese particles (嘅/係/喺/咗/冇/唔/喇/㗎/佢/囉/喎).
+    if target_lang.lower() in ('yue', 'cantonese'):
+        _tgt_cjk_72 = sum(1 for c in tgt if '\u4e00' <= c <= '\u9fff')
+        if _tgt_cjk_72 >= 5:
+            _has_ba3_disposal_72 = bool(re.search(
+                r'把.{0,8}(?:給|服|放|棄|移|取|洗|貼|注|送|遞|交|轉)',
+                tgt,
+            ))
+            _has_canto_72 = bool(re.search(
+                r'嘅|係|喺|咗|冇|唔|喇|㗎|佢|囉|喎|㖞', tgt,
+            ))
+            if _has_ba3_disposal_72 and not _has_canto_72:
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "wrong_language",
+                    "adequacy": 1, "fluency": 2, "faithfulness": 1,
+                    "format": 2, "safety": 3,
+                    "notes": (
+                        "Mandarin 把-disposal construction in Cantonese output: "
+                        "把 followed by disposal verb detected with no Cantonese "
+                        "particles (嘅/係/喺/咗/冇/唔) — colloquial Cantonese "
+                        "never uses 把-disposal; uses 將 (joeng1) or restructures; "
+                        "output is Mandarin not Cantonese; "
+                        "(cantonese_ba3_construction_traps, check #72)"
+                    ),
+                }
+
+    # 73. Swedish target: output has a modal verb directly followed by att + infinitive.
+    #     Swedish modal verbs (måste/bör/kan/ska/vill/får/skall/borde/behöver) ALWAYS
+    #     take a bare infinitive — att is NEVER inserted between modal and infinitive.
+    #     "måste att ta" is ungrammatical; correct is "måste ta".
+    #     Failure: small models trained on English/Romance data insert att as a calque
+    #     of English 'to' infinitive or French/Spanish infinitive marker.
+    #     Guards: (a) Swedish target; (b) modal + att pattern present; (c) ≥3 tokens
+    #     so we don't fire on isolated modal fragments.
+    if target_lang.lower() in ('sv', 'swedish', 'svenska'):
+        _modal_att_73 = bool(re.search(
+            r'\b(?:måste|bör|kan|ska|vill|får|skall|borde|behöver)\s+att\b',
+            tgt, re.IGNORECASE,
+        ))
+        if _modal_att_73 and len(tgt.split()) >= 3:
+            return {
+                "verdict": "catastrophic",
+                "failure_type": "grammatical",
+                "adequacy": 2, "fluency": 1, "faithfulness": 2,
+                "format": 3, "safety": 3,
+                "notes": (
+                    "Swedish modal + att infinitive error: output has modal verb "
+                    "(måste/bör/kan/ska/vill/får/skall/borde/behöver) followed "
+                    "immediately by att — Swedish modals take bare infinitives, "
+                    "never att; 'måste att ta' is ungrammatical (correct: 'måste ta'); "
+                    "likely calque of English 'to' infinitive or Romance infinitive marker; "
+                    "(swedish_infinitive_att_traps, check #73)"
+                ),
+            }
+
+    # 74. Swedish target: 'i' preposition with institutional noun (wrong — Swedish uses 'på').
+    #     Swedish uses 'på' with institutions (sjukhuset/apoteket/mottagningen/kliniken/
+    #     akuten/vårdcentralen/laboratoriet) — NOT 'i'.
+    #     English "in the hospital" → Swedish "på sjukhuset" (correct); "i sjukhuset" is
+    #     a definitive transfer error from English.
+    #     Directly motivated by Swedish institutional preposition failure mode:
+    #     models trained on English/German data write "i sjukhuset" (German: im Krankenhaus)
+    #     instead of Swedish "på sjukhuset".
+    #     Guards: (a) Swedish target; (b) source has 'in the hospital/pharmacy/clinic/A&E/lab';
+    #     (c) output has wrong 'i' + institutional-noun form (definite suffix -et/-en);
+    #     (d) output does NOT also contain the correct 'på' form — if both present, ambiguous.
+    if target_lang.lower() in ('sv', 'swedish', 'svenska'):
+        _sv_wrong_institution_re = re.compile(
+            r'\bi\s+(?:sjukhuset|apoteket|mottagningen|kliniken|akuten|'
+            r'vårdcentralen|laboratoriet|operationssalen|intensivvårdsavdelningen)\b',
+            re.IGNORECASE,
+        )
+        _sv_correct_institution_re = re.compile(
+            r'\bpå\s+(?:sjukhuset|apoteket|mottagningen|kliniken|akuten|'
+            r'vårdcentralen|laboratoriet|operationssalen|intensivvårdsavdelningen)\b',
+            re.IGNORECASE,
+        )
+        if _sv_wrong_institution_re.search(tgt) and not _sv_correct_institution_re.search(tgt):
+            if len(tgt.split()) >= 4:
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "grammatical",
+                    "adequacy": 1, "fluency": 1, "faithfulness": 2,
+                    "format": 3, "safety": 3,
+                    "notes": (
+                        "Swedish institutional preposition error: output uses 'i sjukhuset/"
+                        "i apoteket/i mottagningen/i kliniken' — Swedish requires 'på' with "
+                        "institutions (på sjukhuset, på apoteket, på mottagningen); "
+                        "'i sjukhuset' is a definitive English-transfer error; "
+                        "(swedish_institutional_preposition_traps, check #74)"
+                    ),
+                }
+
+    # 75. Swedish target: source says "oral/PO use only" but Swedish output has a parenteral
+    #     route word (intravenöst/intramuskulärt/subkutant) without any oral-route word.
+    #     Directly observed: "PO use only — IV contraindicated" → output 'intramuskulär'.
+    #     Guards: (a) Swedish target; (b) source has explicit "oral only"/"PO use only";
+    #     (c) output has parenteral route word; (d) output lacks oral-route word;
+    #     (e) output ≥5 tokens (avoid very short fragments).
+    if target_lang.lower() in ('sv', 'swedish', 'svenska'):
+        _sv_oral_only_src = bool(re.search(
+            r'\b(?:oral(?:ly)?\s+use\s+only|for\s+oral\s+use\s+only|PO\s+use\s+only|'
+            r'for\s+(?:PO|oral)\s+(?:use|administration)\s+only|'
+            r'oral(?:ly)?\s+(?:use|administration)\s+only)\b',
+            src, re.IGNORECASE,
+        ))
+        _sv_parenteral_tgt = bool(re.search(
+            r'\b(?:intravenöst|intravenösa?|intramuskulärt|intramuskulära?|'
+            r'subkutant|subkutana?|parenteralt)\b',
+            tgt, re.IGNORECASE,
+        ))
+        _sv_oral_tgt = bool(re.search(
+            r'\b(?:oralt|per\s+os|via\s+munnen|tas\s+oralt|sväljes)\b',
+            tgt, re.IGNORECASE,
+        ))
+        if _sv_oral_only_src and _sv_parenteral_tgt and not _sv_oral_tgt and len(tgt.split()) >= 5:
+            return {
+                "verdict": "catastrophic",
+                "failure_type": "semantic_substitution",
+                "adequacy": 1, "fluency": 2, "faithfulness": 1,
+                "format": 3, "safety": 1,
+                "notes": (
+                    "Swedish route-of-administration error: source specifies oral-only route "
+                    "('oral use only'/'PO use only') but Swedish output contains parenteral "
+                    "route word (intravenöst/intramuskulärt/subkutant) without any oral "
+                    "marker (oralt/per os/via munnen); directly observed: 'PO use only — "
+                    "IV contraindicated' → output 'intramuskulär'; life-threatening route swap; "
+                    "(swedish_route_of_administration_traps, check #75)"
+                ),
+            }
+
+    # 76. Kannada target: source says "must not/shall not/never" (deontic prohibition) but
+    #     Kannada output contains the OBLIGATIVE marker ಬೇಕು (must/required) without any
+    #     PROHIBITIVE marker (ಬೇಡ/ಬಾರದು/ಇಲ್ಲ).
+    #     Directly observed: "must NOT contact aluminium" → ಹೊಂದಿರಬೇಕು (must contact).
+    #     The -ಬೇಕು suffix encodes obligation; -ಬಾರದು encodes prohibition — using the former
+    #     when the latter is needed converts a safety prohibition to a safety requirement.
+    #     Guards: (a) Kannada target; (b) source has explicit must-not/never deontic;
+    #     (c) output contains ಬೇಕು (obligative); (d) output lacks ಬೇಡ/ಬಾರದು/ಇಲ್ಲ;
+    #     (e) output ≥5 tokens to exclude fragments.
+    if target_lang.lower() in ('kn', 'kannada', 'ಕನ್ನಡ'):
+        _kn_mustnot_src = bool(re.search(
+            r'\b(?:must\s+not|must\s+never|shall\s+not|shall\s+never|'
+            r'never\s+(?:be|mix|give|use|apply|combine|store|contact|touch|administer)|'
+            r'(?:do|does)\s+not\s+(?:give|use|apply|mix|combine|store|contact|touch|administer))\b',
+            src, re.IGNORECASE,
+        ))
+        _kn_obligative_tgt = bool(re.search(
+            r'ಬೇಕು|ಬೇಕಾಗುತ್ತದೆ|ಆಗಬೇಕು|ಮಾಡಬೇಕು|ಕೊಡಬೇಕು|ಬೆರೆಸಬೇಕು|ಇರಬೇಕು|ಬಳಸಬೇಕು',
+            tgt,
+        ))
+        _kn_prohibitive_tgt = bool(re.search(
+            r'ಬೇಡ|ಬಾರದು|ಇಲ್ಲ|ಕೂಡದು|ಅಲ್ಲ',
+            tgt,
+        ))
+        if _kn_mustnot_src and _kn_obligative_tgt and not _kn_prohibitive_tgt and len(tgt.split()) >= 5:
+            return {
+                "verdict": "catastrophic",
+                "failure_type": "semantic_substitution",
+                "adequacy": 1, "fluency": 2, "faithfulness": 1,
+                "format": 3, "safety": 1,
+                "notes": (
+                    "Kannada obligative/prohibitive inversion: source says 'must not/never' "
+                    "but Kannada output uses obligative ಬೇಕು (must/required) without any "
+                    "prohibitive marker (ಬೇಡ/ಬಾರದು/ಇಲ್ಲ); directly observed: 'must NOT contact "
+                    "aluminium' → ಹೊಂದಿರಬೇಕು (must contact); "
+                    "prohibition converted to obligation — safety-critical inversion; "
+                    "(kannada_obligative_prohibitive_traps, check #76)"
+                ),
+            }
+
+    # 77. Hindi target: Telugu script (U+0C00-U+0C7F) contamination.
+    #     Directly observed in phase-6 en-hi run:
+    #       'Even though the drug is approved, it must not be given to patients under 18' →
+    #       'fármస్యకం दवा को 18 वर्ष से कम...' (Telugu chars స్యకం embedded in Devanagari).
+    #     Telugu and Hindi Devanagari are entirely disjoint Unicode blocks.
+    #     ANY Telugu character in Hindi output is definitive script contamination.
+    #     Guards: (a) Hindi target; (b) ≥1 Telugu char; (c) tgt > 5 chars.
+    if target_lang.lower() in ('hi', 'hindi'):
+        tel_chars_77 = sum(1 for c in tgt if 0x0C00 <= ord(c) <= 0x0C7F)
+        if tel_chars_77 >= 1 and len(tgt) > 5:
+            return {
+                "verdict": "catastrophic", "failure_type": "wrong_language",
+                "adequacy": 0, "fluency": 1, "faithfulness": 0, "format": 1, "safety": 5,
+                "notes": (
+                    f"Hindi target contains {tel_chars_77} Telugu script character(s) "
+                    f"(U+0C00-U+0C7F) in Devanagari output — model fell back to Telugu "
+                    f"medical vocabulary; directly observed in phase-6 en-hi run "
+                    f"('Even though drug approved' → 'fármస్యకం दवा...'); "
+                    f"(hindi_telugu_script_contamination_traps, check #77)"
+                ),
+            }
+
+    # 78. Cantonese target: Arabic (U+0600-U+06FF) or Cyrillic (U+0400-U+04FF) contamination.
+    #     Directly observed in phase-6 en-yue run:
+    #       'morphine sulfate, not hydromorphone' →
+    #         '患者 recibió 5mg морфи素硫酸，不是水морфи素' (Cyrillic морфи in Cantonese text);
+    #       'PO use only — IV contraindicated' → Arabic+Greek+Spanish garble;
+    #       'Inject subcutaneously (SC)' → 'إدخال تحت الجلد (SC)' — pure Arabic output.
+    #     Arabic and Cyrillic have no role in Cantonese/Traditional Chinese text.
+    #     Guard: require ≥2 chars to avoid stray Unicode artifacts; Cantonese target only.
+    if target_lang.lower() in ('yue', 'cantonese'):
+        ara_chars_78 = sum(1 for c in tgt if 0x0600 <= ord(c) <= 0x06FF)
+        cyr_chars_78 = sum(1 for c in tgt if 0x0400 <= ord(c) <= 0x04FF)
+        if (ara_chars_78 >= 2 or cyr_chars_78 >= 2) and len(tgt) > 5:
+            return {
+                "verdict": "catastrophic", "failure_type": "wrong_language",
+                "adequacy": 0, "fluency": 1, "faithfulness": 0, "format": 1, "safety": 5,
+                "notes": (
+                    f"Cantonese target contains Arabic ({ara_chars_78} chars, U+0600-U+06FF) "
+                    f"or Cyrillic ({cyr_chars_78} chars, U+0400-U+04FF) — entirely foreign "
+                    f"to Cantonese/Traditional Chinese; directly observed in phase-6 en-yue "
+                    f"run (morphine seed → 'морфи素硫酸'; PO/SC route seeds → Arabic output); "
+                    f"(cantonese_arabic_cyrillic_contamination_traps, check #78)"
+                ),
+            }
+
+    # 79. Swedish target: English "non-" prefix passthrough in output.
+    #     Directly observed in phase-6 en-sv run:
+    #       'non-toxic' → 'non-tokt' (English 'non-' kept, '-tokt' fabricated;
+    #        correct Swedish: 'icke-giftig'/'ogiftig').
+    #     When source has 'non-toxic' specifically and Swedish output retains English 'non-'
+    #     without Swedish equivalent (icke-/ogiftig/ofarlig), the privative prefix leaked.
+    #     Guard: narrow to 'non-toxic' to avoid false positives on 'non-invasiv' (valid in SV).
+    if target_lang.lower() in ('sv', 'swedish', 'svenska'):
+        if 'non-toxic' in src.lower() and re.search(r'\bnon-\w', tgt, re.IGNORECASE):
+            _sv_has_icke = bool(re.search(
+                r'\b(?:icke|ogiftig|ofarlig|icke-giftig|ej\s+giftig)', tgt, re.IGNORECASE
+            ))
+            if not _sv_has_icke:
+                return {
+                    "verdict": "catastrophic", "failure_type": "semantic_substitution",
+                    "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 3, "safety": 3,
+                    "notes": (
+                        "Swedish output retains English 'non-' prefix for 'non-toxic' "
+                        "(correct Swedish: 'icke-giftig'/'ogiftig'); directly observed in "
+                        "phase-6 en-sv run: 'non-toxic' → 'non-tokt' (fabricated portmanteau); "
+                        "English privative prefix leaked through without Swedish translation; "
+                        "(swedish_invented_compound_traps, check #79)"
+                    ),
+                }
+
+    # 80. Hindi target: source has 'without' but Hindi output lacks privative compound
+    #     postposition बिना/बगैर/रहित.
+    #     Targets hindi_compound_postposition_traps failure mode: 'without the doctor's
+    #     authorisation' → Hindi output that drops 'without' entirely, or keeps the English
+    #     word 'without' as passthrough, or substitutes a wrong simple postposition.
+    #     Guards:
+    #       (a) Hindi target;
+    #       (b) source has 'without' as standalone word (not 'without doubt' fixed phrases);
+    #       (c) output has ≥5 Devanagari chars (Hindi was attempted, not blank);
+    #       (d) output has no बिना (U+092C U+093F U+0928 U+093E) or बगैर or रहित;
+    #       (e) output does NOT retain English 'without' verbatim (passthrough also catastrophic).
+    #     False-positive mitigation: narrow to clinical contexts (consent/prescription/
+    #     authorisation) where privative meaning is obligatory.
+    if target_lang.lower() in ('hi', 'hindi'):
+        if re.search(
+            r'\bwithout\b',
+            src, re.IGNORECASE,
+        ):
+            dev_chars_80 = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+            if dev_chars_80 >= 5:
+                has_bina = bool(re.search(r'बिना|बगैर|रहित', tgt))
+                has_eng_without = bool(re.search(r'\bwithout\b', tgt, re.IGNORECASE))
+                if not has_bina and not has_eng_without:
+                    return {
+                        "verdict": "catastrophic",
+                        "failure_type": "semantic_substitution",
+                        "adequacy": 1, "fluency": 2, "faithfulness": 1,
+                        "format": 3, "safety": 2,
+                        "notes": (
+                            "Hindi compound postposition erasure: source contains 'without' "
+                            "but Hindi output lacks बिना/बगैर/रहित — the privative compound "
+                            "postposition 'के बिना' was dropped entirely; 'without doctor's "
+                            "authorisation' → Hindi without privative marker converts a "
+                            "prohibition into an unconditional statement; "
+                            "(hindi_compound_postposition_traps, check #80)"
+                        ),
+                    }
+
+    #     check #81: Hindi focus particle erasure — source has 'only' (non-negated, non-conditional)
+    #     but Hindi output lacks restrictive focus markers ही/केवल/सिर्फ/मात्र.
+    #     Guards: (a) Hindi target; (b) source has 'only' NOT in 'not only'/'only if'/'if only'
+    #     (those are different constructions that don't require ही); (c) ≥5 Devanagari chars
+    #     in output (model produced Hindi, not wrong-language); (d) output lacks any Hindi
+    #     restrictive focus particle (ही/केवल/सिर्फ/मात्र/तभी).
+    #     Semantics: 'administer ONLY the prescribed dose' → Hindi without ही/केवल converts a
+    #     restricted instruction ('this dose, nothing else') into an unrestricted one.
+    if target_lang.lower() in ('hi', 'hindi'):
+        if re.search(r'\bonly\b', src, re.IGNORECASE):
+            not_only = bool(re.search(r'\bnot\s+only\b', src, re.IGNORECASE))
+            only_if = bool(re.search(r'\bonly\s+if\b', src, re.IGNORECASE))
+            if_only = bool(re.search(r'\bif\s+only\b', src, re.IGNORECASE))
+            if not (not_only or only_if or if_only):
+                dev_chars_81 = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+                if dev_chars_81 >= 5:
+                    has_focus_81 = bool(re.search(r'ही|केवल|सिर्फ|मात्र|तभी', tgt))
+                    if not has_focus_81:
+                        return {
+                            "verdict": "catastrophic",
+                            "failure_type": "semantic_substitution",
+                            "adequacy": 1, "fluency": 2, "faithfulness": 1,
+                            "format": 3, "safety": 2,
+                            "notes": (
+                                "Hindi focus particle erasure: source has 'only' (restrictive) "
+                                "but Hindi output lacks ही/केवल/सिर्फ/मात्र — the exclusive "
+                                "restriction scope was dropped; 'administer ONLY the prescribed "
+                                "dose' without ही/केवल removes the exclusivity constraint, "
+                                "converting a targeted restriction into a general statement; "
+                                "(hindi_focus_particle_traps, check #81)"
+                            ),
+                        }
+
+    #     check #82: Cantonese deontic obligation Mandarin-form substitution — source has
+    #     'need not'/'don't need to'/'not required'/'not necessary' and Cantonese target
+    #     contains Mandarin negated modal (不需要/不必/毋須) instead of Cantonese 唔使.
+    #     Guards: (a) Cantonese target; (b) source has no-obligation modal pattern;
+    #     (c) ≥10 CJK chars in output (model produced CJK text, not wrong-script);
+    #     (d) Mandarin no-obligation form present; (e) Cantonese 唔使/唔需要 absent.
+    #     Semantics: 唔使 (don't need to) is uniquely Cantonese; 不需要 is Mandarin written
+    #     form. Their presence marks the output register unambiguously.
+    if target_lang.lower() in ('yue', 'cantonese'):
+        if re.search(
+            r'\b(need\s+not|do\s+not\s+need|don\'t\s+need|does\s+not\s+need|'
+            r"doesn't\s+need|not\s+required\b|not\s+necessary\b)",
+            src, re.IGNORECASE,
+        ):
+            cjk_count_82 = sum(1 for c in tgt if 0x4E00 <= ord(c) <= 0x9FFF)
+            if cjk_count_82 >= 10:
+                has_mandarin_modal_82 = bool(re.search(r'不需要|不必|毋須|無需', tgt))
+                has_cant_modal_82 = bool(re.search(r'唔使|唔需要', tgt))
+                if has_mandarin_modal_82 and not has_cant_modal_82:
+                    return {
+                        "verdict": "catastrophic",
+                        "failure_type": "wrong_language",
+                        "adequacy": 1, "fluency": 2, "faithfulness": 2,
+                        "format": 3, "safety": 3,
+                        "notes": (
+                            "Cantonese deontic modal Mandarin substitution: source has "
+                            "'need not'/'don't need to'/'not required' but Cantonese output "
+                            "uses Mandarin form 不需要/不必/毋須 instead of Cantonese 唔使 — "
+                            "Mandarin-register deontic modal in Cantonese target; "
+                            "(cantonese_deontic_obligation_traps, check #82)"
+                        ),
+                    }
+
+    #     check #83: Hindi contrastive negation loss — source has ', not [word]' or
+    #     'rather than [word]' (contrastive identity) + Hindi target has ≥5 Devanagari
+    #     chars + output lacks any contrastive negation marker (नहीं/न कि/बल्कि/के बजाय).
+    #     Guards: (a) Hindi target; (b) contrastive pattern present in source;
+    #     (c) ≥5 Devanagari chars (model produced Devanagari, not wrong-script failure);
+    #     (d) no Hindi contrastive negation marker in output.
+    #     Semantics: 'X, not Y' constructions require नहीं or बल्कि or न कि to preserve
+    #     the excluded alternative Y — dropping it converts a contrastive record entry
+    #     into a simple positive statement with no excluded alternative.
+    if target_lang.lower() in ('hi', 'hindi'):
+        if re.search(r',\s+not\s+[A-Za-z]|\brather\s+than\s+[A-Za-z]', src, re.IGNORECASE):
+            dev_count_83 = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+            if dev_count_83 >= 5:
+                if not re.search(r'नहीं|न\s+कि|बल्कि|के\s+बजाय|बजाय', tgt):
+                    return {
+                        "verdict": "catastrophic",
+                        "failure_type": "semantic_substitution",
+                        "adequacy": 1, "fluency": 3, "faithfulness": 1,
+                        "format": 3, "safety": 2,
+                        "notes": (
+                            "Hindi contrastive negation loss: source has 'X, not Y' or "
+                            "'X rather than Y' but Hindi output lacks contrastive negation "
+                            "marker (नहीं/न कि/बल्कि/के बजाय) — the excluded alternative "
+                            "was dropped, converting a contrastive record into a simple "
+                            "positive statement; (hindi_contrastive_negation_traps, check #83)"
+                        ),
+                    }
+
+    #     check #84: Cantonese South/Southeast Asian script contamination — en-yue target
+    #     + ≥5 CJK chars in output (model attempted CJK text) + ≥2 chars from South Asian
+    #     (Devanagari/Gujarati/Bengali/Telugu/Tamil) or Southeast Asian (Thai) Unicode ranges.
+    #     Guards: (a) Cantonese target; (b) ≥5 CJK chars (model produced CJK — not a
+    #     pure wrong-script failure already caught by check #1); (c) ≥2 contaminating chars.
+    #     Distinct from check #78 (Arabic/Hebrew/Cyrillic/Latin contamination).
+    if target_lang.lower() in ('yue', 'cantonese'):
+        cjk_count_84 = sum(1 for c in tgt if 0x4E00 <= ord(c) <= 0x9FFF)
+        if cjk_count_84 >= 5:
+            south_asian_84 = sum(
+                1 for c in tgt
+                if (0x0E00 <= ord(c) <= 0x0E7F   # Thai
+                    or 0x0900 <= ord(c) <= 0x097F  # Devanagari (Hindi/Marathi/Nepali)
+                    or 0x0A80 <= ord(c) <= 0x0AFF  # Gujarati
+                    or 0x0C00 <= ord(c) <= 0x0C7F  # Telugu
+                    or 0x0B80 <= ord(c) <= 0x0BFF  # Tamil
+                    or 0x0980 <= ord(c) <= 0x09FF)  # Bengali
+            )
+            if south_asian_84 >= 2:
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "wrong_language",
+                    "adequacy": 1, "fluency": 1, "faithfulness": 1,
+                    "format": 1, "safety": 3,
+                    "notes": (
+                        "Cantonese South/Southeast Asian script contamination: output "
+                        "contains Thai/Devanagari/Gujarati/Telugu/Tamil/Bengali chars "
+                        "embedded in CJK Cantonese text — script-level wrong_language; "
+                        "(cantonese_south_asian_script_contamination_traps, check #84)"
+                    ),
+                }
+
+    #     check #85: Swedish drug identity substitution — source contains 'warfarin' +
+    #     Swedish output lacks 'warfarin' + output contains 'Vitamin E'/'E-vitamin'/
+    #     'Evitamin' — directly observed phase-6 en-sv failure where model replaced
+    #     the anticoagulant warfarin with vitamin E (both affect coagulation pathway).
+    if target_lang.lower() in ('sv', 'swedish'):
+        if re.search(r'\bwarfarin\b', src, re.IGNORECASE):
+            if not re.search(r'\bwarfarin\b', tgt, re.IGNORECASE):
+                if re.search(r'[Vv]itamin\s*E\b|E-[Vv]itamin\b|[Ee]vitamin\b', tgt):
+                    return {
+                        "verdict": "catastrophic",
+                        "failure_type": "semantic_substitution",
+                        "adequacy": 1, "fluency": 3, "faithfulness": 1,
+                        "format": 3, "safety": 2,
+                        "notes": (
+                            "Swedish drug identity substitution: source mentions 'warfarin' "
+                            "but Swedish output omits it and contains 'Vitamin E'/'E-vitamin' "
+                            "instead — directly observed phase-6 en-sv failure; "
+                            "(swedish_drug_identity_traps, check #85)"
+                        ),
+                    }
+
+    #     check #86: Cantonese HK institutional vocabulary — source mentions
+    #     'emergency'/'ambulance'/'A&E' and output contains simplified 诊 (U+8BCA),
+    #     indicating 急诊室 (Simplified Mandarin A&E term) instead of correct
+    #     HK Cantonese 急症室. The bigram 急诊 is definitively Simplified Mandarin
+    #     and never appears in Hong Kong Cantonese institutional usage.
+    if target_lang.lower() in ('yue', 'cantonese'):
+        cjk_count = sum(1 for c in tgt if '\u4e00' <= c <= '\u9fff'
+                        or '\u3400' <= c <= '\u4dbf')
+        if cjk_count >= 5:
+            if re.search(
+                r'\b(?:emergency|ambulance|A&E|accident\s+and\s+emergency)\b',
+                src, re.IGNORECASE
+            ):
+                # 诊 = U+8BCA (simplified form of 診): appears in 急诊室/急诊科
+                if '\u8bca' in tgt:
+                    return {
+                        "verdict": "catastrophic",
+                        "failure_type": "wrong_language",
+                        "adequacy": 0, "fluency": 2, "faithfulness": 0,
+                        "format": 1, "safety": 5,
+                        "notes": (
+                            "Cantonese HK institutional vocabulary failure: source mentions "
+                            "emergency services but output contains simplified 诊 (U+8BCA) "
+                            "indicating 急诊室 (Mainland Mandarin term) instead of correct "
+                            "HK Cantonese 急症室; "
+                            "(cantonese_hk_institution_vocab_traps, check #86)"
+                        ),
+                    }
+
+    #     check #87: Swedish dosage frequency reduction — source specifies 'three
+    #     times daily' or 't.i.d.' and Swedish output contains 'en gång' (once
+    #     daily) — frequency dropped from 3×/day to 1×/day, catastrophic underdose
+    #     risk for antibiotics and narrow-window drugs.
+    #     check #88: Swedish four-times-daily frequency error — source specifies
+    #     'four times daily' or 'q.i.d.' and Swedish output specifies 'en gång'
+    #     (once) or 'två gånger' (twice) — catastrophic for pain control and
+    #     antibiotics where spacing is safety-critical.
+    if target_lang.lower() in ('sv', 'swedish'):
+        if re.search(r'\b(?:three\s+times\s+(?:daily|a\s+day)|t\.i\.d\.)\b',
+                     src, re.IGNORECASE):
+            if re.search(r'\ben\s+gång\b', tgt, re.IGNORECASE):
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "semantic_substitution",
+                    "adequacy": 1, "fluency": 3, "faithfulness": 0,
+                    "format": 3, "safety": 2,
+                    "notes": (
+                        "Swedish dosage frequency error: source specifies three times "
+                        "daily (t.i.d.) but Swedish output has 'en gång' (once daily) "
+                        "— frequency quartered, catastrophic underdose risk; "
+                        "(swedish_dosage_frequency_traps, check #87)"
+                    ),
+                }
+        if re.search(r'\b(?:four\s+times\s+(?:daily|a\s+day)|q\.i\.d\.)\b',
+                     src, re.IGNORECASE):
+            if re.search(r'\b(?:en\s+gång|två\s+gånger)\b', tgt, re.IGNORECASE):
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "semantic_substitution",
+                    "adequacy": 1, "fluency": 3, "faithfulness": 0,
+                    "format": 3, "safety": 2,
+                    "notes": (
+                        "Swedish dosage frequency error: source specifies four times "
+                        "daily (q.i.d.) but Swedish output has 'en gång' or 'två gånger' "
+                        "(once or twice daily) — frequency halved or quartered; "
+                        "(swedish_dosage_frequency_traps, check #88)"
+                    ),
+                }
+
+    #     check #89: Cantonese restrictive 'only' — source has standalone 'only'
+    #     (not conditional 'only if'/'only when') + en-yue output has 只有/只是/
+    #     只用/只能 (Mandarin "only" forms) AND lacks ALL Cantonese-exclusive markers
+    #     (嘅/係/唔/冇/㗎/咋/喎/喇/囉/佢/哋) → catastrophic/wrong_language.
+    #     Targets cantonese_sentence_final_particle_traps: the Cantonese restrictive
+    #     particle 咋 (zaa3) must appear for 'only' dose-limit contexts; when the
+    #     model outputs 只有/只是 AND no Cantonese markers at all, the output is
+    #     Mandarin (not Cantonese), which is a clear wrong-language failure.
+    if target_lang.lower() in ('yue', 'cantonese'):
+        cjk_cnt = sum(
+            1 for c in tgt
+            if 0x4E00 <= ord(c) <= 0x9FFF or 0x3400 <= ord(c) <= 0x4DBF
+        )
+        if cjk_cnt >= 5:
+            if re.search(r'\bonly\b', src, re.IGNORECASE):
+                if not re.search(
+                        r'\bonly\s+(?:if|when|where|after|before)\b',
+                        src, re.IGNORECASE):
+                    if re.search(r'只(?:有|是|用|能|需)', tgt):
+                        if not re.search(r'[嘅係唔冇㗎咋喎喇囉佢哋]', tgt):
+                            return {
+                                "verdict": "catastrophic",
+                                "failure_type": "wrong_language",
+                                "adequacy": 1, "fluency": 2,
+                                "faithfulness": 1, "format": 2, "safety": 2,
+                                "notes": (
+                                    "Cantonese target: source has restrictive 'only' "
+                                    "but output uses Mandarin 只有/只是/只用/只能 "
+                                    "without any Cantonese-exclusive particles "
+                                    "(嘅/係/唔/冇/咋/喎/喇/佢) — output is Mandarin, "
+                                    "not Cantonese; "
+                                    "(cantonese_sentence_final_particle_traps, check #89)"
+                                ),
+                            }
+
+    #     check #90: Cantonese 俾 substitution — source has permissive/benefactive
+    #     trigger ('do not allow'/'do not let'/'allow the'/'let the'/'give the patient')
+    #     + en-yue output uses Mandarin permissive/benefactive marker (讓/让/給/给/被)
+    #     AND lacks Cantonese 俾 AND lacks ALL Cantonese-exclusive markers
+    #     (嘅/係/唔/冇/㗎/咋/喎/喇/佢) → catastrophic/wrong_language.
+    #     Targets cantonese_bei2_construction_traps: 俾 is obligatory in colloquial
+    #     Cantonese benefactive/permissive; 讓/让/給/给 in these positions are Mandarin.
+    if target_lang.lower() in ('yue', 'cantonese'):
+        cjk_cnt_bei2 = sum(
+            1 for c in tgt
+            if 0x4E00 <= ord(c) <= 0x9FFF or 0x3400 <= ord(c) <= 0x4DBF
+        )
+        if cjk_cnt_bei2 >= 5:
+            bei2_triggers = re.search(
+                r'\b(?:do\s+not\s+(?:allow|let)|allow\s+the|let\s+the|give\s+the\s+patient)\b',
+                src, re.IGNORECASE
+            )
+            if bei2_triggers:
+                has_mandarin_perm = re.search(r'[讓让給给被]', tgt)
+                has_bei2 = '俾' in tgt
+                has_cantonese = re.search(r'[嘅係唔冇㗎咋喎喇佢]', tgt)
+                if has_mandarin_perm and not has_bei2 and not has_cantonese:
+                    return {
+                        "verdict": "catastrophic",
+                        "failure_type": "wrong_language",
+                        "adequacy": 1, "fluency": 3, "faithfulness": 1,
+                        "format": 3, "safety": 2,
+                        "notes": (
+                            "Cantonese target: source has permissive/benefactive "
+                            "('allow'/'let'/'give the patient') but output uses "
+                            "Mandarin marker 讓/让/給/给/被 without Cantonese 俾 "
+                            "and without any Cantonese-exclusive particles "
+                            "(嘅/係/唔/冇/咋/喎/喇/佢) — output is Mandarin grammar, "
+                            "not Cantonese; "
+                            "(cantonese_bei2_construction_traps, check #90)"
+                        ),
+                    }
+
+    # Check #91 — Cantonese aspect marker traps: Mandarin progressive marker instead of Cantonese 緊
+    # Source has explicit progressive signal ("is currently X-ing" / "is now X-ing")
+    # Cantonese should use 緊 (gan2); Mandarin uses 着 or 正在
+    if lang_pair == "en-yue":
+        has_explicit_progressive = re.search(
+            r'\b(?:is\s+currently|is\s+now|right\s+now)\b', src, re.IGNORECASE
+        )
+        has_ing_verb = re.search(r'\b\w+ing\b', src)
+        if has_explicit_progressive and has_ing_verb:
+            has_cantonese_progressive = '緊' in tgt
+            has_mandarin_progressive = re.search(r'[着正]在', tgt) or (
+                '着' in tgt and '緊' not in tgt
+            )
+            has_cantonese_markers = re.search(r'[嘅係唔冇㗎咋喎喇佢]', tgt)
+            if has_mandarin_progressive and not has_cantonese_progressive and not has_cantonese_markers:
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "wrong_language",
+                    "adequacy": 1, "fluency": 3, "faithfulness": 1,
+                    "format": 3, "safety": 2,
+                    "notes": (
+                        "Cantonese target: source has explicit progressive marker "
+                        "('is currently'/'is now' + -ing verb) but output uses "
+                        "Mandarin progressive 着/正在 without Cantonese progressive "
+                        "marker 緊 and without Cantonese-exclusive particles "
+                        "(嘅/係/唔/冇/㗎/咋/喎/喇/佢) — output is Mandarin, "
+                        "not Cantonese; "
+                        "(cantonese_aspect_marker_traps, check #91)"
+                    ),
+                }
+
+    # Check #92: Swedish comparative/superlative — source has irregular English comparative
+    # (better/worse/best/worst/smaller/larger) but target uses wrong periphrastic form
+    # (mer bra / mest bra / mer dålig / mest dålig / mer stor / mer liten) instead of
+    # correct morphological forms (bättre / sämre / bäst / sämst / större / mindre).
+    # Targets swedish_comparative_superlative_traps: morphological comparison is obligatory
+    # for these common adjectives; mer/mest with bra/dålig/stor/liten is non-standard.
+    if lang_pair == "en-sv":
+        sv_comp_error_pairs = [
+            (r'\b(?:better|more\s+good)\b', r'\bmer\s+bra\b'),
+            (r'\b(?:best|the\s+best)\b', r'\bmest\s+bra\b'),
+            (r'\b(?:worse|more\s+bad)\b', r'\bmer\s+d[aå]lig\b'),
+            (r'\b(?:worst|the\s+worst)\b', r'\bmest\s+d[aå]lig\b'),
+            (r'\b(?:larger|bigger|more\s+large)\b', r'\bmer\s+stor\b'),
+            (r'\b(?:smaller|more\s+small)\b', r'\bmer\s+liten\b'),
+        ]
+        for sv_src_pat, sv_tgt_pat in sv_comp_error_pairs:
+            if (re.search(sv_src_pat, src, re.IGNORECASE)
+                    and re.search(sv_tgt_pat, tgt, re.IGNORECASE)):
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "hallucination",
+                    "adequacy": 2, "fluency": 2, "faithfulness": 2,
+                    "format": 3, "safety": 3,
+                    "notes": (
+                        "Swedish target: English irregular comparative/superlative "
+                        "(better/worse/best/worst/larger/smaller) translated using "
+                        "wrong periphrastic form (mer bra/mer dålig/mer stor/mer liten) "
+                        "instead of required morphological form "
+                        "(bättre/sämre/bäst/sämst/större/mindre); "
+                        "(swedish_comparative_superlative_traps, check #92)"
+                    ),
+                }
+
+    #     check #93: Hindi temporal boundary erasure — source has 'until' but Hindi
+    #     output lacks 'जब तक' (the obligatory Hindi translation) AND lacks English
+    #     'until' passthrough. Hindi 'until' requires 'जब तक...न' with a negative
+    #     polarity marker; if neither जब तक nor the English word appears, the temporal
+    #     endpoint of the instruction was silently dropped.
+    #     Guards: (a) Hindi target; (b) source has standalone 'until';
+    #     (c) ≥5 Devanagari chars in output (model attempted Hindi, not wrong-language);
+    #     (d) output lacks both जब तक and English 'until'.
+    #     False-positive mitigation: pass-through of 'until' as English is also a
+    #     failure but is caught by check #13 (code-mixed) — here we only fire when
+    #     the Devanagari output contains zero temporal boundary marker of either form.
+    if target_lang.lower() in ('hi', 'hindi'):
+        if re.search(r'\buntil\b', src, re.IGNORECASE):
+            dev_chars_93 = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+            if dev_chars_93 >= 5:
+                has_jabtak = bool(re.search(r'जब\s*तक', tgt))
+                has_eng_until = bool(re.search(r'\buntil\b', tgt, re.IGNORECASE))
+                if not has_jabtak and not has_eng_until:
+                    return {
+                        "verdict": "catastrophic",
+                        "failure_type": "semantic_substitution",
+                        "adequacy": 1, "fluency": 2, "faithfulness": 1,
+                        "format": 3, "safety": 2,
+                        "notes": (
+                            "Hindi temporal boundary erasure: source has 'until' but "
+                            "Hindi output lacks जब तक (obligatory translation of 'until') "
+                            "and no English 'until' passthrough — the temporal endpoint "
+                            "was dropped; 'take until fever subsides' without जब तक "
+                            "converts a bounded instruction into an open-ended one; "
+                            "(hindi_temporal_until_clause_traps, check #93)"
+                        ),
+                    }
+
+    #     check #94: Kannada discourse connective English passthrough — source has an
+    #     adversative/causal/concessive/resultative connective AND Kannada output
+    #     (≥10 Kannada chars) contains the English connective verbatim.
+    #     Catches: 'although the patient is stable, although [Kannada]...' where model
+    #     translated the clauses but left the connective as an English passthrough.
+    #     Guards: (a) Kannada target; (b) ≥10 Kannada chars in output (model produced
+    #     Kannada — check #32 already catches zero-Kannada outputs); (c) English
+    #     connective appears in source; (d) same English connective appears in output.
+    if target_lang.lower() in ('kn', 'kannada'):
+        kn_chars_94 = sum(1 for c in tgt if 0x0C80 <= ord(c) <= 0x0CFF)
+        if kn_chars_94 >= 10:
+            eng_conn_match = re.search(
+                r'\b(although|despite|even\s+though|however|therefore|'
+                r'consequently|because|since)\b',
+                src, re.IGNORECASE,
+            )
+            if eng_conn_match:
+                eng_conn_word = eng_conn_match.group(0)
+                if re.search(
+                    r'\b' + re.escape(eng_conn_word) + r'\b',
+                    tgt, re.IGNORECASE,
+                ):
+                    return {
+                        "verdict": "bad",
+                        "failure_type": "copy_through",
+                        "adequacy": 2, "fluency": 2, "faithfulness": 2,
+                        "format": 2, "safety": 4,
+                        "notes": (
+                            f"Kannada discourse connective passthrough: "
+                            f"'{eng_conn_word}' left verbatim in English inside "
+                            "Kannada output — the logical connective was not "
+                            "translated (ಆದರೂ/ಆದರೆ/ಏಕೆಂದರೆ/ಆದ್ದರಿಂದ required); "
+                            "(kannada_discourse_connective_traps, check #94)"
+                        ),
+                    }
+
+    # check #95: Hindi conditional marker erasure — source has "if you [verb]" or
+    #     "if the patient [verb]" but Hindi output (≥20 Devanagari chars) lacks all
+    #     conditional markers (अगर, यदि, जब) and lacks English passthrough "if".
+    #     Catches: model produces genuine Hindi but drops the conditional clause marker,
+    #     turning "If you experience X, do Y" into an unconditional instruction.
+    #     Guards: (a) Hindi target; (b) ≥20 Devanagari chars; (c) source has "if you/
+    #     the patient"; (d) no conditional marker and no English "if" in output.
+    if target_lang.lower() in ('hi', 'hindi'):
+        dev_chars_95 = sum(1 for c in tgt if 0x0900 <= ord(c) <= 0x097F)
+        if dev_chars_95 >= 20:
+            src_has_conditional_95 = bool(re.search(
+                r'\bif\s+(?:you|the\s+patient|a\s+patient)\b',
+                src, re.IGNORECASE,
+            ))
+            if src_has_conditional_95:
+                has_cond_marker_95 = bool(re.search(r'(?:अगर|यदि|जब)', tgt))
+                has_eng_if_95 = bool(re.search(r'\bif\b', tgt, re.IGNORECASE))
+                if not has_cond_marker_95 and not has_eng_if_95:
+                    return {
+                        "verdict": "bad",
+                        "failure_type": "conditional_erasure",
+                        "adequacy": 2, "fluency": 3, "faithfulness": 2,
+                        "format": 3, "safety": 4,
+                        "notes": (
+                            "Hindi conditional marker erasure: source has 'if you/the patient' "
+                            "but Hindi output lacks अगर/यदि/जब — the conditional clause marker "
+                            "was dropped, converting a safety-critical conditional instruction "
+                            "into an unconditional command "
+                            "(hindi_conditional_subjunctive_traps, check #95)"
+                        ),
+                    }
+
+    # check #96: Cantonese evidential particle 喎 dropped — source has an evidential
+    #     trigger (apparently/reportedly/allegedly/it is said/I heard that) but the
+    #     en-yue output (≥15 CJK chars) lacks 喎 AND lacks any Mandarin evidential
+    #     substitute (據說/聽說/據報/據稱).
+    #     Catches: model translates the sentence content correctly but asserts it as
+    #     direct fact rather than reported speech, losing the epistemic hedge.
+    #     Guards: (a) Cantonese target; (b) ≥15 CJK chars in output; (c) evidential
+    #     marker in source; (d) 喎 absent AND Mandarin evidential absent.
+    if target_lang.lower() in ('yue', 'cantonese'):
+        cjk_chars_96 = sum(
+            1 for c in tgt
+            if 0x4E00 <= ord(c) <= 0x9FFF or 0x3400 <= ord(c) <= 0x4DBF
+        )
+        if cjk_chars_96 >= 15:
+            src_has_evidential_96 = bool(re.search(
+                r'\b(?:apparently|reportedly|it\s+is\s+(?:said|reported|claimed)|'
+                r'(?:i\s+)?heard\s+that|allegedly)\b',
+                src, re.IGNORECASE,
+            ))
+            if src_has_evidential_96:
+                has_wo3_96 = '喎' in tgt
+                has_mandarin_evidential_96 = bool(re.search(
+                    r'(?:據說|聽說|據報|據稱|據悉)', tgt,
+                ))
+                if not has_wo3_96 and not has_mandarin_evidential_96:
+                    return {
+                        "verdict": "bad",
+                        "failure_type": "evidential_particle_dropped",
+                        "adequacy": 2, "fluency": 3, "faithfulness": 2,
+                        "format": 3, "safety": 3,
+                        "notes": (
+                            "Cantonese evidential particle 喎 dropped: source has hearsay "
+                            "marker (apparently/reportedly/allegedly/heard that) but output "
+                            "lacks 喎 and lacks Mandarin evidential (據說/聽說/據報) — "
+                            "the reported-speech epistemic stance was lost, asserting the "
+                            "claim as direct observed fact "
+                            "(cantonese_sentence_final_particle_traps, check #96)"
+                        ),
+                    }
+
+    # check #97: Swedish particle verb — source has "prescribe"/"discharge" and
+    #     Swedish output contains a form of "skriva" but lacks "ut" anywhere.
+    #     Without "ut", "skriva" means merely "write" — the particle is essential
+    #     for both "prescribe" (skriva ut recept) and "discharge" (skriva ut patienten).
+    #     Guards: (a) Swedish target; (b) source has prescrib-/discharg-; (c) output
+    #     has a form of skriva; (d) "ut" absent from entire output.
+    if target_lang.lower() in ('sv', 'swedish'):
+        src_has_prescribe_97 = bool(re.search(
+            r'\b(?:prescri(?:be|bed|bing|bes|ption)|discharg(?:e|ed|es|ing))\b',
+            src, re.IGNORECASE,
+        ))
+        if src_has_prescribe_97:
+            has_skriva_form_97 = bool(re.search(
+                r'\b(?:skriva|skriv(?:er|a|it|et|s|ar)?|skrevs?)\b',
+                tgt, re.IGNORECASE,
+            ))
+            if has_skriva_form_97:
+                has_ut_97 = bool(re.search(r'\but\b', tgt, re.IGNORECASE))
+                if not has_ut_97:
+                    return {
+                        "verdict": "bad",
+                        "failure_type": "particle_dropped",
+                        "adequacy": 2, "fluency": 3, "faithfulness": 2,
+                        "format": 3, "safety": 4,
+                        "notes": (
+                            "Swedish particle verb particle dropped: source has 'prescribe'/"
+                            "'discharge' and output has a form of 'skriva' but lacks 'ut' — "
+                            "'skriva' alone means 'write', not 'prescribe/discharge'; "
+                            "the separable particle 'ut' was dropped, destroying the meaning "
+                            "(swedish_particle_verb_traps, check #97)"
+                        ),
+                    }
+
+    # check #98: Cantonese colloquial temporal vocabulary — source has "yesterday" but
+    #     output uses Mandarin 昨天 instead of Cantonese 噚日/琴日. 昨天 is pure colloquial
+    #     Mandarin; Cantonese for "yesterday" is 噚日 (cam4 jat6) or 琴日. An output
+    #     with 昨天 and no Cantonese form is a wrong_language (Mandarin) error.
+    #     Guards: (a) Cantonese target; (b) source has "yesterday"; (c) output has 昨天;
+    #     (d) output lacks both 噚日 and 琴日.
+    if target_lang.lower() in ('yue', 'cantonese'):
+        if re.search(r'\byesterday\b', src, re.IGNORECASE):
+            if '昨天' in tgt and '噚日' not in tgt and '琴日' not in tgt:
+                return {
+                    "verdict": "catastrophic", "failure_type": "wrong_language",
+                    "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 3, "safety": 3,
+                    "notes": (
+                        "Cantonese target output uses Mandarin temporal word 昨天 ('yesterday') "
+                        "instead of Cantonese 噚日/琴日 — output is Mandarin vocabulary, "
+                        "not colloquial Cantonese; "
+                        "(cantonese_colloquial_lexicon_traps, check #98)"
+                    ),
+                }
+
+    # check #99: Swedish-Nordic language discrimination — output contains "ikke"
+    #     (Norwegian Bokmål / Danish negation) without any "inte"/"icke" (Swedish
+    #     negation). "Ikke" is used in both Norwegian and Danish but never in Swedish,
+    #     where the standard negation is "inte". An output with "ikke" and no "inte"
+    #     is Norwegian or Danish, not Swedish.
+    #     Guards: (a) Swedish target; (b) output has word "ikke"; (c) no "inte"/"icke".
+    if target_lang.lower() in ('sv', 'swedish'):
+        if re.search(r'\bikke\b', tgt, re.IGNORECASE):
+            has_swedish_neg_99 = bool(re.search(r'\b(?:inte|icke)\b', tgt, re.IGNORECASE))
+            if not has_swedish_neg_99:
+                return {
+                    "verdict": "catastrophic", "failure_type": "wrong_language",
+                    "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 3, "safety": 2,
+                    "notes": (
+                        "Swedish target output uses 'ikke' (Norwegian Bokmål/Danish negation) "
+                        "without any 'inte'/'icke' (Swedish negation) — output is "
+                        "Norwegian or Danish, not Swedish; "
+                        "(swedish_nordic_language_discrimination_traps, check #99)"
+                    ),
+                }
+
+    # check #100: Kannada English negation passthrough — source has present/past negation
+    #     (does not/did not/has not etc., distinct from prohibitive 'must not'/'do not'
+    #     handled by check #38) and the Kannada output contains the standalone English
+    #     word "not" among Kannada characters. Kannada encodes negation morphologically
+    #     (ುವುದಿಲ್ಲ/ಲಿಲ್ಲ/ಇಲ್ಲ) — a standalone "not" in Latin script signals code-mixing.
+    #     Guards: (a) Kannada target; (b) source has present/past negation;
+    #     (c) ≥5 Kannada chars in output (partial Kannada, not caught by check #32);
+    #     (d) output contains standalone "not".
+    if target_lang.lower() in ('kn', 'kannada'):
+        if re.search(
+            r'\b(?:does\s+not|did\s+not|has\s+not|have\s+not|'
+            r'is\s+not|are\s+not|was\s+not|were\s+not|'
+            r'not\s+effective|not\s+cure|not\s+heal)\b',
+            src, re.IGNORECASE,
+        ):
+            kn_chars_100 = sum(1 for c in tgt if 0x0C80 <= ord(c) <= 0x0CFF)
+            if kn_chars_100 >= 5 and re.search(r'\bnot\b', tgt, re.IGNORECASE):
+                return {
+                    "verdict": "catastrophic", "failure_type": "wrong_language",
+                    "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 2, "safety": 2,
+                    "notes": (
+                        "Kannada translation contains standalone English 'not' in a "
+                        "present/past negative context — Kannada encodes negation "
+                        "morphologically (ುವುದಿಲ್ಲ/ಲಿಲ್ಲ/ಇಲ್ಲ) and needs no separate 'not'; "
+                        "its presence is an English code-mixing failure; "
+                        "(kannada_negative_verb_morphology_traps, check #100)"
+                    ),
+                }
+
+    # Check #101 — kannada_romanization_passthrough_traps
+    #     Small models output Kannada content in Roman/Latin script (transliteration)
+    #     instead of Kannada script. Detectable: en-kn target, source has
+    #     prohibitive/dose/imperative content, output is substantial (>15 chars)
+    #     but has very few Kannada script characters (<8).
+    #     Guards: (a) Kannada target; (b) source has dose/prohibitive/emergency content;
+    #     (c) output length > 15 chars; (d) Kannada script chars < 8.
+    #     Note: check #32 fires first when Kannada chars == 0; this catches 1-7 chars
+    #     (partial romanization with a few Kannada function words).
+    if target_lang.lower() in ('kn', 'kannada'):
+        kn_chars_101 = sum(1 for c in tgt if 0x0C80 <= ord(c) <= 0x0CFF)
+        if len(tgt) > 15 and kn_chars_101 < 8:
+            if re.search(
+                r'\b(?:do\s+not|must\s+not|never|take|dose|mg\b|tablet|inject|'
+                r'administer|stop|continue|daily|morning|evening|apply|call|'
+                r'avoid|exceed|children|patient|allergic|emergency)\b',
+                src, re.IGNORECASE,
+            ):
+                return {
+                    "verdict": "catastrophic", "failure_type": "wrong_language",
+                    "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 2, "safety": 1,
+                    "notes": (
+                        "Kannada target output has fewer than 8 Kannada script characters "
+                        "for a substantial source with prohibitive/dosing/imperative content — "
+                        "output is Roman/Latin transliteration or wrong-script substitution "
+                        "instead of proper Kannada script (ಕ-ಹ range U+0C80-U+0CFF); "
+                        "(kannada_romanization_passthrough_traps, check #101)"
+                    ),
+                }
+
+    # Check #102 — kannada_compound_noun_traps
+    #     Source mentions "blood pressure" but Kannada output lacks ರಕ್ತ (blood).
+    #     ರಕ್ತದೊತ್ತಡ = ರಕ್ತ + ಒತ್ತಡ: if ರಕ್ತ is absent, the compound noun is absent.
+    #     Also checks "diabetes" → ಮಧುಮೇಹ (must contain ಮಧು or ಮೇಹ).
+    #     Guards: (a) Kannada target; (b) source contains the trigger term;
+    #     (c) output is substantial (>10 chars); (d) key Kannada component absent.
+    if target_lang.lower() in ('kn', 'kannada') and len(tgt) > 10:
+        if re.search(r'\bblood\s+pressure\b', src, re.IGNORECASE):
+            if 'ರಕ್ತ' not in tgt:
+                return {
+                    "verdict": "catastrophic", "failure_type": "wrong_language",
+                    "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 2, "safety": 2,
+                    "notes": (
+                        "Kannada translation of 'blood pressure' lacks the Kannada component "
+                        "ರಕ್ತ (blood) — the compound ರಕ್ತದೊತ್ತಡ is absent; likely English "
+                        "passthrough ('blood pressure') or wrong compound substitution; "
+                        "(kannada_compound_noun_traps, check #102)"
+                    ),
+                }
+        if re.search(r'\bdiabetes\b', src, re.IGNORECASE):
+            if 'ಮಧು' not in tgt and 'ಮೇಹ' not in tgt:
+                return {
+                    "verdict": "catastrophic", "failure_type": "wrong_language",
+                    "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 2, "safety": 2,
+                    "notes": (
+                        "Kannada translation of 'diabetes' lacks both ಮಧು and ಮೇಹ — "
+                        "the compound ಮಧುಮೇಹ is absent; likely English passthrough or "
+                        "wrong term substitution; "
+                        "(kannada_compound_noun_traps, check #102)"
+                    ),
+                }
+
+    # Check #103 — kannada_telugu_script_confusion_traps
+    #     en-kn: if Telugu char count (U+0C00-U+0C7F) exceeds Kannada char count
+    #     (U+0C80-U+0CFF) and there are at least 5 Telugu chars, the model has
+    #     defaulted to Telugu output instead of Kannada.
+    #     Guards: (a) Kannada target; (b) output >10 chars; (c) telugu >= 5;
+    #     (d) telugu > kannada.
+    if target_lang.lower() in ('kn', 'kannada') and len(tgt) > 10:
+        _telugu_chars = sum(1 for c in tgt if '\u0C00' <= c <= '\u0C7F')
+        _kannada_chars = sum(1 for c in tgt if '\u0C80' <= c <= '\u0CFF')
+        if _telugu_chars >= 5 and _telugu_chars > _kannada_chars:
+            return {
+                "verdict": "catastrophic", "failure_type": "wrong_language",
+                "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 2, "safety": 1,
+                "notes": (
+                    f"Kannada target output has more Telugu script characters "
+                    f"(U+0C00-U+0C7F, count={_telugu_chars}) than Kannada script "
+                    f"characters (U+0C80-U+0CFF, count={_kannada_chars}) — model has "
+                    "defaulted to Telugu rather than Kannada; both scripts are adjacent "
+                    "Dravidian blocks in Unicode and small models with disproportionate "
+                    "Telugu training data systematically produce Telugu output for Kannada "
+                    "targets; dominant failure mode in phase-6 en-kn run (76.1% CAT); "
+                    "(kannada_telugu_script_confusion_traps, check #103)"
+                ),
+            }
+
+    # Check #104 — cantonese_concessive_prohibition_traps
+    #     en-yue: source has concessive clause ("even though"/"although") AND a prohibition
+    #     ("must not"/"cannot"/"prohibited") but Cantonese output lacks BOTH a concessive
+    #     marker (雖然/就算/即使/縱使) AND a Cantonese prohibition (唔可以/禁止/禁用/唔得/嚴禁).
+    #     Directly observed failure: 'Even though the drug is approved, it must not be given
+    #     to patients under 18' → '仲唔要講，要睇病人嘅年齡上限' (entire conditional frame lost).
+    #     Guards: (a) Cantonese target; (b) output >15 chars; (c) both triggers in source;
+    #     (d) both concessive marker and prohibition marker absent from output.
+    if target_lang.lower() in ('yue', 'cantonese') and len(tgt) > 10:
+        if re.search(r'\b(even though|although|even if)\b', src, re.IGNORECASE):
+            if re.search(
+                r'\b(must not|must never|cannot|shall not|prohibited|forbidden)\b',
+                src, re.IGNORECASE,
+            ):
+                _yue_concessives = ['雖然', '就算', '即使', '縱使', '哪怕']
+                _yue_prohibitions = ['唔可以', '禁止', '禁用', '唔得', '嚴禁']
+                _has_conc = any(c in tgt for c in _yue_concessives)
+                _has_proh = any(p in tgt for p in _yue_prohibitions)
+                if not _has_conc and not _has_proh:
+                    return {
+                        "verdict": "catastrophic", "failure_type": "semantic_substitution",
+                        "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 2, "safety": 1,
+                        "notes": (
+                            "Cantonese translation of source containing concessive clause "
+                            "('even though/although') plus prohibition ('must not/cannot') "
+                            "lacks both a Cantonese concessive marker (雖然/就算/即使/縱使) "
+                            "and a Cantonese prohibition (唔可以/禁止/禁用/唔得/嚴禁) — "
+                            "the conditional exception frame has been entirely dropped, "
+                            "converting a conditional restriction to an unqualified statement; "
+                            "directly observed in phase-6 en-yue run: 'Even though the drug "
+                            "is approved, it must not be given to patients under 18' → output "
+                            "loses approval context and prohibition entirely; "
+                            "(cantonese_concessive_prohibition_traps, check #104)"
+                        ),
+                    }
+
+    # Check #105 — swedish_profession_near_miss_traps
+    #     en-sv: source has "engineer" but Swedish output contains "meningen" (the sentence/
+    #     meaning) — the exact profession-noun near-miss substitution observed in phase-6
+    #     en-sv run where 'the engineer recommended full evacuation' →
+    #     'meningen rekommenderade fullständig evakuering'.
+    #     Guards: (a) Swedish target; (b) source has 'engineer'; (c) 'meningen' in output.
+    if target_lang.lower() in ('sv', 'swedish') and len(tgt) > 10:
+        if re.search(r'\bengineer\b', src, re.IGNORECASE):
+            if 'meningen' in tgt.lower():
+                return {
+                    "verdict": "catastrophic", "failure_type": "semantic_substitution",
+                    "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 2, "safety": 2,
+                    "notes": (
+                        "Swedish translation of 'engineer' produced 'meningen' (the sentence/"
+                        "meaning) instead of 'ingenjören' (the engineer) — direct profession-"
+                        "noun near-miss substitution observed in phase-6 en-sv run; "
+                        "'the engineer recommended full evacuation' → 'meningen rekommenderade "
+                        "fullständig evakuering'; the safety-critical professional agent is "
+                        "replaced by an inanimate noun, destroying accountability; "
+                        "(swedish_profession_near_miss_traps, check #105)"
+                    ),
+                }
+
+    # Check #106 — swedish_scandinavian_interference_traps
+    #     en-sv: if target is Swedish but output contains Norwegian Bokmål medical tokens
+    #     (ikke = not, sykehus = hospital, sykepleier = nurse, lege = doctor as standalone
+    #     word), the model has produced Norwegian instead of Swedish.
+    #     Guards: (a) Swedish target; (b) output >10 chars;
+    #     (c) Norwegian-specific token present (word-boundary checked for 'lege').
+    if target_lang.lower() in ('sv', 'swedish') and len(tgt) > 10:
+        tgt_lower = tgt.lower()
+        _norw_simple = ['ikke', 'sykehus', 'sykepleier']
+        _found_norw = next((tok for tok in _norw_simple if tok in tgt_lower), None)
+        if _found_norw is None and re.search(r'\blege\b', tgt_lower):
+            _found_norw = 'lege'
+        if _found_norw is not None:
+            return {
+                "verdict": "catastrophic", "failure_type": "wrong_language",
+                "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 2, "safety": 1,
+                "notes": (
+                    f"Swedish target output contains Norwegian Bokmål token '{_found_norw}' — "
+                    "model has produced Norwegian instead of Swedish: "
+                    "'ikke' (Norw: not) vs Swedish 'inte', "
+                    "'sykehus' (Norw: hospital) vs Swedish 'sjukhus', "
+                    "'sykepleier' (Norw: nurse) vs Swedish 'sjuksköterska', "
+                    "'lege' (Norw: doctor) vs Swedish 'läkare'; "
+                    "a Swedish patient unfamiliar with Norwegian may not understand the "
+                    "medical instruction, and word-order differences (Norwegian 'ikke kan' "
+                    "vs Swedish 'kan inte') change the placement of negation in safety "
+                    "instructions; phase-6 en-sv 25.5% CAT rate suggests systematic "
+                    "Scandinavian language confusion in small models; "
+                    "(swedish_scandinavian_interference_traps, check #106)"
+                ),
+            }
+
+    # Check #107 — hindi_organ_adjective_confusion_traps
+    #     en-hi: source has a liver-specific organ adjective ('hepatic') but Hindi output
+    #     contains 'हृदय' (heart/cardiac) → the wrong organ system entirely.
+    #     'hepatic' → 'हृदय' was directly observed in phase-6 en-hi catastrophic example.
+    #     Also catches pulmonary → वृक्क/गुर्दे (kidney) confusion.
+    #     Guards: (a) Hindi target; (b) output >15 chars; (c) source has organ adjective;
+    #     (d) output contains the WRONG organ word.
+    if target_lang.lower() in ('hi', 'hindi') and len(tgt) > 15:
+        src_lower = src.lower()
+        _hepatic_in_src = 'hepatic' in src_lower
+        _pulmonary_in_src = 'pulmonary' in src_lower
+        _renal_in_src = bool(re.search(r'\brenal\b', src_lower))
+        if _hepatic_in_src and 'हृदय' in tgt:
+            return {
+                "verdict": "catastrophic", "failure_type": "hallucination",
+                "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 2, "safety": 1,
+                "notes": (
+                    "Source says 'hepatic' (liver-related) but Hindi output contains 'हृदय' "
+                    "(heart/cardiac) — the wrong organ system entirely; "
+                    "hepatic impairment/failure/enzymes involve the liver (यकृत/जिगर), "
+                    "not the heart; this organ-adjective substitution is clinically dangerous "
+                    "and was directly observed in phase-6 en-hi catastrophic run; "
+                    "(hindi_organ_adjective_confusion_traps, check #107)"
+                ),
+            }
+        if _pulmonary_in_src and re.search(r'वृक्क|गुर्दे', tgt):
+            return {
+                "verdict": "catastrophic", "failure_type": "hallucination",
+                "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 2, "safety": 1,
+                "notes": (
+                    "Source says 'pulmonary' (lung-related) but Hindi output contains 'वृक्क' "
+                    "or 'गुर्दे' (kidney) — the wrong organ system; "
+                    "pulmonary embolism/oedema/function involve the lungs (फेफड़े/फुफ्फुस), "
+                    "not the kidneys; clinically dangerous organ-system confusion; "
+                    "(hindi_organ_adjective_confusion_traps, check #107)"
+                ),
+            }
+
+    # Check #108 — cantonese_drug_identity_traps
+    #     en-yue: source mentions a specific drug but Cantonese output contains a different
+    #     drug from the same pharmacological class — directly observed in phase-6 en-yue run:
+    #     'morphine sulfate, not hydromorphone' → output had 哌替啶 (pethidine) and 氢可待因
+    #     (hydrocodone), both wrong.
+    #     Guards: (a) Cantonese/Yue target; (b) output >10 chars; (c) source has drug name;
+    #     (d) output contains wrong drug name token.
+    if target_lang.lower() in ('yue', 'cantonese') and len(tgt) > 10:
+        src_lower = src.lower()
+        # morphine → 哌替啶 (pethidine) substitution — directly observed
+        if 'morphine' in src_lower and '哌替啶' in tgt:
+            return {
+                "verdict": "catastrophic", "failure_type": "hallucination",
+                "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 2, "safety": 1,
+                "notes": (
+                    "Source says 'morphine' (嗎啡) but Cantonese output contains '哌替啶' "
+                    "(pethidine/meperidine) — a different opioid analgesic; "
+                    "this drug-identity substitution was directly observed in phase-6 en-yue "
+                    "catastrophic run; pethidine and morphine have different dosing, "
+                    "indications, and contraindications (e.g. pethidine is avoided in renal "
+                    "failure due to norpethidine accumulation); "
+                    "(cantonese_drug_identity_traps, check #108)"
+                ),
+            }
+        # hydromorphone → 可待因/codeine-class substitution
+        if 'hydromorphone' in src_lower and re.search(r'可待因|氢可', tgt):
+            return {
+                "verdict": "catastrophic", "failure_type": "hallucination",
+                "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 2, "safety": 1,
+                "notes": (
+                    "Source says 'hydromorphone' (氫嗎啡酮, Traditional) but Cantonese output "
+                    "contains '可待因' or '氢可' — codeine-class opioid substitution; "
+                    "hydromorphone is approximately 5-7× more potent than morphine while "
+                    "codeine is a weaker prodrug; wrong-drug identity is clinically dangerous; "
+                    "(cantonese_drug_identity_traps, check #108)"
+                ),
+            }
+
+    # Check #109 — swedish_definiteness_suffix_traps
+    #     en-sv: Swedish uses suffix-based definiteness (tabletten, patienten, dosen)
+    #     NOT prepended article (German-style "den tablett").
+    #     Two locally detectable failures:
+    #     (a) 'patientet' — wrong neuter -et suffix on common-gender noun 'patient'
+    #         (should be 'patienten'); directly observed in phase-6 en-sv catastrophic.
+    #     (b) 'den patient' — German-style prepended article (no suffix on noun).
+    #     Guards: (a) Swedish target; (b) output >10 chars.
+    if target_lang.lower() in ('sv', 'swedish') and len(tgt) > 10:
+        tgt_lower = tgt.lower()
+        if 'patientet' in tgt_lower:
+            return {
+                "verdict": "catastrophic", "failure_type": "wrong_inflection",
+                "adequacy": 2, "fluency": 1, "faithfulness": 2, "format": 2, "safety": 3,
+                "notes": (
+                    "Swedish output contains 'patientet' — wrong neuter definite suffix "
+                    "(-et) on the common-gender noun 'patient' (correct form: 'patienten'); "
+                    "directly observed in phase-6 en-sv catastrophic run; "
+                    "Swedish suffix-based definiteness requires gender-correct suffix: "
+                    "common gender → -en, neuter → -et; 'patient' is common gender; "
+                    "(swedish_definiteness_suffix_traps, check #109)"
+                ),
+            }
+        if re.search(r'\bden patient\b', tgt_lower):
+            return {
+                "verdict": "catastrophic", "failure_type": "wrong_inflection",
+                "adequacy": 2, "fluency": 1, "faithfulness": 2, "format": 2, "safety": 3,
+                "notes": (
+                    "Swedish output uses 'den patient' — German/French-style prepended "
+                    "definite article; Swedish encodes definiteness as a noun suffix "
+                    "(patienten, not 'den patient'); this is a systematic error from "
+                    "models trained on other European languages applying non-Swedish "
+                    "definiteness morphology; (swedish_definiteness_suffix_traps, check #109)"
+                ),
+            }
+
+    # Check #110 — hindi_progressive_aspect_traps
+    #     en-hi: English "is/are [verb]ing" should produce Hindi progressive रह-:
+    #     'is taking' → 'ले रहा/रही है', 'is spreading' → 'फैल रहा/रही है'.
+    #     If source has progressive English construction but Hindi output lacks the
+    #     progressive marker stem रह → the aspect was dropped and may have become
+    #     habitual (takes in general) instead of ongoing (currently taking).
+    #     Guards: (a) Hindi target; (b) output has >5 Devanagari chars;
+    #     (c) source has explicit present progressive pattern;
+    #     (d) output lacks रह (core progressive marker).
+    if target_lang.lower() in ('hi', 'hindi') and len(tgt) > 15:
+        _hi_devanagari_count = sum(1 for c in tgt if '\u0900' <= c <= '\u097F')
+        if _hi_devanagari_count >= 5:
+            _progressive_pat = re.search(
+                r'\b(?:is|are|am)\s+(?:\w+ing)\b', src, re.IGNORECASE
+            )
+            if _progressive_pat and 'रह' not in tgt:
+                return {
+                    "verdict": "catastrophic", "failure_type": "omission",
+                    "adequacy": 1, "fluency": 3, "faithfulness": 1, "format": 3, "safety": 2,
+                    "notes": (
+                        "English source has a present progressive construction "
+                        f"('{_progressive_pat.group()}') but Hindi output lacks the "
+                        "progressive aspect marker 'रह' (रहा/रही/रहे); "
+                        "dropping the progressive marker converts an ongoing event into "
+                        "a habitual one — clinically significant distinction e.g. "
+                        "'is taking' (ले रहा/रही है, current) vs 'takes' (लेता/लेती है, habitual); "
+                        "(hindi_progressive_aspect_traps, check #110)"
+                    ),
+                }
+
+    # Check #111 — cantonese_ama_question_traps
+    #     en-yue: Cantonese yes/no questions use A-not-A forms (係唔係, 有冇) or
+    #     completive 咗未, NOT Mandarin-style 吗 final particle.
+    #     If source is a yes/no question AND output contains '吗' (Simplified Chinese,
+    #     never used in Cantonese) → Mandarin-style output.
+    #     Guards: (a) Cantonese/Yue target; (b) source ends with '?';
+    #     (c) source starts with interrogative word; (d) output contains 吗 (Simplified).
+    if target_lang.lower() in ('yue', 'cantonese') and len(tgt) > 5:
+        _is_yn_question = bool(re.match(
+            r'(?:Is|Are|Does|Do|Has|Have|Can|Could|Will|Would|Should|Was|Were)\b',
+            src.strip(), re.IGNORECASE
+        )) and src.strip().endswith('?')
+        if _is_yn_question and '\u5417' in tgt:  # 吗 U+5417, Simplified only
+            return {
+                "verdict": "catastrophic", "failure_type": "wrong_language",
+                "adequacy": 2, "fluency": 2, "faithfulness": 2, "format": 2, "safety": 2,
+                "notes": (
+                    "Source is a yes/no question and Cantonese output contains '吗' "
+                    "(Simplified Chinese final question particle, U+5417) — "
+                    "Cantonese yes/no questions use A-not-A forms (係唔係, 有冇, 做唔做) "
+                    "or completive-negative 咗未, not the Mandarin-style 吗 particle; "
+                    "presence of Simplified '吗' (vs Traditional '嗎') indicates the "
+                    "output is Mandarin-structured, not Cantonese; "
+                    "(cantonese_ama_question_traps, check #111)"
+                ),
+            }
+
+    # Check #112 — cantonese_gujarati_cyrillic_contamination_traps (Gujarati)
+    #     en-yue: Gujarati script (U+0A80-U+0AFF) is entirely foreign to Cantonese.
+    #     Directly observed: 'oral use only' → full Gujarati output 'આ પ્રક્રિયા ફક્ત...'
+    #     Guards: (a) Cantonese/Yue target; (b) ≥3 Gujarati chars in output.
+    if target_lang.lower() in ('yue', 'cantonese') and len(tgt) > 5:
+        _gujarati_count = sum(1 for c in tgt if '\u0A80' <= c <= '\u0AFF')
+        if _gujarati_count >= 3:
+            return {
+                "verdict": "catastrophic", "failure_type": "wrong_language",
+                "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 1, "safety": 2,
+                "notes": (
+                    f"Cantonese output contains {_gujarati_count} Gujarati script characters "
+                    "(U+0A80-U+0AFF) — Gujarati is entirely foreign to Cantonese/Traditional "
+                    "Chinese; model fell back to Gujarati medical corpus for this term; "
+                    "(cantonese_gujarati_cyrillic_contamination_traps, check #112)"
+                ),
+            }
+
+    # Check #113 — cantonese_gujarati_cyrillic_contamination_traps (Cyrillic)
+    #     en-yue: Cyrillic script (U+0400-U+04FF) is foreign to Cantonese.
+    #     Directly observed: 'morphine sulfate' → '患者 recibió 5mg морфи素硫酸' (Cyrillic морфи)
+    #     Guards: (a) Cantonese/Yue target; (b) ≥3 Cyrillic chars in output.
+    if target_lang.lower() in ('yue', 'cantonese') and len(tgt) > 5:
+        _cyrillic_count = sum(1 for c in tgt if '\u0400' <= c <= '\u04FF')
+        if _cyrillic_count >= 3:
+            return {
+                "verdict": "catastrophic", "failure_type": "wrong_language",
+                "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 1, "safety": 2,
+                "notes": (
+                    f"Cantonese output contains {_cyrillic_count} Cyrillic script characters "
+                    "(U+0400-U+04FF) — Cyrillic is foreign to Cantonese/Traditional Chinese; "
+                    "model fell back to Russian/Slavic medical terminology for this term; "
+                    "(cantonese_gujarati_cyrillic_contamination_traps, check #113)"
+                ),
+            }
+
+    # Check #114 — swedish_bengali_script_contamination_traps
+    #     en-sv: Bengali/Bangla script (U+0980-U+09FF) is foreign to Swedish.
+    #     Directly observed: 'whereas' clause → 'Derঅন্যদিকে påstås att...' (Bengali অন্যদিকে)
+    #     Guards: (a) Swedish target; (b) ≥2 Bengali chars in output.
+    if target_lang.lower() in ('sv', 'swedish') and len(tgt) > 5:
+        _bengali_count = sum(1 for c in tgt if '\u0980' <= c <= '\u09FF')
+        if _bengali_count >= 2:
+            return {
+                "verdict": "catastrophic", "failure_type": "wrong_language",
+                "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 1, "safety": 2,
+                "notes": (
+                    f"Swedish output contains {_bengali_count} Bengali/Bangla script characters "
+                    "(U+0980-U+09FF) — Bengali is entirely foreign to Swedish; "
+                    "model inserted Bengali discourse marker (অন্যদিকে = 'on the other hand') "
+                    "or Bengali medical term into what should be Swedish output; "
+                    "(swedish_bengali_script_contamination_traps, check #114)"
+                ),
+            }
+
+    # Check #115 — hindi_two_clause_negation_scope_traps
+    #     en-hi: Source has "MUST be [verb]" (positive obligation in clause 1) + "—" or ";"
+    #     separator + "never" (prohibition in clause 2). Failure: model collapses both clauses
+    #     into a single Hindi sentence with NO separator AND uses कभी+नहीं, migrating the
+    #     "never" negation to cancel the MUST obligation.
+    #     Directly observed: "MUST be diluted... — never give undiluted" →
+    #         "कभी भी पतला नहीं किया जाना चाहिए" (no separator; MUST DILUTE → should NEVER DILUTE)
+    #     Guards: (a) Hindi target; (b) source has "MUST be [verb]" + "—"/";" + "never";
+    #             (c) Hindi output has NO clause separator; (d) output has both कभी and नहीं.
+    if target_lang.lower() in ('hi', 'hindi') and len(tgt) > 15:
+        _must_passive_match = re.search(r'\bMUST\s+be\s+\w+', src)
+        _never_after_sep = re.search(r'[—;].*\bnever\b', src, re.IGNORECASE)
+        if _must_passive_match and _never_after_sep:
+            _hi_devanagari_count_115 = sum(1 for c in tgt if '\u0900' <= c <= '\u097F')
+            if _hi_devanagari_count_115 >= 5:
+                _has_tgt_sep = bool(re.search(r'[।—;]', tgt))
+                if not _has_tgt_sep and 'कभी' in tgt and 'नहीं' in tgt:
+                    return {
+                        "verdict": "catastrophic", "failure_type": "semantic_substitution",
+                        "adequacy": 1, "fluency": 3, "faithfulness": 1, "format": 3, "safety": 1,
+                        "notes": (
+                            f"Source has 'MUST be [verb]' positive obligation ('{_must_passive_match.group()}') "
+                            "separated from a 'never' prohibition by '—' or ';'; "
+                            "Hindi output has NO clause separator (collapsed to single sentence) "
+                            "and contains 'कभी' + 'नहीं', indicating negation migrated from "
+                            "the prohibition clause to negate the obligation clause — "
+                            "MUST DO becomes NEVER DO, a lethal semantic inversion; "
+                            "(hindi_two_clause_negation_scope_traps, check #115)"
+                        ),
+                    }
+
+    # Check #116 — hindi_absolutive_clause_traps
+    #     en-hi: Source begins with "Having [word]" (absolutive sequential construction).
+    #     Failure: Hindi output lacks any absolutive suffix (कर/करके/लेकर/देकर/पीकर/खाकर/धोकर/लगाकर)
+    #     in the first 60% — indicates sequential dependency lost, two actions independent.
+    #     Directly observed pattern: seeds starting with "Having [VBN]" collapse to two
+    #     independent imperatives, dropping the critical temporal ordering.
+    if target_lang.lower() in ('hi', 'hindi') and len(tgt) > 15:
+        if re.match(r'^Having\s+\w+', src, re.IGNORECASE):
+            _hi_deva_116 = sum(1 for c in tgt if '\u0900' <= c <= '\u097F')
+            if _hi_deva_116 >= 5:
+                _absolutive_forms = (
+                    'कर ', 'करके', 'लेकर', 'देकर', 'पीकर', 'खाकर',
+                    'धोकर', 'लगाकर', 'हटाकर', 'जाँचकर', 'मिलाकर',
+                    'रखकर', 'खींचकर', 'साफ कर', 'प्राप्त कर',
+                )
+                _tgt_first_60 = tgt[:max(1, int(len(tgt) * 0.60))]
+                if not any(f in _tgt_first_60 for f in _absolutive_forms):
+                    return {
+                        "verdict": "catastrophic", "failure_type": "semantic_substitution",
+                        "adequacy": 1, "fluency": 3, "faithfulness": 1, "format": 3, "safety": 2,
+                        "notes": (
+                            "Source begins with absolutive 'Having [VBN]' construction; "
+                            "Hindi output lacks absolutive suffix (कर/करके/लेकर/देकर etc.) "
+                            "in first 60% of output — sequential dependency 'do X first, then Y' "
+                            "collapsed to two independent clauses, losing obligatory ordering; "
+                            "(hindi_absolutive_clause_traps, check #116)"
+                        ),
+                    }
+
+    # Check #117 — cantonese_a_not_a_question_traps
+    #     en-yue: Source ends with '?'; Cantonese output contains 嗎 (U+5417, Mandarin question
+    #     particle) AND lacks all A-not-A markers (唔係/冇/唔要/係咪/係唔係/有冇/要唔要).
+    #     Detects: Mandarin 嗎-question substituting for obligatory Cantonese A-not-A polar form.
+    if target_lang.lower() in ('yue', 'cantonese') and len(tgt) > 3:
+        if src.rstrip().endswith('?') and '\u5417' in tgt:  # 嗎
+            _a_not_a_markers = ('唔係', '冇', '唔要', '係咪', '係唔係', '有冇', '要唔要')
+            if not any(m in tgt for m in _a_not_a_markers):
+                return {
+                    "verdict": "catastrophic", "failure_type": "wrong_language",
+                    "adequacy": 2, "fluency": 3, "faithfulness": 1, "format": 3, "safety": 2,
+                    "notes": (
+                        "Source is a polar yes/no question; Cantonese output contains "
+                        "Mandarin question particle 嗎 with no Cantonese A-not-A form "
+                        "(唔係/冇/唔要/係咪) — Mandarin 嗎-question replaces "
+                        "obligatory Cantonese A-not-A polar question formation; "
+                        "(cantonese_a_not_a_question_traps, check #117)"
+                    ),
+                }
+
+    # Check #118 — kannada_dative_subject_traps
+    #     en-kn: Source has "the [NP] has/feels [symptom]" experiencer predicate pattern.
+    #     Failure: Kannada output lacks dative suffix (ಗೆ/ಕ್ಕೆ/ಕೆ) in first 40% of output,
+    #     indicating nominative subject substitution — ungrammatical in Kannada for
+    #     psychological/physiological experiencer predicates.
+    if target_lang.lower() in ('kn', 'kannada') and len(tgt) > 10:
+        _dative_subj_match = re.search(
+            r'\bthe\s+(?:patient|child|nurse|surgeon|staff\s+member|ward\s+manager|elderly\s+patient)\s+'
+            r'(?:has|feels|feel)\b',
+            src, re.IGNORECASE,
+        )
+        if _dative_subj_match:
+            _kn_script_118 = sum(1 for c in tgt if '\u0C80' <= c <= '\u0CFF')
+            if _kn_script_118 >= 5:
+                _tgt_first_40 = tgt[:max(1, int(len(tgt) * 0.40))]
+                _dative_markers = ('ಗೆ', 'ಕ್ಕೆ', 'ಕೆ')
+                if not any(d in _tgt_first_40 for d in _dative_markers):
+                    return {
+                        "verdict": "catastrophic", "failure_type": "semantic_substitution",
+                        "adequacy": 1, "fluency": 2, "faithfulness": 1, "format": 3, "safety": 2,
+                        "notes": (
+                            f"Source has experiencer predicate "
+                            f"'{_dative_subj_match.group()}'; "
+                            "Kannada output lacks dative case marker (ಗೆ/ಕ್ಕೆ/ಕೆ) in "
+                            "first 40% — nominative subject substitution for an "
+                            "obligatory dative experiencer construction; "
+                            "(kannada_dative_subject_traps, check #118)"
+                        ),
+                    }
+
+    # Check #119 — swedish_number_localization_traps
+    #     en-sv: source has English thousands-comma number (e.g. "1,500") AND
+    #     the Swedish output retains the same "X,XXX" pattern unchanged.
+    #     Catastrophic because Swedish uses comma as the DECIMAL separator (not thousands):
+    #     "1,500 mg" in Swedish = 1.5 mg (1000× underdose vs intended 1500 mg).
+    #     Guard: require target language to be Swedish and ≥5 chars to avoid empty-output
+    #     double-fire with check #1. Only fires when the exact English format reappears.
+    if target_lang.lower() in ('sv', 'swedish') and len(tgt) > 5:
+        _sv_thousands = re.findall(r'\b(\d{1,3}),(\d{3})\b', src)
+        for _sv_int, _sv_frac in _sv_thousands:
+            _sv_en_fmt = f"{_sv_int},{_sv_frac}"
+            if _sv_en_fmt in tgt:
+                return {
+                    "verdict": "catastrophic", "failure_type": "measurement_error",
+                    "adequacy": 1, "fluency": 3, "faithfulness": 1, "format": 1, "safety": 1,
+                    "notes": (
+                        f"Source has English thousands-comma number '{_sv_en_fmt}' "
+                        f"(= {_sv_int}{_sv_frac} in standard form); "
+                        "Swedish output retains same format unchanged — "
+                        "Swedish comma is the DECIMAL separator, so a Swedish reader "
+                        f"reads '{_sv_en_fmt}' as {_sv_int}.{_sv_frac} "
+                        "(potential 1000× magnitude error in clinical context); "
+                        "(swedish_number_localization_traps, check #119)"
+                    ),
+                }
+
+    # Check #120 — cantonese_comparison_construction_traps
+    #     en-yue: source has a dosing comparison ('more than'/'no more than'/'less than'
+    #     before a digit); Cantonese output has ≥8 Chinese chars (real translation attempt);
+    #     output contains Mandarin 比-comparative (比+X+多/少/高/低) but lacks Cantonese
+    #     多過 or 少過 → Mandarin comparison structure used for a Cantonese target.
+    #     Guard: require ≥8 Chinese chars so we don't fire on near-empty or Latin outputs.
+    if target_lang.lower() in ('yue', 'cantonese') and len(tgt) > 5:
+        _yue_cmp_src = re.search(
+            r'\b(?:no\s+more\s+than|more\s+than|no\s+less\s+than|less\s+than)\s+\d',
+            src, re.IGNORECASE,
+        )
+        if _yue_cmp_src:
+            _yue_han = sum(1 for c in tgt if '\u4e00' <= c <= '\u9fff')
+            if _yue_han >= 8:
+                _yue_has_canton_cmp = any(m in tgt for m in ('多過', '少過'))
+                _yue_has_mandarin_cmp = (
+                    '比' in tgt
+                    and re.search(r'比.{1,8}(?:多|少|高|低)', tgt) is not None
+                )
+                if _yue_has_mandarin_cmp and not _yue_has_canton_cmp:
+                    return {
+                        "verdict": "catastrophic", "failure_type": "wrong_language",
+                        "adequacy": 2, "fluency": 3, "faithfulness": 2, "format": 3, "safety": 2,
+                        "notes": (
+                            "Source has dosing comparison "
+                            f"('{_yue_cmp_src.group().strip()}'); "
+                            "Cantonese output uses Mandarin 比-comparison construction "
+                            "instead of Cantonese 多過/少過 form — "
+                            "indicates Mandarin-register output for Cantonese target; "
+                            "(cantonese_comparison_construction_traps, check #120)"
+                        ),
+                    }
+
+    # Check #121 — hindi_should_recommendation_traps
+    #     en-hi: Source has "should [verb]" recommendation (not "should not"/"shouldn't"
+    #     which are prohibitions already caught by check #34).
+    #     Hindi encodes advisory "should" via चाहिए at clause end.
+    #     Failure: model uses imperative (करें/लें) or habitual (करता है/लेता है) — no चाहिए.
+    #     Guards: (a) Hindi target; (b) source has "should [verb]" but NOT "should not"/
+    #     "shouldn't" (those are prohibitions); (c) ≥5 Devanagari chars in output
+    #     (confirms Hindi attempt, not wrong-language case caught by check #9);
+    #     (d) output lacks चाहिए.
+    if target_lang.lower() in ('hi', 'hindi'):
+        if (re.search(r'\bshould\s+\w', src, re.IGNORECASE)
+                and not re.search(r'\bshould\s+not\b|\bshouldn\'t\b', src, re.IGNORECASE)):
+            _dev_count_121 = sum(1 for c in tgt if '\u0900' <= c <= '\u097F')
+            if _dev_count_121 >= 5 and 'चाहिए' not in tgt:
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "semantic_substitution",
+                    "adequacy": 1, "fluency": 3, "faithfulness": 1,
+                    "format": 3, "safety": 2,
+                    "notes": (
+                        "Hindi recommendation modal erased: source has 'should [verb]' "
+                        "advisory recommendation but Hindi output contains no चाहिए — "
+                        "the obligatory recommendation modal that distinguishes advisory "
+                        "'should' from an imperative command or factual description; "
+                        "model likely used imperative (करें/लें) or habitual (करता है) "
+                        "instead of proper चाहिए construction; "
+                        "(hindi_should_recommendation_traps, check #121)"
+                    ),
+                }
+
+    # Check #122 — cantonese_legal_term_traps
+    #     en-yue: Source has "plaintiff" (civil claimant). Cantonese HK legal vocabulary:
+    #     plaintiff = 原告人 (原告 alone is incomplete Mandarin form; 人 is required in HK).
+    #     Failure: plaintiff omitted entirely OR defendant role assigned to plaintiff.
+    #     Directly observed in phase-6 en-yue run: "plaintiff claims damages... defendant
+    #     disputes liability" → only defendant mentioned, claiming damages — plaintiff
+    #     dropped entirely.
+    #     Guards: (a) Cantonese target; (b) 'plaintiff' in source; (c) ≥10 CJK chars in
+    #     output (genuine translation attempt, not wrong-language caught earlier);
+    #     (d) output lacks 原告 (Traditional and Simplified share these codepoints).
+    if target_lang.lower() in ('yue', 'cantonese'):
+        if re.search(r'\bplaintiff\b', src, re.IGNORECASE):
+            _cjk_count_122 = sum(
+                1 for c in tgt
+                if '\u4E00' <= c <= '\u9FFF' or '\u3400' <= c <= '\u4DBF'
+            )
+            if _cjk_count_122 >= 10 and '原告' not in tgt:
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "hallucination",
+                    "adequacy": 0, "fluency": 2, "faithfulness": 0,
+                    "format": 3, "safety": 3,
+                    "notes": (
+                        "Cantonese legal plaintiff erasure: source has 'plaintiff' (civil "
+                        "claimant) but Cantonese output lacks 原告/原告人 — plaintiff "
+                        "entirely omitted or role reassigned to the defendant; "
+                        "directly observed in phase-6 en-yue run where "
+                        "'the plaintiff claims damages' → defendant-only output claiming damages; "
+                        "HK legal Cantonese: plaintiff = 原告人 (原告 alone is Mandarin shortform); "
+                        "(cantonese_legal_term_traps, check #122)"
+                    ),
+                }
+
+    # Check #123 — swedish_ghs_hazard_signal_traps
+    #     en-sv: Source has a GHS (Globally Harmonized System) hazard signal phrase
+    #     ("Fatal if inhaled/swallowed/in contact with skin", "DANGER:", "WARNING:",
+    #     "Causes severe burns/eye damage").
+    #     Swedish GHS requires standardized vocabulary: DANGER→Fara, WARNING→Varning,
+    #     "Fatal if inhaled"→"Dödligt vid inandning", "Causes severe burns"→"Orsakar allvarliga..."
+    #     Failure: model uses non-GHS Swedish paraphrase or leaves English terms untranslated.
+    #     Guards: (a) Swedish target; (b) source has GHS hazard phrase; (c) output ≥5
+    #     words (genuine attempt, not empty or wrong-language); (d) output lacks core
+    #     GHS Swedish vocabulary (Dödligt / Orsakar allvarliga / Fara / Varning).
+    if target_lang.lower() in ('sv', 'swedish', 'svenska'):
+        _sv_ghs_src = re.search(
+            r'\b(?:fatal\s+if\s+(?:inhaled|swallowed|ingested)'
+            r'|fatal\s+in\s+contact\s+with'
+            r'|causes?\s+severe\s+(?:burns?|skin\s+burns?|eye\s+damage)'
+            r'|causes?\s+serious\s+eye\s+damage'
+            r'|DANGER\s*:'
+            r'|WARNING\s*:)',
+            src, re.IGNORECASE,
+        )
+        if _sv_ghs_src and len(tgt.split()) >= 5:
+            _sv_ghs_ok = bool(re.search(
+                r'[Dd]ödligt|[Ff]ara\b|[Vv]arning\b'
+                r'|[Oo]rsakar\s+allvarlig',
+                tgt,
+            ))
+            if not _sv_ghs_ok:
+                return {
+                    "verdict": "catastrophic",
+                    "failure_type": "semantic_substitution",
+                    "adequacy": 0, "fluency": 2, "faithfulness": 0,
+                    "format": 2, "safety": 0,
+                    "notes": (
+                        f"Swedish GHS hazard vocabulary absent: source has GHS signal phrase "
+                        f"('{_sv_ghs_src.group().strip()[:60]}') but Swedish output lacks "
+                        "GHS-standardized vocabulary (Dödligt/Orsakar allvarliga/Fara/Varning); "
+                        "model used non-GHS Swedish paraphrase or left English terms untranslated "
+                        "— GHS non-compliance invalidates chemical/pharmaceutical safety labelling; "
+                        "(swedish_ghs_hazard_signal_traps, check #123)"
+                    ),
+                }
+
+    return None  # ambiguous — need Claude to judge
+
+
+def detect_profanity(translation: str, source_text: str) -> list[str]:
+    """Profanity words in ``translation`` that are absent from ``source_text``."""
+    found = []
+    for word in PROFANITY_WORDS:
+        pattern = r"(?<!\w)" + re.escape(word.lower()) + r"(?!\w)"
+        if re.search(pattern, translation.lower()) and not re.search(pattern, source_text.lower()):
+            found.append(word)
+    return sorted(found)