[NOTICKET] fix(agents): analysis answer reply-language + number formatting

The Assembler (analysis answer composer) had no reply-language rule and drifted to English; it also detected language from the router's rewritten_query (normalized to English) rather than the user's turn. Detect reply_language from the ORIGINAL message in chat_handler and thread it through coordinator -> assembler; add the [Reply language] default+explicit-override rule to assembler.md. Also add number formatting to assembler.md: round to a sensible default precision (honoring an explicit user request like '2 angka di belakang koma'), match prose and table cells, and use the decimal separator of the reply language (comma for Indonesian).

src/agents/chat_handler.py

@@ -47,6 +47,7 @@ from .handlers.help import HelpAgent
 # `run_problem_statement` unwired 2026-06-24 (problem_statement removed from the router).
 # `ProblemStatementAgent` kept — still referenced by the constructor + _get_ps_agent.
 from .handlers.problem_statement import ProblemStatementAgent
+from .language import detect_reply_language
 from .orchestration import OrchestratorAgent
 from .refusals import blocked_message, out_of_scope_message
 
@@ -410,8 +411,12 @@ class ChatHandler:
                 catalog = await reader.read(user_id, "structured")
                 # structured_flow always runs the slow analytical path (the
                 # ENABLE_SLOW_PATH flag was removed 2026-07-02).
+                # Detect reply language from the ORIGINAL message (not `rewritten` — the
+                # router's rewritten_query is often normalized to English, which would
+                # make the assembled answer English for an Indonesian question).
+                reply_language = detect_reply_language(history, message=message)
                 async for event in self._run_slow_path(
-                    user_id, rewritten, catalog, tracer, reader, analysis_id
+                    user_id, rewritten, catalog, tracer, reader, analysis_id, reply_language
                 ):
                     yield event
                 return
@@ -594,6 +599,7 @@ class ChatHandler:
         tracer: Any = None,
         catalog_reader: CatalogReader | None = None,
         analysis_id: str | None = None,
+        reply_language: str | None = None,
     ) -> AsyncIterator[dict[str, Any]]:
         """Run the slow path and stream its assembled answer as SSE events.
 
@@ -640,7 +646,8 @@ class ChatHandler:
 
         run_task = asyncio.create_task(
             coordinator.run(
-                context, catalog, query, Constraints(), progress=_progress, **run_kw
+                context, catalog, query, Constraints(),
+                progress=_progress, reply_language=reply_language, **run_kw
             )
         )
         getter: asyncio.Task = asyncio.create_task(progress_q.get())

src/agents/slow_path/assembler.py

@@ -25,6 +25,7 @@ from langchain_openai import AzureChatOpenAI
 
 from src.middlewares.logging import get_logger
 
+from ..language import detect_reply_language
 from ..planner.contracts import BusinessContext
 from .errors import AssemblerError
 from .prompt import build_assembler_prompt
@@ -93,10 +94,16 @@ class Assembler:
         run_state: RunState,
         context: BusinessContext,
         question: str | None = None,
+        reply_language: str | None = None,
         callbacks: list | None = None,
     ) -> AssembledOutput:
         chain = self._ensure_chain()
-        human_content = build_assembler_prompt(run_state, context, question)
+        # `reply_language` is detected upstream from the ORIGINAL user message. Fall back
+        # to `question` only if not provided — but note `question` is the router's
+        # rewritten_query, which may be normalized to English, so the caller should pass it.
+        if reply_language is None:
+            reply_language = detect_reply_language([], message=question)
+        human_content = build_assembler_prompt(run_state, context, question, reply_language)
         try:
             if callbacks:
                 narrative: AssemblerNarrative = await chain.ainvoke(
@@ -113,6 +120,7 @@ class Assembler:
             plan_id=run_state.plan_id,
             business_context_id=run_state.business_context_id,
             n_tasks=len(run_state.results),
+            reply_language=reply_language,
         )
         return AssembledOutput(chat_answer=narrative.chat_answer, analysis_record=record)
 

src/agents/slow_path/coordinator.py

@@ -43,6 +43,7 @@ class SlowPathCoordinator:
         planner_callbacks: list | None = None,
         assembler_callbacks: list | None = None,
         progress: Callable[[str], Awaitable[None]] | None = None,
+        reply_language: str | None = None,
     ) -> AssembledOutput:
         # `progress` (optional) surfaces per-stage status to the caller so a long
         # slow-path run isn't a silent ~12s on the wire. Each stage is a single
@@ -62,5 +63,5 @@ class SlowPathCoordinator:
             await progress("Composing the answer…")
         asm_kw = {"callbacks": assembler_callbacks} if assembler_callbacks else {}
         return await self._assembler.assemble(
-            run_state, context, question=query, **asm_kw
+            run_state, context, question=query, reply_language=reply_language, **asm_kw
         )

src/agents/slow_path/prompt.py

@@ -56,6 +56,7 @@ def build_assembler_prompt(
     run_state: RunState,
     context: BusinessContext,
     question: str | None = None,
+    reply_language: str | None = None,
 ) -> str:
     sections = [
         f"# Business context\n\n{render_business_context(context)}",
@@ -63,4 +64,15 @@ def build_assembler_prompt(
     ]
     if question:
         sections.append(f"# Original question\n\n{question}")
+    if reply_language:
+        # Imperative + resolved language name (a bare "[Reply language]: X" label is too
+        # weak for the structured-output call — the English data render drowns it out).
+        # The full rule (incl. explicit-request exception) lives in assembler.md.
+        sections.append(
+            f"# Reply language (MANDATORY)\n\n"
+            f"Write `chat_answer` AND every narrative field entirely in **{reply_language}**. "
+            f"The results above use English column names and labels — do NOT let that switch "
+            f"your reply to English. (If the user explicitly asked for a different language, "
+            f"follow that instead.)"
+        )
     return "\n\n".join(sections)

src/config/prompts/assembler.md

@@ -9,6 +9,16 @@ You produce two things in one structured object:
 2. The narrative fields of an analysis record: `goal_restated`, `findings`,
    `caveats`, `data_used`, `open_questions`.
 
+# Reply language
+
+> **Default** to the language named in `[Reply language]` (in the input's *Reply language*
+> section, detected from the user's question). Write `chat_answer` **and** the narrative fields
+> in that language. The task results — column/table names and rows — are often English; do
+> **not** let them 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 instead. Proper nouns and column/table names may stay as-is.
+
 # Hard rules (non-negotiable)
 
 1. **Ground every claim in the provided results.** Use only the numbers, tables,
@@ -28,6 +38,19 @@ You produce two things in one structured object:
 
 - **`chat_answer`**: lead with the answer. Add a short markdown table when it makes
   the numbers clearer. Keep it tight — this streams into a chat, not a report.
+- **Number formatting.** **Default:** round every figure to a sensible reading precision —
+  usually **3 decimals** (up to 5 for small magnitudes like correlations/rates). Never paste
+  a raw full-precision float (e.g. `18.053165810898534` → `18.053`), and keep whole numbers
+  whole. Apply this in **both** the prose and the table cells so they match.
+  **Exception — honor an explicit user request.** If the user asked for a specific precision
+  (e.g. "3 angka di belakang koma", "bulatkan ke bilangan bulat", "give the exact value"),
+  use exactly that instead of the default — consistently across prose and tables.
+  This is display rounding only — it does **not** violate "Render, don't recompute"; the
+  underlying value is unchanged.
+  **Decimal separator.** Match the reply language: when replying in **Indonesian**, use a
+  **comma** for the decimal point and a period for thousands (`71,26`, `1.250,5`); in
+  **English**, use a period for the decimal and a comma for thousands (`71.26`, `1,250.5`).
+  Be consistent within one reply.
 - **`findings`**: the key takeaways, each a single self-contained sentence with the
   supporting figure.
 - **`caveats`**: data-quality limits, partial/failed steps, assumptions that affect