Add enforce_terminology: deterministic post-processing corrective gate

backend/pipeline.py

@@ -26,7 +26,7 @@ from sentence_transformers import SentenceTransformer
 
 from config import features_path, domain_for, DISPLAY_NAMES
 from grader import grade, GradeReport, get_embedder
-from rosetta import client_terms
+from rosetta import client_terms, enforce_terminology
 
 log = logging.getLogger(__name__)
 
@@ -321,7 +321,10 @@ def run(
     ]
 
     context = _build_context(retrieved)
-    answer = _generate(query, context, client, domain, hf_client)
+    raw_answer = _generate(query, context, client, domain, hf_client)
+    answer, replacements = enforce_terminology(raw_answer, client)
+    if replacements:
+        log.info("Terminology enforced for client=%s replacements=%s", client, replacements)
     report = grade(
         query=query,
         response=answer,

backend/rosetta.py

@@ -1,5 +1,6 @@
 """RosettaStone: canonical term -> client-specific term translation."""
 
+import re
 import yaml
 from functools import lru_cache
 
@@ -28,6 +29,22 @@ def client_terms(client: str) -> dict[str, str]:
     return dict(catalog.get(client, {}))
 
 
+def enforce_terminology(text: str, client: str) -> tuple[str, list[dict]]:
+    """Replace rival client terms with correct client terms. Returns (corrected_text, replacements)."""
+    catalog = _load_catalog(domain_for(client))
+    expected = catalog.get(client, {})
+    other_clients = {c: terms for c, terms in catalog.items() if c != client}
+    result = text
+    replacements = []
+    for canonical_key, client_term in expected.items():
+        for other_terms in other_clients.values():
+            rival = other_terms.get(canonical_key, "")
+            if rival and re.search(re.escape(rival), result, re.IGNORECASE):
+                result = re.sub(re.escape(rival), client_term, result, flags=re.IGNORECASE)
+                replacements.append({"from": rival, "to": client_term})
+    return result, replacements
+
+
 def check_terminology(response_text: str, client: str) -> dict:
     """
     Deterministic chain_terminology check.