[NOTICKET] Fix check skill: reply language + tabular inventory routing

The `check` intent path never applied reply-language detection and hardcoded
English strings, so inventory questions ("data apa saja yang aku punya?")
always answered in English regardless of the room's language. It also routed
generic words ("uploaded", "file") to the document-only branch, so a user with
only tabular (CSV/XLSX) sources got "nothing registered" — their data lives
under check_data, not check_knowledge.

- chat_handler: detect reply_language from the original message and pass it to
run_check (mirrors the structured_flow branch).
- check.py: localize fixed prose (no_match, helicopter labels, error) via an
EN/ID string bundle; thread reply_language through render helpers.
- check.py: drop "uploaded"/"file" from knowledge cues so bare inventory
questions fall through to the helicopter view (structured + documents).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/agents/chat_handler.py

@@ -443,7 +443,11 @@ class ChatHandler:
         elif intent == "check":
             try:
                 invoker = self._get_check_invoker(user_id)
-                text = await run_check(rewritten, invoker)
+                # Detect from the ORIGINAL message (not `rewritten`, which the
+                # router normalizes to English) so the deterministic check reply
+                # matches the user's language like the other paths.
+                reply_language = detect_reply_language(history, message=message)
+                text = await run_check(rewritten, invoker, reply_language)
             except Exception as e:
                 logger.error("check route failed", user_id=user_id, error=str(e))
                 yield {"event": "error", "data": f"Lookup failed: {e}"}

src/agents/handlers/check.py

@@ -21,16 +21,20 @@ from src.tools.contracts import ToolOutput
 if TYPE_CHECKING:
     from src.agents.slow_path.invoker import ToolInvoker
 
-# Cues that point at documents rather than structured data.
+# Cues that point at documents rather than structured data. Deliberately
+# document-SPECIFIC: generic words like "file" and "uploaded" are excluded
+# because users say "file/data yang aku upload" about tabular datasets too, and
+# forcing those to the document-only branch made "what data have I uploaded?"
+# answer "nothing" for a user whose data is tabular (lives under check_data).
+# A bare inventory question with no specific cue falls through to the
+# helicopter view (both structured + documents) instead.
 _KNOWLEDGE_CUES = (
     "document",
     "docs",
     "doc ",
-    "file",
     "pdf",
     "docx",
     ".txt",
-    "uploaded",
     "knowledge",
     "dokumen",
 )
@@ -50,6 +54,32 @@ _DATA_CUES = (
 )
 
 
+# User-facing fixed strings, localized by reply language (detect_reply_language
+# returns "Indonesian"/"English"). Table headers stay as the tool's technical
+# column ids; only the prose the user reads is translated.
+_STRINGS = {
+    "English": {
+        "no_match": "Nothing registered yet — I don't see any matching sources.",
+        "none": "Nothing registered yet — I don't see any sources or documents.",
+        "structured": "Structured data",
+        "documents": "Documents",
+        "lookup_error": "Sorry, I couldn't look that up: {error}",
+    },
+    "Indonesian": {
+        "no_match": "Belum ada yang terdaftar — aku tidak menemukan sumber data yang cocok.",
+        "none": "Belum ada yang terdaftar — aku tidak menemukan sumber data atau dokumen.",
+        "structured": "Data terstruktur",
+        "documents": "Dokumen",
+        "lookup_error": "Maaf, aku tidak bisa mencarinya: {error}",
+    },
+}
+
+
+def _s(reply_language: str) -> dict[str, str]:
+    """Localized string bundle; defaults to English for an unknown language."""
+    return _STRINGS.get(reply_language, _STRINGS["English"])
+
+
 def _intent(message: str) -> str:
     """Return 'knowledge', 'data', or 'both' (helicopter view) from keyword cues."""
     lowered = message.lower()
@@ -62,10 +92,10 @@ def _intent(message: str) -> str:
     return "both"
 
 
-def render_tool_output(out: ToolOutput) -> str:
+def render_tool_output(out: ToolOutput, reply_language: str = "English") -> str:
     """Render a `check_*` ToolOutput table into a markdown string, or '' if empty."""
     if out.kind == "error":
-        return f"Sorry, I couldn't look that up: {out.error}"
+        return _s(reply_language)["lookup_error"].format(error=out.error)
     columns = out.columns or []
     rows = out.rows or []
     if not rows:
@@ -106,52 +136,62 @@ def _matched_source_ids(message: str, inventory: ToolOutput) -> list[str]:
     return matched
 
 
-def _render_helicopter(data_out: ToolOutput, knowledge_out: ToolOutput) -> str:
+def _render_helicopter(
+    data_out: ToolOutput, knowledge_out: ToolOutput, reply_language: str = "English"
+) -> str:
     """Stitch structured + document inventory into one helicopter-view reply."""
+    strings = _s(reply_language)
     parts: list[str] = []
 
-    data_table = render_tool_output(data_out)
+    data_table = render_tool_output(data_out, reply_language)
     if data_table:
-        parts.append(f"**Data terstruktur**\n{data_table}")
+        parts.append(f"**{strings['structured']}**\n{data_table}")
 
-    knowledge_table = render_tool_output(knowledge_out)
+    knowledge_table = render_tool_output(knowledge_out, reply_language)
     if knowledge_table:
-        parts.append(f"**Dokumen**\n{knowledge_table}")
+        parts.append(f"**{strings['documents']}**\n{knowledge_table}")
 
     if not parts:
-        return "Nothing registered yet — I don't see any sources or documents."
+        return strings["none"]
 
     return "\n\n".join(parts)
 
 
-async def run_check(message: str, invoker: ToolInvoker) -> str:
-    """Route to check_data, check_knowledge, or both (helicopter view) based on cues."""
+async def run_check(
+    message: str, invoker: ToolInvoker, reply_language: str = "English"
+) -> str:
+    """Route to check_data, check_knowledge, or both (helicopter view) based on cues.
+
+    `reply_language` ("Indonesian"/"English", from `detect_reply_language`)
+    localizes the fixed prose so this deterministic path answers in the user's
+    language like the LLM paths do.
+    """
     intent = _intent(message)
 
-    _no_match = "Nothing registered yet — I don't see any matching sources."
+    _no_match = _s(reply_language)["no_match"]
 
     if intent == "knowledge":
         out = await invoker.invoke("check_knowledge", {})
-        return render_tool_output(out) or _no_match
+        return render_tool_output(out, reply_language) or _no_match
 
     if intent == "data":
         inventory = await invoker.invoke("check_data", {})
         if inventory.kind == "error":
-            return render_tool_output(inventory)
+            return render_tool_output(inventory, reply_language)
         # Drill down to the schema of each source the user named; if they named
         # none, return the source listing.
         source_ids = _matched_source_ids(message, inventory)
         if not source_ids:
-            return render_tool_output(inventory) or _no_match
+            return render_tool_output(inventory, reply_language) or _no_match
         schemas = await asyncio.gather(
             *(invoker.invoke("check_data", {"source_id": sid}) for sid in source_ids)
         )
         if len(schemas) == 1:
-            return render_tool_output(schemas[0]) or _no_match
+            return render_tool_output(schemas[0], reply_language) or _no_match
         # Multiple named sources → one labelled section per source.
         sections: list[str] = []
         for out in schemas:
-            table = render_tool_output(out)
+            table = render_tool_output(out, reply_language)
             if table:
                 label = (out.meta or {}).get("source_name") or "source"
                 sections.append(f"**{label}**\n{table}")
@@ -162,4 +202,4 @@ async def run_check(message: str, invoker: ToolInvoker) -> str:
         invoker.invoke("check_data", {}),
         invoker.invoke("check_knowledge", {}),
     )
-    return _render_helicopter(data_out, knowledge_out)
+    return _render_helicopter(data_out, knowledge_out, reply_language)