The translation read perfectly and still crashed at runtime

# fmtcheck.py — extract format specifiers and compare them with severity
import re
from collections import Counter
 
PRINTF = re.compile(
    r"%(?:(\d+)\$)?([-+ 0#]*)(\d+|\*)?(?:\.(\d+|\*))?(?:hh|h|ll|l|q|z|t|L)?([@sdiufFeEgGxXoc%])"
)
BRACE = re.compile(r"\{([^{}\s]+)\}")   # deliberately wide: translators do translate what's inside
BROKEN_GLYPH = re.compile(r"[％＄＠]|%\s+\d+\s*\$|%\s+[@sd]")
LITERAL_PCT = re.compile(r"%%")
 
NUMERIC = set("diufFeEgGxXo")
 
def tokens(text):
    """Return a list of (positional index, conversion char). Index is None when absent."""
    out = []
    for m in PRINTF.finditer(text):
        if m.group(5) == "%":
            continue                      # %% is a literal and consumes no argument
        out.append((int(m.group(1)) if m.group(1) else None, m.group(5)))
    for m in BRACE.finditer(text):
        out.append((m.group(1), "{}"))
    return out
 
def _kind(conv):
    if conv == "{}":
        return "named"
    return "number" if conv in NUMERIC else "text"

def check(src, dst):
    findings = []
    s, d = tokens(src), tokens(dst)
 
    # Literal %% never shows up in tokens, so count it separately
    ls, ld = len(LITERAL_PCT.findall(src)), len(LITERAL_PCT.findall(dst))
    if ls != ld:
        findings.append(("crash", "literal_percent", (ls, ld)))
 
    g = BROKEN_GLYPH.search(dst)
    if g:
        findings.append(("crash", "broken_glyph", g.group(0)))
 
    if any(a is not None for a, _ in s):
        # Positional: order is free, count and type are not
        if any(a is None for a, _ in d):
            findings.append(("crash", "lost_argnum", [t for t in d if t[0] is None]))
        cs, cd = Counter(s), Counter(d)
        for tok in (cd - cs).elements():
            # Reusing an existing index is legal, so demote that case to review
            findings.append(("review" if tok in cs else "crash", "extra", tok))
        for tok in (cs - cd).elements():
            findings.append(("loss", "missing", tok))
        types_s = {a: c for a, c in s if a is not None}
        types_d = {a: c for a, c in d if a is not None}
        for a, c in types_d.items():
            if a in types_s and _kind(types_s[a]) != _kind(c):
                findings.append(("crash", "type_mismatch", (a, types_s[a], c)))
    else:
        # Non-positional: the sequence is the binding
        seq_s = [c for _, c in s]
        seq_d = [c for _, c in d]
        if len(seq_d) > len(seq_s):
            findings.append(("crash", "too_many", seq_d))
        elif len(seq_d) < len(seq_s):
            findings.append(("loss", "too_few", seq_d))
        elif seq_s != seq_d:
            findings.append(("crash", "sequence_type_shift", seq_d))
    return findings
 
def worst(findings):
    for level in ("crash", "loss", "review"):
        if any(f[0] == level for f in findings):
            return level
    return "ok"

src='%1$@ to %2$@'
 dst='Moved %2$@ to %1$@ and %1$@'
  set comparison=equal / multiset comparison=different

id                   severity  first finding
ok_positional_swap   ok      —
ok_same              ok      —
ok_percent_literal   ok      —
ok_brace             ok      —
meaning_swap         ok      —
lost_argnum          crash   ('crash', 'lost_argnum', [(None, '@'), (None, 'd')])
platform_token_swap  crash   ('crash', 'extra', (1, 's'))
dropped_one          loss    ('loss', 'missing', (2, '@'))
added_one            crash   ('crash', 'extra', (2, '@'))
type_mismatch        crash   ('crash', 'extra', (1, '@'))
fullwidth            crash   ('crash', 'broken_glyph', '％')
space_injected       crash   ('crash', 'broken_glyph', '% 1$')
seq_reordered        crash   ('crash', 'sequence_type_shift', ['d', '@'])
brace_translated     crash   ('crash', 'extra', ('件数', '{}'))
brace_dropped        loss    ('loss', 'missing', ('count', '{}'))
percent_unescaped    crash   ('crash', 'literal_percent', (1, 0))
reuse_positional     review  ('review', 'extra', (1, '@'))
 
totals: {'ok': 5, 'crash': 9, 'loss': 2, 'review': 1} / 17 cases

'Free %1$d%% left'     tokens=[(1, 'd')]              verdict=ok
'Free %1$d% left'      tokens=[(1, 'd'), (None, 'e')] verdict=crash
'Free (%1$d%)'         tokens=[(1, 'd')]              verdict=ok    <- slipped through
'Free %1$d%'           tokens=[(1, 'd')]              verdict=ok    <- slipped through

# gate.py — run this immediately after receiving a translation file
import re, sys
from fmtcheck import check, worst
 
STRINGS = re.compile(r'^\s*"((?:[^"\\]|\\.)*)"\s*=\s*"((?:[^"\\]|\\.)*)"\s*;', re.M)
 
def load_strings(path):
    with open(path, encoding="utf-8") as f:
        return dict(STRINGS.findall(f.read()))
 
def run(base_path, target_path):
    base, target = load_strings(base_path), load_strings(target_path)
    rows = []
    for key, src in base.items():
        dst = target.get(key)
        if dst is None:
            rows.append((key, "loss", [("loss", "missing_key", key)]))
            continue
        f = check(src, dst)
        rows.append((key, worst(f), f))
    return rows
 
if __name__ == "__main__":
    rows = run(sys.argv[1], sys.argv[2])
    order = {"crash": 0, "loss": 1, "review": 2, "ok": 3}
    rows.sort(key=lambda r: order[r[1]])
    blocked = sum(1 for _, level, _ in rows if level == "crash")
    for key, level, f in rows:
        print(f"[{level:<6}] {key}: {f if f else '—'}")
    print(f"\n{blocked} crash / {len(rows)} total")
    sys.exit(1 if blocked else 0)

[crash ] storage: [('crash', 'broken_glyph', '％'), ('loss', 'missing', (1, 'd'))]
[crash ] retry: [('crash', 'sequence_type_shift', ['d', '@'])]
[loss  ] move_done: [('loss', 'missing', (2, '@'))]
[ok    ] add_done: —
 
2 crash / 4 total
exit=1

# mask.py — park the specifiers before handing text to the model
import re
from fmtcheck import PRINTF, BRACE
 
TOKEN = "§{}§"                       # unlikely to be translated, unlikely to collide
BACK  = re.compile(r"§(\d+)§")
 
def mask(text):
    slots, idx = [], 0
    def take(m):
        nonlocal idx
        if m.group(0) == "%%":
            return m.group(0)
        slots.append(m.group(0)); idx += 1
        return TOKEN.format(idx - 1)
    out = PRINTF.sub(take, text)
    out = BRACE.sub(take, out)
    return out, slots
 
def unmask(text, slots):
    missing = []
    def put(m):
        i = int(m.group(1))
        if i >= len(slots):
            missing.append(i); return m.group(0)
        return slots[i]
    restored = BACK.sub(put, text)
    used = {int(m.group(1)) for m in BACK.finditer(text)}
    return restored, sorted(set(range(len(slots))) - used), missing

masked : §0§ wallpapers added in §1§ seconds (free §2§%%)
parked : ['%1$@', '%2$d', '%3$d']
 
returned verbatim     unused slots = []  / unknown markers = []
reordered             unused slots = []  / unknown markers = []
one marker dropped    unused slots = [1] / unknown markers = []
marker translated     unused slots = [0] / unknown markers = []
marker invented       unused slots = []  / unknown markers = [3]

# repair.py — re-translate only the crash lines, at most two rounds
import json, os
from anthropic import Anthropic
from fmtcheck import check, worst
from mask import mask, unmask
 
client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
MODEL = "claude-sonnet-5"
 
SYSTEM = (
    "You translate short UI strings. The input contains opaque markers like §0§. "
    "Copy every marker verbatim, keep the same count, never translate or reformat them. "
    "Return JSON only: an object mapping each key to the translated string."
)
 
def translate_batch(items, target_lang):
    masked, slotmap = {}, {}
    for k, src in items.items():
        masked[k], slotmap[k] = mask(src)
 
    msg = client.messages.create(
        model=MODEL,
        max_tokens=2000,
        system=SYSTEM,
        messages=[{
            "role": "user",
            "content": f"Target language: {target_lang}\n"
                       f"Strings:\n{json.dumps(masked, ensure_ascii=False, indent=2)}",
        }],
    )
    raw = json.loads(msg.content[0].text)
 
    out = {}
    for k, translated in raw.items():
        restored, unused, unknown = unmask(translated, slotmap[k])
        # Drop the line before anyone reads the prose
        out[k] = None if (unused or unknown) else restored
    return out
 
def repair(base, target, lang, max_rounds=2):
    fixed, log = dict(target), []
    for rnd in range(1, max_rounds + 1):
        broken = {k: base[k] for k in base
                  if worst(check(base[k], fixed.get(k, ""))) == "crash"}
        if not broken:
            log.append((rnd, 0, "stopped: no crash left"))
            break
        got = translate_batch(broken, lang)
        applied = 0
        for k, v in got.items():
            if v is None:
                continue
            if worst(check(base[k], v)) != "crash":   # never accept an unfixed line
                fixed[k] = v
                applied += 1
        log.append((rnd, len(broken), f"accepted {applied}"))
    still = [k for k in base if worst(check(base[k], fixed.get(k, ""))) == "crash"]
    return fixed, still, log

round 1: 3 candidates -> accepted 2
round 2: 1 candidates -> accepted 1
remaining crash: []
  add_done  [ok    ] Added %1$@ wallpapers in %2$d seconds
  storage   [ok    ] Uses %1$d%% of free space
  retry     [ok    ] Tried %@ times, %d attempts
  move      [loss  ] Moved %1$@

src='Copied from %1$@ to %2$@'
dst='Copied from %2$@ to %1$@'
verdict=ok