check: table-level column drill + drop misleading "name a table" hint

check could only drill to the SOURCE level: "what columns are in badactor" (a
table in a multi-table DB) returned the whole-DB table list and ignored the
named table. And a >3-table DB rendered a "Name a table to see its columns"
hint that nothing honored — check is stateless, so the follow-up (e.g. bare
"pareto") is re-classified by the intent router (and "pareto" reads as a Pareto
analysis) into structured_flow, giving an analytical answer instead of columns.

- _filter_to_named_tables narrows drilled schemas to the table(s) named in the
message (whole-word match), dropping sources with none of them, so
"columns in <table>" answers with that table's columns — even for a DB that
would otherwise be summarised.
- Remove the "Name a table..." hint (db_hint) that promised a follow-up the
handler can't reliably serve.
- Factor the whole-word matcher into _name_in_message, reused for source + tables.

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

src/agents/handlers/check.py

@@ -278,6 +278,18 @@ async def _fetch_db_tables(
     }
 
 
+def _name_in_message(name: str, message: str) -> bool:
+    """Whole-word, case-insensitive match of `name` in `message`.
+
+    `\\b` treats `_` as a word char, so "sales" won't hit "sales_archive" and the
+    short table name "pa" won't hit "pareto" — the same rule used for source names,
+    reused here for table names.
+    """
+    return bool(name) and (
+        re.search(rf"\b{re.escape(name)}\b", message, re.IGNORECASE) is not None
+    )
+
+
 def _matched_source_ids(message: str, inventory: ToolOutput) -> list[str]:
     """All source_ids whose name appears as a whole word in the message.
 
@@ -285,9 +297,9 @@ def _matched_source_ids(message: str, inventory: ToolOutput) -> list[str]:
     the tool needs exact `source_id`s. We resolve them against the inventory
     rows (kind="table", columns include "source_id" + "name") instead of an LLM
     — a cheap match against catalog metadata already in hand. Whole-word match
-    (`\\b`) avoids nuisance hits ("orders" inside "reorders") and treats `_` as
-    part of the word, so "sales" won't pick up "sales_archive". Multiple named
-    sources all match, so the caller can show each schema.
+    avoids nuisance hits ("orders" inside "reorders") and treats `_` as part of
+    the word, so "sales" won't pick up "sales_archive". Multiple named sources all
+    match, so the caller can show each schema.
     """
     if inventory.kind != "table" or not inventory.rows:
         return []
@@ -301,7 +313,7 @@ def _matched_source_ids(message: str, inventory: ToolOutput) -> list[str]:
     matched: list[str] = []
     for row in inventory.rows:
         name = str(row[name_idx])
-        if name and re.search(rf"\b{re.escape(name)}\b", message, re.IGNORECASE):
+        if _name_in_message(name, message):
             matched.append(str(row[id_idx]))
     return matched
 
@@ -370,7 +382,6 @@ _SCHEMA_STR = {
         "yes": "Yes", "no": "—",
         "db_tables": "{name} has {n} tables:",
         "db_item": "- {table} ({cols} columns{rows})",
-        "db_hint": "Name a table to see its columns.",
     },
     "Indonesian": {
         "lead": "Berikut kolom dan tipe data di {n} sumber yang kamu punya:",
@@ -383,7 +394,6 @@ _SCHEMA_STR = {
         "yes": "Ya", "no": "—",
         "db_tables": "{name} punya {n} tabel:",
         "db_item": "- {table} ({cols} kolom{rows})",
-        "db_hint": "Sebut nama tabelnya untuk lihat kolomnya.",
     },
 }
 
@@ -542,7 +552,6 @@ def _render_schema_source(out: ToolOutput, reply_language: str) -> str:
             lines.append(
                 sc["db_item"].format(table=tname, cols=len(tcols), rows=_rows_suffix(rc))
             )
-        lines.append(sc["db_hint"])
         return "\n".join(lines)
 
     parts: list[str] = []
@@ -580,6 +589,41 @@ def _render_schemas(schemas: list[ToolOutput], reply_language: str) -> str:
     return lead + "\n\n" + "\n\n".join(blocks)
 
 
+def _filter_to_named_tables(
+    schemas: list[ToolOutput], message: str
+) -> list[ToolOutput] | None:
+    """Narrow drilled schemas to the specific table(s) named in the message.
+
+    Lets "what columns are in badactor" answer with badactor's columns instead of
+    the whole-DB table list. When the message names table(s) present in a source,
+    that source is narrowed to just those tables; sources with none of the named
+    tables are dropped, so a table-specific question doesn't dump every other
+    source's schema. Returns None when the message names no table at all, so the
+    caller keeps the default whole-source view. Table names are matched
+    whole-word (same rule as source names) against each drilled schema's rows.
+    """
+    narrowed: list[ToolOutput] = []
+    any_named = False
+    for out in schemas:
+        if out.kind != "table":
+            continue
+        cols = out.columns or []
+        if "table_name" not in cols:
+            continue
+        tn_idx = cols.index("table_name")
+        keep = {
+            str(r[tn_idx])
+            for r in (out.rows or [])
+            if _name_in_message(str(r[tn_idx]), message)
+        }
+        if not keep:
+            continue
+        any_named = True
+        rows = [r for r in (out.rows or []) if str(r[tn_idx]) in keep]
+        narrowed.append(out.model_copy(update={"rows": rows}))
+    return narrowed if any_named else None
+
+
 async def run_check(
     message: str, invoker: ToolInvoker, reply_language: str = "English"
 ) -> str:
@@ -618,7 +662,12 @@ async def run_check(
         schemas = await asyncio.gather(
             *(invoker.invoke("check_data", {"source_id": sid}) for sid in ids)
         )
-        return _render_schemas(schemas, reply_language) or _no_match
+        # Table-level drill: if the message names specific table(s) — e.g. "what
+        # columns are in badactor" — narrow to those so we answer with that table's
+        # columns instead of a whole-DB table list. Falls back to the full view when
+        # no table is named.
+        narrowed = _filter_to_named_tables(schemas, message)
+        return _render_schemas(narrowed or schemas, reply_language) or _no_match
 
     if intent == "data":
         inventory = await invoker.invoke("check_data", {})