feat(translation): quality pipeline overhaul + new features (audit 2026-08-29)

Translation quality & format preservation:
- Word: merge adjacent same-format runs into one unit (sentence-level
  coherence like inline-tag handling); translate comments/balloons;
  dedupe textbox collection (was translated twice); RTL no longer
  overrides center/justify alignment; CJK/Arabic font hints (eastAsia/cs)
- PPTX: chart translations now actually reach the output file
  (ChartPart.blob is read-only — rewrite chart XML in the saved ZIP);
  CJK typeface hints (a:ea)
- Excel: sheet renames no longer break references — rewrite cell
  formulas (3D/quoted), defined names, data validations, cond. formats
- PDF: bold/italic honored (hebo/heit/hebi); table cells never merge;
  unchanged blocks left untouched (typography preserved, fixes duplicate
  hyperlinks); attempted/changed stats + route gate now cover PDF;
  CJK font paths; scanned PDFs via Mistral OCR (detection + admin settings)

Features:
- formality param (formal/informal) + automatic regional-variant prompts
- output_mode=bilingual docx (source above translation)
- per-user translation memory on Redis (falls back to LRU), context-hashed
- QA report + 0-100 confidence score in job status; L0 on by default
- OpenAI-compatible providers: whole chunk in ONE numbered-JSON request
  (~15x fewer calls) with per-item fallback; base prompt always present
  (custom prompt no longer replaces translation instructions)

Infra & marketing alignment:
- plan-based engine gating + vision gating (closes paid-engine leak);
  /providers/available filtered per plan; 107 languages exposed
- zh-CN/zh-TW validation fixed; libmagic disabled on Windows (native crash)
- admin: Mistral OCR settings + engine status dashboard; httpx<0.28 pin
  (TestClient breakage); Prometheus test fixture fixed
- marketing docs aligned with code (PDF+OCR, retention, engines, pricing)
- security: .env.ionos/.env.production/provider_settings.json removed

Tests: 1173 passed / 0 failed (6 network tests deselected: free Google
endpoint temporarily blocked from this machine)

services/providers/openai_provider.py

@@ -22,7 +22,16 @@ from typing import Any, Dict, List, Optional
 from core.logging import get_logger
 
 logger = get_logger(__name__)
-_HAS_STRUCTLOG = True
+
+# structlog is the project's logger backend (see core/logging.py), but detect
+# it rather than hardcoding True so the stdlib-logging fallback branches below
+# are reachable if structlog is ever absent.
+try:
+    import structlog  # noqa: F401
+
+    _HAS_STRUCTLOG = True
+except ImportError:  # pragma: no cover - structlog is a hard project dep
+    _HAS_STRUCTLOG = False
 
 
 def _log_info(event: str, **kwargs):
@@ -111,56 +120,26 @@ Rules:
 def _build_system_prompt(
     source_lang: str, target_lang: str, custom_prompt: Optional[str] = None
 ) -> str:
-    """Build system prompt for translation."""
-    if custom_prompt:
-        return custom_prompt
-    return DEFAULT_TRANSLATION_PROMPT.format(
+    """Build system prompt for translation.
+
+    The base translation instructions are ALWAYS present — a custom prompt
+    (glossary, tone, context) is appended as additional directives, never a
+    replacement. Previously a glossary-only custom prompt produced a system
+    prompt with no translation instruction at all.
+    """
+    base = DEFAULT_TRANSLATION_PROMPT.format(
         source_lang=source_lang, target_lang=target_lang
     )
+    if custom_prompt and custom_prompt.strip():
+        return f"{base}\n\nADDITIONAL CONTEXT AND INSTRUCTIONS:\n{custom_prompt.strip()}"
+    return base
 
 
 def _get_language_name(code: str) -> str:
     """Convert language code to full name for better LLM understanding."""
-    language_names = {
-        "en": "English",
-        "fr": "French",
-        "es": "Spanish",
-        "de": "German",
-        "it": "Italian",
-        "pt": "Portuguese",
-        "nl": "Dutch",
-        "ru": "Russian",
-        "zh": "Chinese",
-        "ja": "Japanese",
-        "ko": "Korean",
-        "ar": "Arabic",
-        "hi": "Hindi",
-        "tr": "Turkish",
-        "pl": "Polish",
-        "vi": "Vietnamese",
-        "th": "Thai",
-        "id": "Indonesian",
-        "ms": "Malay",
-        "uk": "Ukrainian",
-        "cs": "Czech",
-        "sv": "Swedish",
-        "da": "Danish",
-        "fi": "Finnish",
-        "no": "Norwegian",
-        "el": "Greek",
-        "he": "Hebrew",
-        "ro": "Romanian",
-        "hu": "Hungarian",
-        "bg": "Bulgarian",
-        "sk": "Slovak",
-        "hr": "Croatian",
-        "sl": "Slovenian",
-        "lt": "Lithuanian",
-        "lv": "Latvian",
-        "et": "Estonian",
-    }
-    base_code = code.split("-")[0].lower()
-    return language_names.get(base_code, code)
+    from core.languages import language_name
+
+    return language_name(code)
 
 
 class OpenAITranslationProvider(TranslationProvider):
@@ -529,21 +508,120 @@ class OpenAITranslationProvider(TranslationProvider):
             error_code=OPENAI_SERVICE_ERROR,
         )
 
+    def _make_batch_api_request(
+        self, texts: List[str], system_prompt: str
+    ) -> Optional[List[str]]:
+        """Translate a whole chunk in ONE request via a numbered JSON list.
+
+        The user message is a JSON array; the model must answer with a JSON
+        array of the same length. Returns None when the answer cannot be
+        parsed confidently — callers then fall back to per-item calls
+        (correctness over latency).
+        """
+        import json as _json
+
+        numbered = _json.dumps(
+            [{"id": i, "text": t} for i, t in enumerate(texts)],
+            ensure_ascii=False,
+        )
+        batch_system = (
+            system_prompt
+            + "\n\nBATCH MODE: the user message is a JSON array of items with "
+            "unique ids. Answer with ONLY a JSON array of objects "
+            '[{"id": <same id>, "translation": "<translated text>"}], same '
+            "length and same ids, in the same order. Translate every item; "
+            "keep ids unchanged; no comments, no markdown fence."
+        )
+
+        try:
+            content, _usage = self._make_api_request(numbered, batch_system)
+            raw = content.strip()
+            # Strip an optional markdown fence
+            if raw.startswith("```"):
+                raw = raw.strip("`")
+                if raw.lower().startswith("json"):
+                    raw = raw[4:]
+                raw = raw.strip()
+            parsed = _json.loads(raw)
+            if not isinstance(parsed, list) or len(parsed) != len(texts):
+                return None
+            out: List[str] = [""] * len(texts)
+            for item in parsed:
+                if not isinstance(item, dict):
+                    return None
+                idx = item.get("id")
+                translation = item.get("translation")
+                if not isinstance(idx, int) or not 0 <= idx < len(texts):
+                    return None
+                if not isinstance(translation, str) or not translation.strip():
+                    return None
+                out[idx] = translation.strip()
+            return out
+        except OpenAIProviderError:
+            raise
+        except Exception:
+            return None
+
     def translate_batch(
         self, requests: List[TranslationRequest]
     ) -> List[TranslationResponse]:
         """
         Translate multiple texts.
 
-        Args:
-            requests: List of TranslationRequest objects
-
-        Returns:
-            List of TranslationResponse objects
+        Chunks arrive from the translators as ~15 texts. When every request
+        shares the same language pair and metadata, they are sent in ONE
+        call (numbered JSON list — ~15× fewer requests, better contextual
+        consistency across neighbouring segments). Any parse/API doubt falls
+        back to the per-item path so a batch failure never corrupts output.
         """
         if not requests:
             return []
 
+        same_pair = len({(r.source_language, r.target_language) for r in requests}) == 1
+        same_meta = len(
+            {tuple(sorted((r.metadata or {}).items())) for r in requests}
+        ) == 1
+
+        if same_pair and same_meta and len(requests) > 1:
+            try:
+                source_lang_name = _get_language_name(
+                    requests[0].source_language or "auto"
+                ) or "the source language (auto-detect)"
+                target_lang_name = _get_language_name(requests[0].target_language)
+                custom_prompt = None
+                if requests[0].metadata:
+                    custom_prompt = requests[0].metadata.get("custom_prompt")
+                system_prompt = _build_system_prompt(
+                    source_lang_name, target_lang_name, custom_prompt
+                )
+                texts = [r.text for r in requests]
+                translations = self._make_batch_api_request(texts, system_prompt)
+                if translations is not None:
+                    _log_info(
+                        "openai_batch_translation_success",
+                        items=len(requests),
+                        model=self._model,
+                    )
+                    return [
+                        TranslationResponse(
+                            translated_text=t,
+                            provider_name=self._provider_name,
+                            from_cache=False,
+                        )
+                        for t in translations
+                    ]
+                _log_warning(
+                    "openai_batch_translation_fallback",
+                    reason="unparseable_response",
+                    items=len(requests),
+                )
+            except Exception as e:
+                _log_warning(
+                    "openai_batch_translation_fallback",
+                    reason=type(e).__name__,
+                    items=len(requests),
+                )
+
         return [self.translate_text(req) for req in requests]
 
     def health_check(self) -> ProviderHealthStatus: