feat(translation): accept/reject gate on Interpreter's detection confidence (#1376)

Interpreter now returns a real per-detection confidence (source stays "auto"),
so curator can reject the mis-detections it was blindly storing — e.g. a short
English title mis-labelled as German and rewritten into the archive.

The gate consumes ONLY Interpreter's own reported detection — curator does no
language detection of its own (Scribe rule 133): a field is stored when the
engine actually translated it AND either the detected language is CJK
(script-detected, reliably high — ja/ko/zh trusted outright, incl. pure-kanji
Japanese that lands as zh ~0.75) or the reported confidence clears a
latin-script floor (_MIN_LATIN_CONFIDENCE = 0.90). A latin detection below the
floor keeps the original and marks the post handled; a missing confidence fails
open. The client already sent source="auto" and parsed confidence, so this is
purely the gate + tests.

Tests: pinned interpreter-client test now asserts source stays "auto"; new
pure-unit gate tests (CJK trusted / latin floor / case-insensitive / fail-open)
in the fast lane; end-to-end reject-low-latin, accept-high-latin,
accept-low-cjk sweeps.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CgZP9v2otxVJymiYsnVuMy

tests/test_interpreter_client.py

@@ -38,6 +38,9 @@ def test_translate_maps_batch_in_order(monkeypatch):
     assert out["engine_version"] == "ollama:x:12b"
     assert captured["json"]["q"] == ["ねこが可愛い", "金髪ギャル！"]
     assert captured["json"]["target"] == "en"
+    # Source MUST stay "auto": an explicit source makes Interpreter skip detection
+    # and report confidence 1.0, which would defeat the acceptance gate.
+    assert captured["json"]["source"] == "auto"
 
 
 def test_translate_passthrough_unchanged(monkeypatch):

tests/test_translate_posts.py

@@ -252,6 +252,68 @@ def test_translate_posts_beat_single_chunk_no_tail_chase(db_sync, monkeypatch):
     assert calls == []                           # no self-re-enqueue
 
 
+def _mock_lang(monkeypatch, *, lang, conf, ver="v1"):
+    # Interpreter is up and returns a translation with the given detected language
+    # + confidence, so the acceptance gate can be exercised end-to-end.
+    monkeypatch.setattr("backend.app.tasks.translation.ic.health", lambda *a, **k: True)
+    monkeypatch.setattr(
+        "backend.app.tasks.translation.ic.translate",
+        lambda texts, **k: {
+            "translations": [f"EN:{t}" for t in texts],
+            "detected_lang": lang, "detected_confidence": conf,
+            "engine": "llm", "engine_version": ver,
+        },
+    )
+
+
+def test_translate_posts_rejects_low_confidence_latin(db_sync, monkeypatch):
+    # A short English title Interpreter mis-labels as German with LOW confidence is
+    # NOT stored — the original is kept, and the post is marked handled (source ==
+    # target) so the sweep won't revisit it.
+    _patch(monkeypatch, db_sync)
+    _mock_lang(monkeypatch, lang="de", conf=0.42)
+    a = _artist(db_sync)
+    p = _post(db_sync, a.id, title="Nami Heroines - WIP Part 1", ext="p1")
+    _enable(db_sync)
+    db_sync.commit()
+
+    translate_posts()
+    db_sync.refresh(p)
+    assert p.post_title_translated is None            # mis-flag rejected, kept
+    assert p.translated_source_lang == "en"           # marked handled (== target)
+
+
+def test_translate_posts_accepts_high_confidence_latin(db_sync, monkeypatch):
+    # A confident latin-script detection (real German) clears the floor → stored.
+    _patch(monkeypatch, db_sync)
+    _mock_lang(monkeypatch, lang="de", conf=0.98)
+    a = _artist(db_sync)
+    p = _post(db_sync, a.id, title="Das Mädchen mit dem Perlenohrring", ext="p2")
+    _enable(db_sync)
+    db_sync.commit()
+
+    translate_posts()
+    db_sync.refresh(p)
+    assert p.post_title_translated == "EN:Das Mädchen mit dem Perlenohrring"
+    assert p.translated_source_lang == "de"
+
+
+def test_translate_posts_accepts_low_confidence_cjk(db_sync, monkeypatch):
+    # CJK is script-detected and trusted regardless of the reported number — a
+    # zh 0.75 (e.g. pure-kanji Japanese) is still translated, not rejected.
+    _patch(monkeypatch, db_sync)
+    _mock_lang(monkeypatch, lang="zh", conf=0.75)
+    a = _artist(db_sync)
+    p = _post(db_sync, a.id, title="猫が可愛い", ext="p3")
+    _enable(db_sync)
+    db_sync.commit()
+
+    translate_posts()
+    db_sync.refresh(p)
+    assert p.post_title_translated == "EN:猫が可愛い"
+    assert p.translated_source_lang == "zh"
+
+
 def _mock_new_model(monkeypatch, *, ver="v2"):
     """Interpreter is up and translates with a NEW engine version."""
     monkeypatch.setattr("backend.app.tasks.translation.ic.health", lambda *a, **k: True)

tests/test_translation_gate.py

@@ -0,0 +1,33 @@
+"""Translation acceptance gate (#1376) — pure unit tests for ``_accept``, which
+decides whether curator stores Interpreter's translation or keeps the original.
+Curator does no detection of its own; it only thresholds Interpreter's reported
+detected language + confidence (Scribe rule 133). No DB, no network."""
+from backend.app.tasks.translation import _MIN_LATIN_CONFIDENCE, _accept
+
+
+def test_accept_trusts_cjk_regardless_of_confidence():
+    # ja/ko/zh are script-detected — accepted even at a low reported number
+    # (pure-kanji Japanese can come back labelled zh ~0.75, still translated).
+    assert _accept("ja", None) is True
+    assert _accept("ja", 0.10) is True
+    assert _accept("ko", 0.99) is True
+    assert _accept("zh", 0.75) is True
+    assert _accept("zh-CN", 0.20) is True      # region suffix is still CJK
+
+
+def test_accept_requires_floor_for_latin():
+    assert _accept("de", 0.98) is True
+    assert _accept("de", _MIN_LATIN_CONFIDENCE) is True          # exactly at floor
+    assert _accept("de", _MIN_LATIN_CONFIDENCE - 0.01) is False
+    assert _accept("fr", 0.40) is False                          # short mis-flag
+
+
+def test_accept_is_case_insensitive():
+    assert _accept("JA", None) is True
+    assert _accept("DE", 0.40) is False
+
+
+def test_accept_missing_confidence_fails_open():
+    # No confidence reported → don't silently drop a translation.
+    assert _accept("de", None) is True
+    assert _accept("", None) is True