fix(planner): reply-language for infeasible_reason + answer-only-asked rule

Two prompt-layer fixes for answer quality:

- Language consistency: the planner authored infeasible_reason in English while
the data-gap wrapper (refusals.py) was rendered in the user's language, so an
infeasible answer came back mixed ID+EN. Thread reply_language coordinator ->
PlannerService.plan -> build_planner_prompt and instruct the planner (planner.md)
to write infeasible_reason in the reply language. All params optional/backward-
compatible; the prompt section only renders when a language is known.

- Scope creep: the planner added unasked tasks (e.g. an extra count-by-site_type)
because "smallest plan" was only a soft bullet. Promote it to Hard rule #7:
answer ONLY the asked question; a multi-part plan is correct only when the
question itself has multiple parts.

Behavioral (prompt) change, not a deterministic guard — validated for plumbing by
the unit suite; behavioral effect should be checked via eval/ and reviewed with
the planner few-shot owner.

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

src/agents/planner/prompt.py

@@ -95,13 +95,16 @@ def build_planner_prompt(
     query: str,
     constraints: Constraints,
     previous_errors: list[str] | None = None,
+    reply_language: str | None = None,
 ) -> str:
     """Return the human-message content for the planner LLM.
 
     The system prompt (`config/prompts/planner.md`) is loaded separately by
     `PlannerService`. `previous_errors` is the full history of prior validation
     failures (oldest first) so a retry fixes ALL of them at once instead of fixing
-    one and reintroducing an earlier one.
+    one and reintroducing an earlier one. `reply_language` (the pipeline's detected
+    user language) is surfaced so the only user-facing free text the planner emits
+    — `infeasible_reason` — comes back in that language instead of always English.
     """
     sections = [
         f"# Business context\n\n{render_business_context(context)}",
@@ -111,6 +114,13 @@ def build_planner_prompt(
         f"# Examples\n\n{render_examples()}",
         f"# Question\n\n{query}",
     ]
+    if reply_language:
+        sections.append(
+            f"# Reply language\n\n"
+            f"The user writes in {reply_language}. If (and only if) you return an "
+            f"infeasible plan, write `infeasible_reason` in {reply_language} — it is "
+            f"shown to the user verbatim. The plan structure itself is unaffected."
+        )
     if previous_errors:
         joined = "\n".join(f"- {err}" for err in previous_errors)
         sections.append(

src/agents/planner/service.py

@@ -102,6 +102,7 @@ class PlannerService:
         query: str,
         constraints: Constraints,
         callbacks: list | None = None,
+        reply_language: str | None = None,
     ) -> TaskList:
         summary = CatalogSummary.from_catalog(catalog)
         chain = self._ensure_chain()
@@ -109,7 +110,13 @@ class PlannerService:
 
         for attempt in range(1, self._max_retries + 1):
             human_content = build_planner_prompt(
-                context, summary, tools, query, constraints, previous_errors
+                context,
+                summary,
+                tools,
+                query,
+                constraints,
+                previous_errors,
+                reply_language=reply_language,
             )
             # All retry attempts share `callbacks`, so each shows up under the same
             # trace — that is how retry token cost becomes visible.
@@ -176,6 +183,9 @@ async def plan_analysis(
     tools: ToolRegistry,
     query: str,
     constraints: Constraints,
+    reply_language: str | None = None,
 ) -> TaskList:
     """Convenience entry point using the default chain + validator."""
-    return await PlannerService().plan(context, catalog, tools, query, constraints)
+    return await PlannerService().plan(
+        context, catalog, tools, query, constraints, reply_language=reply_language
+    )

src/agents/slow_path/coordinator.py

@@ -55,7 +55,8 @@ class SlowPathCoordinator:
             await progress("Planning the analysis…")
         plan_kw = {"callbacks": planner_callbacks} if planner_callbacks else {}
         task_list = await self._planner.plan(
-            context, catalog, self._registry, query, constraints, **plan_kw
+            context, catalog, self._registry, query, constraints,
+            reply_language=reply_language, **plan_kw
         )
         if task_list.infeasible_reason and not task_list.tasks:
             # Honest data-gap outcome (planner.md "When the catalog cannot

src/config/prompts/planner.md

@@ -27,6 +27,13 @@ only a `TaskList` object that conforms to the provided schema.
    0-1 ratio AS a percentage metric). If no column plausibly holds the measure
    or entity the question asks about, the plan is **infeasible** — see "When the
    catalog cannot answer".
+7. **Answer ONLY the asked question.** Plan the smallest analysis that fully
+   answers what the user actually asked — nothing more. Do NOT add tasks for
+   adjacent, "might be useful", or unasked questions (e.g. an extra breakdown by
+   a category the question never mentioned, or a count the user did not request),
+   even when the data would support them. Extra breadth the user did not ask for
+   is noise, not helpfulness. A multi-part task list is correct ONLY when the
+   question itself has multiple parts (e.g. "trend by region AND what's unusual").
 
 # How to plan
 
@@ -99,6 +106,9 @@ subscription data). For those:
 - Return `tasks: []` and set **`infeasible_reason`**: one short paragraph naming
   (a) what the question needs that no column provides, and (b) the nearest
   analyses the catalog CAN support, so the user knows what to ask instead.
+  Write this paragraph in the user's reply language (see the "Reply language"
+  note in the human message, when present) — it is shown to the user verbatim, so
+  a mismatched language reads as broken.
 - Do NOT emit a plan that maps the question onto semantically unrelated columns
   just because their types fit — a confidently wrong number is worse than an
   honest gap.