Replace enforce_terminology with pinned glossary doc in RAG context

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, enforce_terminology
+from rosetta import client_terms, client_terms_doc
 
 log = logging.getLogger(__name__)
 
@@ -320,11 +320,15 @@ def run(
         if scores[i] > MIN_RETRIEVAL_SCORE
     ]
 
-    context = _build_context(retrieved)
-    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)
+    terms_doc = client_terms_doc(client)
+    pinned = RetrievedDoc(
+        id=terms_doc["id"],
+        title=terms_doc["title"],
+        content=terms_doc["content"],
+        score=1.0,
+    )
+    context = _build_context([pinned] + retrieved)
+    answer = _generate(query, context, client, domain, hf_client)
     report = grade(
         query=query,
         response=answer,

backend/rosetta.py

@@ -1,10 +1,9 @@
 """RosettaStone: canonical term -> client-specific term translation."""
 
-import re
 import yaml
 from functools import lru_cache
 
-from config import term_catalog_path, domain_for
+from config import term_catalog_path, domain_for, DISPLAY_NAMES
 
 
 @lru_cache(maxsize=8)
@@ -29,20 +28,16 @@ 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 client_terms_doc(client: str) -> dict:
+    """Return the term catalog as a pinned KB document for context injection."""
+    terms = client_terms(client)
+    display = DISPLAY_NAMES.get(client, client.title())
+    lines = "\n".join(f"- {k.replace('_', ' ').title()}: use '{v}'" for k, v in terms.items())
+    return {
+        "id": f"terms_{client}",
+        "title": f"{display} Terminology Guide",
+        "content": f"Always use these exact terms when responding to {display} users:\n{lines}",
+    }
 
 
 def check_terminology(response_text: str, client: str) -> dict: