[NOTICKET] fix(agents): lock analysis answer language to the user's turn

The analysis answer composer (ChatbotAgent / chatbot_system.md) had no reply-language rule, so it drifted to English even for Indonesian questions (the data context — column names, rows — is English). Extract the deterministic detector from help.py into a shared src/agents/language.py, enrich the Indonesian markers with common chat abbreviations (brp, gmn, yg, ...), and add a history fallback so a short/ambiguous turn inherits the conversation language instead of the team default. ChatbotAgent now computes the language per turn and injects a [Reply language] hard directive; chatbot_system.md gained the matching hard rule (mirrors help.md). help.py re-exports the moved names, so its call sites + tests are unchanged.

src/agents/chatbot.py

@@ -25,6 +25,7 @@ from langchain_openai import AzureChatOpenAI
 from src.middlewares.logging import get_logger
 
 from ..query.executor.base import QueryResult
+from .language import detect_reply_language
 
 logger = get_logger("chatbot")
 
@@ -126,6 +127,9 @@ def _build_default_chain() -> Runnable:
     prompt = ChatPromptTemplate.from_messages(
         [
             ("system", _load_system_prompt()),
+            # Hard reply-language directive — the system prompt's language rule
+            # points at this. Deterministic + mandatory, mirrors the help path.
+            ("system", "[Reply language]\nRespond ONLY in: {reply_language}"),
             MessagesPlaceholder(variable_name="history", optional=True),
             ("human", "{message}"),
             ("system", "Data context for this turn:\n\n{context}"),
@@ -168,6 +172,9 @@ class ChatbotAgent:
             "message": message,
             "history": history or [],
             "context": _build_context_block(query_result, chunks),
+            # Deterministic reply-language lock: current turn, else last human turn
+            # (so a short/ambiguous turn inherits the conversation language).
+            "reply_language": detect_reply_language(history, message=message),
         }
         if callbacks:
             async for token in chain.astream(payload, config={"callbacks": callbacks}):

src/agents/handlers/help.py

@@ -29,7 +29,6 @@ SEAMS:
 
 from __future__ import annotations
 
-import re
 from collections.abc import AsyncIterator
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -42,6 +41,12 @@ from langchain_core.runnables import Runnable
 from langchain_openai import AzureChatOpenAI
 
 from src.agents.gate import AnalysisState
+from src.agents.language import (
+    FALLBACK_LANGUAGE as _FALLBACK_LANGUAGE,
+)
+from src.agents.language import (
+    detect_reply_language as _detect_reply_language,
+)
 from src.middlewares.logging import get_logger
 
 logger = get_logger("help")
@@ -58,72 +63,9 @@ _DEFAULT_TRIGGERS = {
     "Indonesian": "Apa yang sebaiknya saya lakukan selanjutnya?",
     "English": "What should I do next?",
 }
-_FALLBACK_LANGUAGE = "Indonesian"  # team default when no human turn exists yet
-
-# Lightweight, LLM-free language detection over the last human turn. The result is LOCKED
-# into the prompt via a `[Reply language]` directive (see `_build_context_block`), so
-# replying in the user's language is deterministic/mandatory — not a soft prompt hint that
-# an English system prompt + English default trigger can override.
-_ID_MARKERS = frozenset({
-    "yang", "dan", "apa", "gimana", "bagaimana", "kenapa", "mengapa", "aku", "saya",
-    "tolong", "ini", "itu", "nih", "dong", "kah", "untuk", "dengan", "pada", "adalah",
-    "tidak", "enggak", "nggak", "bisa", "mau", "buat", "dari", "kamu", "ya",
-    "berapa", "kapan", "siapa", "dimana", "juga", "sudah", "belum", "akan",
-})
-_EN_MARKERS = frozenset({
-    "the", "what", "how", "why", "please", "this", "that", "is", "are", "can", "could",
-    "should", "for", "with", "of", "and", "you", "do", "does", "when", "where",
-    "who", "which", "my", "me", "your", "have", "has", "want", "next",
-})
-
-
-def _last_human_text(history: list[BaseMessage] | None) -> str:
-    """Return the text of the most recent human turn in history, or '' if none."""
-    for msg in reversed(history or []):
-        if getattr(msg, "type", None) == "human":
-            content = msg.content
-            return content if isinstance(content, str) else str(content)
-    return ""
-
-
-def _score_language(text: str) -> str | None:
-    """Return "Indonesian"/"English" from marker-word counts, or None if no signal."""
-    tokens = re.findall(r"[a-z']+", text.lower())
-    id_hits = sum(1 for t in tokens if t in _ID_MARKERS)
-    en_hits = sum(1 for t in tokens if t in _EN_MARKERS)
-    if en_hits > id_hits:
-        return "English"
-    if id_hits > en_hits:
-        return "Indonesian"
-    return None
-
-
-def _detect_reply_language(
-    history: list[BaseMessage] | None,
-    message: str | None = None,
-    goal_texts: list[str] | None = None,
-) -> str:
-    """Detect the reply language deterministically (no LLM), by signal priority.
-
-    1. the user's turn — an explicit `message` (intent path) or the last human turn in
-       `history` (button path, where `message` is None);
-    2. the user-authored goal (`objective` + `business_questions`) — required at
-       onboarding, so it's always present and is a reliable signal on a fresh analysis
-       that has no chat yet;
-    3. the team default (Indonesian) — a safety net only, for a stub/legacy/empty-goal
-       state where nothing above yields a signal.
-
-    Returns "Indonesian" or "English".
-    """
-    primary = (message or _last_human_text(history)).strip()
-    lang = _score_language(primary) if primary else None
-    if lang:
-        return lang
-    goal = " ".join(t for t in (goal_texts or []) if t).strip()
-    lang = _score_language(goal) if goal else None
-    if lang:
-        return lang
-    return _FALLBACK_LANGUAGE
+# Reply-language detection now lives in `src/agents/language.py` (shared with the
+# analysis answer composer). `_detect_reply_language` / `_FALLBACK_LANGUAGE` are
+# re-exported via the imports above so this module's call sites + tests are unchanged.
 
 
 @dataclass

src/agents/language.py

@@ -0,0 +1,92 @@
+"""Deterministic, LLM-free reply-language detection shared across agents.
+
+The user-facing agents (help playbook + the analysis answer composer) must reply
+in the user's language. Detection is marker-word based over the user's turn, and
+the result is injected into the prompt as a hard `[Reply language]` directive so
+replying in that language is mandatory — not a soft hint an English system prompt
++ English data context can override.
+
+Signal priority (first hit wins):
+  1. the current turn (`message`);
+  2. the most recent human turn in `history` — covers the button path (no
+     `message`) AND acts as a tiebreaker when the current turn is too short to
+     carry a signal (e.g. "2025 vs 2026"), so a bilingual user's ambiguous turn
+     inherits their previous turn's language instead of snapping to the default;
+  3. the user-authored goal (`objective` + `business_questions`);
+  4. the team default (Indonesian).
+"""
+
+from __future__ import annotations
+
+import re
+
+from langchain_core.messages import BaseMessage
+
+FALLBACK_LANGUAGE = "Indonesian"  # team default when nothing yields a signal
+
+# Function words + common chat shorthand/abbreviations. Content words (nouns,
+# domain terms) are deliberately excluded — they're often shared across both
+# languages (e.g. "data", "revenue") and would add noise.
+_ID_MARKERS = frozenset({
+    "yang", "dan", "apa", "gimana", "bagaimana", "kenapa", "mengapa", "aku", "saya",
+    "tolong", "ini", "itu", "nih", "dong", "kah", "untuk", "dengan", "pada", "adalah",
+    "tidak", "enggak", "nggak", "bisa", "mau", "buat", "dari", "kamu", "ya",
+    "berapa", "kapan", "siapa", "dimana", "juga", "sudah", "belum", "akan",
+    # abbreviations / chat shorthand
+    "brp", "gmn", "yg", "gt", "gitu", "gini", "dgn", "utk", "tdk", "sdh", "blm",
+    "aja", "dah", "kalo", "klo", "knp", "jd", "jgn", "krn", "udah", "udh",
+    "ga", "gak", "gk", "engga", "trus", "trs", "sm", "kayak", "kek",
+})
+_EN_MARKERS = frozenset({
+    "the", "what", "how", "why", "please", "this", "that", "is", "are", "can", "could",
+    "should", "for", "with", "of", "and", "you", "do", "does", "when", "where",
+    "who", "which", "my", "me", "your", "have", "has", "want", "next",
+})
+
+
+def _last_human_text(history: list[BaseMessage] | None) -> str:
+    """Return the text of the most recent human turn in history, or '' if none."""
+    for msg in reversed(history or []):
+        if getattr(msg, "type", None) == "human":
+            content = msg.content
+            return content if isinstance(content, str) else str(content)
+    return ""
+
+
+def _score_language(text: str) -> str | None:
+    """Return "Indonesian"/"English" from marker-word counts, or None if no signal."""
+    tokens = re.findall(r"[a-z']+", text.lower())
+    id_hits = sum(1 for t in tokens if t in _ID_MARKERS)
+    en_hits = sum(1 for t in tokens if t in _EN_MARKERS)
+    if en_hits > id_hits:
+        return "English"
+    if id_hits > en_hits:
+        return "Indonesian"
+    return None
+
+
+def detect_reply_language(
+    history: list[BaseMessage] | None,
+    message: str | None = None,
+    goal_texts: list[str] | None = None,
+) -> str:
+    """Detect the reply language deterministically (no LLM), by signal priority.
+
+    See the module docstring for the priority order. Returns "Indonesian" or
+    "English".
+    """
+    if message:
+        lang = _score_language(message)
+        if lang:
+            return lang
+    prev = _last_human_text(history)
+    if prev:
+        lang = _score_language(prev)
+        if lang:
+            return lang
+    goal = " ".join(t for t in (goal_texts or []) if t).strip()
+    if goal:
+        lang = _score_language(goal)
+        if lang:
+            return lang
+    return FALLBACK_LANGUAGE

src/config/prompts/chatbot_system.md

@@ -1,5 +1,14 @@
 You are a friendly, precise data assistant for a user who has registered databases and uploaded files. Your job is to answer the user's questions using **only** the data context provided to you in this turn.
 
+> **Reply language.** **Default** to the language named in `[Reply language]` (detected from
+> the user's turn). The data context — column/table names and rows — is often English; do
+> **not** let it pull your reply toward English. The user's language wins.
+> **Exception — explicit request overrides.** If the user explicitly asks to reply in a
+> particular language (e.g. "jawab dalam bahasa Inggris", "please answer in Indonesian"),
+> honor that request instead — an explicit instruction beats `[Reply language]`, and it
+> stays in effect for later turns until the user changes it.
+> Never mix languages or switch mid-reply. Proper nouns and column/table names may stay as-is.
+
 ## Rules
 
 1. **Ground every claim in the provided context.** If the context doesn't contain the answer, say so plainly — do not guess. Never invent numbers, dates, or facts that aren't in the result rows or document chunks.