/fix help and tools analyze

API_CONTRACT_BE_PYTHON.md

@@ -143,24 +143,22 @@ Response `200`:
 
 ```json
 {
-  "count": 2,
+  "count": 1,
   "tools": [
     {
       "command": "/help",
       "name": "help",
       "type": "skill",
       "description": "Show what the assistant can do and guide your next step."
-    },
-    {
-      "command": "/report",
-      "name": "report",
-      "type": "skill",
-      "description": "Generate a versioned analysis report with background, EDA, key findings, and insights."
     }
   ]
 }
 ```
 
+> The catalog is `/help` only (KM-711). `/report` was removed as a slash command —
+> report generation is a right-side **Generate** button, not a `/` command. The report
+> HTTP endpoint (`POST /api/v1/tools/report`) still exists; the button calls it.
+
 Tool item shape:
 
 ```json

API_ENDPOINTS_RESTRUCTURE.md

@@ -107,19 +107,18 @@ Static, deterministic, safe for Go to cache. (Was `GET /api/v1/tools`.)
 
 ```json
 {
-  "count": 2,
+  "count": 1,
   "tools": [
     { "command": "/help",   "name": "help",   "type": "skill",
-      "description": "Show what the assistant can do and guide your next step." },
-    { "command": "/report", "name": "report", "type": "skill",
-      "description": "Generate a versioned analysis report (background, EDA, key findings, insights)." }
+      "description": "Show what the assistant can do and guide your next step." }
   ]
 }
 ```
 
 `CommandResponse = { command, name, type, description }`, `type ∈ {skill, analytics, data_access}`.
-Catalog is `/help` + `/report` only; the `analyze_*` / `check_*` / `retrieve_*` and retired
-`/problem-statement` entries are commented out (kept for restorability), not deleted.
+Catalog is `/help` only; the `/report`, `analyze_*` / `check_*` / `retrieve_*`, and retired
+`/problem-statement` entries are commented out (kept for restorability), not deleted. `/report`
+was retired as a slash command (KM-711) — report generation is the right-side button only.
 
 **FE behavior:** the `/` slash menu surfaces **`/help` only**. **Report is a right-side button, not
 a slash command** (it fires only when an analysis is finished — saves tokens).

eval/help/help_dataset.json

@@ -89,8 +89,11 @@
       "report_ready": { "ready": true, "missing": [] },
       "history": [{ "role": "human", "content": "what should I do next?" }],
       "message": null,
-      "asserts": [{ "type": "must_contain_any", "patterns": ["/report", "report"] }],
-      "note": "MIRRORS help.md example help_ex_guard_ready. Enough analysis done — SHOULD nudge toward the report (mention /report or the report option)."
+      "asserts": [
+        { "type": "must_contain_any", "patterns": ["Generate", "generate", "report"] },
+        { "type": "must_not_contain_any", "patterns": ["/report"] }
+      ],
+      "note": "MIRRORS help.md example help_ex_guard_ready. Enough analysis done — SHOULD nudge toward the report by pointing at the Generate button; must NOT offer /report (removed in v6)."
     },
     {
       "id": "guard_03", "group": "report_guard", "carried_over": false, "manual_review": false,
@@ -108,10 +111,11 @@
       "history": [{ "role": "human", "content": "selanjutnya aku ngapain?" }],
       "message": null,
       "asserts": [
-        { "type": "must_contain_any", "patterns": ["/report", "laporan", "report"] },
+        { "type": "must_contain_any", "patterns": ["Generate", "generate", "laporan", "report"] },
+        { "type": "must_not_contain_any", "patterns": ["/report"] },
         { "type": "language_match", "expected": "Indonesian" }
       ],
-      "note": "Ready + Indonesian conversation — should nudge toward the report AND stay in Indonesian (two rules at once)."
+      "note": "Ready + Indonesian conversation — should nudge toward the report (Generate button) AND stay in Indonesian; must NOT offer /report (removed in v6)."
     },
     {
       "id": "guard_05", "group": "report_guard", "carried_over": false, "manual_review": false,

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/planner/validator.py

@@ -142,6 +142,23 @@ class PlannerValidator:
                                 "use analyze_descriptive instead."
                             )
 
+                    # Check 8d — group_by keys must be plain column-name strings. A
+                    # derived grouping (a CASE/binning expression emitted as a dict)
+                    # is unhashable and crashes df.groupby at execution ("unhashable
+                    # type: 'dict'"). Reject it here so the planner is re-prompted;
+                    # bucketing a numeric column into ranges belongs to
+                    # analyze_segment, not smuggled through analyze_aggregate.
+                    group_by = call.args.get("group_by")
+                    if isinstance(group_by, list):
+                        bad_keys = [g for g in group_by if not isinstance(g, str)]
+                        if bad_keys:
+                            raise PlannerValidationError(
+                                f"task {task.id}: analyze_aggregate group_by must be "
+                                f"column names (strings); got non-string entr(ies) "
+                                f"{bad_keys}. Derived groupings (CASE/binning) are not "
+                                "supported — group by an existing column."
+                            )
+
                 # Check 3 — concrete source_id args must exist in the catalog.
                 src = call.args.get("source_id")
                 if isinstance(src, str) and not _is_placeholder(src):
@@ -212,23 +229,45 @@ class PlannerValidator:
     def _validate_data_source(
         task_id: str, call, tasks_by_id: dict, registry: ToolRegistry
     ) -> None:
-        """A `data` placeholder must reference a data-producing task, not a
-        metadata (check_data/check_knowledge) or documents (retrieve_knowledge) one.
-
-        Those pass the structural checks (check_* also returns kind="table"), but
-        their rows are catalog schema, so a downstream analyze_* fails to find the
-        requested columns. Resolving points at the referenced task's representative
-        output — its last tool call (matches TaskRunner's `outputs[-1]`).
+        """The `data`/`data_right` handoff (Pattern A) must be a '${t<id>}'
+        placeholder pointing at an upstream data-producing task.
+
+        Two failure modes are rejected here:
+
+        1. The arg is present but is NOT a placeholder — e.g. the planner inlined a
+           {table_id, source_id} table reference (or any literal) instead of
+           chaining a retrieve_data output. analyze_* tools never self-fetch by
+           source_id; they only consume an already-retrieved table, so such a plan
+           can only blow up at execution ("unsupported 'data' type: dict"). Reject
+           it here so the retry loop re-prompts the planner to add a retrieve_data
+           task and pass its placeholder.
+        2. The placeholder resolves to a metadata (check_data/check_knowledge) or
+           documents (retrieve_knowledge) task. Those pass the structural checks
+           (check_* also returns kind="table"), but their rows are catalog schema,
+           so a downstream analyze_* fails to find the requested columns. Resolving
+           points at the referenced task's representative output — its last tool
+           call (matches TaskRunner's `outputs[-1]`).
+
+        `data_right` is analyze_merge's second table input (KM-703) — same Pattern A
+        handoff, so it gets the same guard. An arg that is absent is left to Check 8a
+        (required-arg presence).
         """
-        # `data_right` is analyze_merge's second table input (KM-703) — same
-        # Pattern A handoff, so it gets the same guard.
         for arg_name in ("data", "data_right"):
-            data_arg = call.args.get(arg_name)
-            if not isinstance(data_arg, str):
-                continue
-            match = PLACEHOLDER_RE.fullmatch(data_arg.strip())
-            if not match:
+            if arg_name not in call.args:
                 continue
+            data_arg = call.args[arg_name]
+            match = (
+                PLACEHOLDER_RE.fullmatch(data_arg.strip())
+                if isinstance(data_arg, str)
+                else None
+            )
+            if match is None:
+                raise PlannerValidationError(
+                    f"task {task_id}: tool {call.tool!r} arg {arg_name!r} must be a "
+                    f"'${{t<id>}}' placeholder referencing a retrieve_data output "
+                    f"(Pattern A), got {data_arg!r}. analyze_* tools do not fetch data "
+                    "themselves — add a retrieve_data task and pass its output."
+                )
             ref_task = tasks_by_id.get(match.group(1))
             if ref_task is None or not ref_task.tool_calls:
                 continue  # a dangling placeholder is reported by the DAG check

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/api/v1/tools.py

@@ -4,8 +4,10 @@ Exposes the agent's user-invocable slash-command catalog so the Golang backend
 can cache it and the frontend can render its "/" command menu WITHOUT calling the
 AI agent for every list (Golang GETs + caches `list_tools`).
 
-Scope (2026-06-24, KM-674): the FE slash-command catalog is now just the two
-FE-callable skills — `/help` and `/report`. Naming: verb-first, kebab-case, `/`
+Scope (2026-07-09): the FE slash-command catalog is now just `/help`. `/report` was
+removed — report generation is button-only (the Generate button in the Report panel);
+typing `/report` no longer creates a report (the router sends it to `check`), so
+surfacing it as a slash command would mislead. Naming: verb-first, kebab-case, `/`
 prefix; each command maps 1:1 to a real internal tool/intent `name` (the dispatch
 key).
 
@@ -49,8 +51,12 @@ class ListToolsResponse(BaseModel):
 # Keep `command` in Harry's convention (verb-first, kebab-case, `/`); `name` is the
 # internal route/tool name used by the orchestrator.
 #
-# 2026-06-24 (KM-674 batch): the FE-callable skills are ONLY /help + /report. The rest
-# below are COMMENTED OUT — NOT deleted — on purpose:
+# 2026-07-09: the only FE-callable slash skill is now /help. The rest below are
+# COMMENTED OUT — NOT deleted — on purpose:
+#   - /report is retired as a slash command: report generation is button-only (Generate
+#     button in the Report panel). Typing /report no longer generates a report (the router
+#     routes it to `check`), so exposing it here would misdirect users. The report HTTP
+#     endpoint (POST /api/v1/tools/report in report.py) stays — the Generate button calls it.
 #   - /problem-statement is retired (objective + business_questions now live in the
 #     New-Analysis form, not a slash skill).
 #   - check_data / check_knowledge stay available but are served by Golang, not exposed
@@ -65,13 +71,13 @@ _COMMAND_CATALOG: list[CommandResponse] = [
         type="skill",
         description="Show what the assistant can do and guide your next step.",
     ),
-    CommandResponse(
-        command="/report",
-        name="report",
-        type="skill",
-        description="Generate a versioned analysis report (background, EDA, "
-        "key findings, insights).",
-    ),
+    # CommandResponse(
+    #     command="/report",
+    #     name="report",
+    #     type="skill",
+    #     description="Generate a versioned analysis report (background, EDA, "
+    #     "key findings, insights).",
+    # ),
     # CommandResponse(
     #     command="/problem-statement",
     #     name="problem_statement",

src/config/prompts/help.md

@@ -1,4 +1,10 @@
-<!-- help.md · v5 · Help skill prompt.
+<!-- help.md · v6 · Help skill prompt.
+     v6 (2026-07-09): report trigger changed — the `/report` skill and the old report button
+     are GONE. A report is now generated ONE way only: the **Generate** button on the Report
+     panel (single source of truth). Help must no longer tell users to run `/report` or "use
+     the report skill"; it points them to the Generate button — anchored on the button LABEL,
+     not an exact corner/position (layout isn't final). Updated Section C, the How-to phrasing
+     note, and the help_ex_guard_ready example accordingly.
      v5 (2026-07-07): added the "Capability boundary" section — Help now only suggests
      analyses the live tools can actually deliver (descriptive, group-by, correlation, trend)
      and must NOT suggest significance tests, forecasting/modeling, causal claims, clustering/
@@ -72,9 +78,11 @@ recommend the specific next questions that would fill those gaps (phrase them as
 the user can ask), still anchored to the objective and business questions.
 
 ### C. `report_ready.ready == true` → nudge toward the report
-There's enough to report. Encourage them to generate it. Report can be triggered **two ways**:
-the **`/report`** skill **or** the report button — mention both so it feels natural.
-Do not over-promise the report's depth.
+There's enough to report. Encourage them to generate it. A report is generated **one way**:
+by clicking the **Generate** button on the Report panel. Anchor on the button's label
+(**Generate**) — that's the unambiguous, layout-stable cue — rather than an exact
+position/corner. There is no `/report` skill or manual command anymore — do **not** mention
+`/report`. Do not over-promise the report's depth.
 
 > Edge case: if `objective` looks empty (unusual — it's required at onboarding), don't push a
 > chat skill to fix it; gently suggest they set the objective + business questions in the New
@@ -111,8 +119,9 @@ the gap — rather than promising the unsupported analysis.
 
 ## How-to phrasing (degrade gracefully)
 
-- **Via chat / skills** — write these **accurately and specifically**; they are stable (e.g. "type your question in the chat", "run `/report`").
-- **Via the UI (buttons/menus)** — the frontend isn't final yet. Describe UI steps **generically** ("use the Generate Report option") rather than naming exact buttons/positions you're unsure of. Prefer the chat/skill path when unsure. *(A later version of this file will fill in the real UI steps.)*
+- **Via chat / skills** — write these **accurately and specifically**; they are stable (e.g. "type your question in the chat"). Note: report is **not** a chat skill — never write `/report`.
+- **Generating a report** — the only way is the **Generate** button on the Report panel. Name the button by its label; don't pin an exact corner/position (the layout isn't final). Don't offer `/report` or a "report skill" as an alternative.
+- **Other UI steps (buttons/menus)** — the rest of the frontend isn't final yet. Describe those steps **generically** rather than naming exact buttons/positions you're unsure of.
 - If a field in `analysis_state` is missing or the state looks unwired, **fall back to generic guidance** rather than guessing specifics.
 
 ## Tone
@@ -158,6 +167,6 @@ State: report_ready.ready=false, missing=["a new analysis since the last report"
 
 <!-- id: help_ex_guard_ready -->
 State: report_ready.ready=true
-→ "You've covered enough to summarize. You can generate your report now — run /report
-   or use the report option to create it."
+→ "You've covered enough to summarize. You can generate your report now — click the
+   Generate button on the Report panel to create it."
 ```

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.

src/tools/analytics/aggregation.py

@@ -27,6 +27,17 @@ class UnsupportedAggregationError(ValueError):
     """Requested aggregation is not in SUPPORTED_AGGS (maps to UNSUPPORTED_AGG)."""
 
 
+class UnsupportedGroupByError(ValueError):
+    """A group_by entry is not a plain column name (maps to UNSUPPORTED_GROUP_BY).
+
+    group_by keys must be column-name strings. A derived grouping — e.g. a CASE /
+    binning expression the planner emits as a dict — is unhashable and would crash
+    `df.groupby` with a bare "unhashable type: 'dict'"; raising here turns it into a
+    clear, actionable error instead. Bucketing a numeric column into ranges belongs
+    to analyze_segment, not analyze_aggregate.
+    """
+
+
 def _clean(value: object) -> object:
     """Convert numpy/pandas scalars to plain Python so the output is JSON-clean.
 
@@ -103,6 +114,17 @@ def analyze_aggregate(
     """
     group_by = group_by or []
 
+    # group_by keys must be plain column names. A non-string entry (e.g. a CASE /
+    # binning dict) is unhashable and would otherwise crash the membership check or
+    # df.groupby with an opaque "unhashable type: 'dict'".
+    non_str = [g for g in group_by if not isinstance(g, str)]
+    if non_str:
+        raise UnsupportedGroupByError(
+            f"group_by entries must be column names (strings); got non-string "
+            f"entr(ies) {non_str}. Derived groupings (e.g. CASE/binning expressions) "
+            "are not supported by analyze_aggregate — group by an existing column."
+        )
+
     # Validate columns first (fail-fast on caller mistakes).
     referenced = list(group_by) + list(aggregations.keys())
     missing = [c for c in referenced if c not in df.columns]

src/tools/analytics/temporal.py

@@ -197,10 +197,15 @@ def analyze_trend(
         )
 
     # Build a clean datetime-indexed series, then resample into periods.
-    s = df[[date_column, value_column]].copy()
-    s[date_column] = _parse_date_column(df, date_column)
-    s = s.dropna(subset=[date_column]).set_index(date_column).sort_index()
-    resampled = s[value_column].resample(FREQ_MAP[freq]).agg(agg)
+    # date_column may equal value_column — e.g. "count of events per month",
+    # where the value being aggregated IS the date itself. Selecting
+    # df[[col, col]] then yields a duplicate-named 2-col frame whose set_index
+    # key is 2-D ("Index data must be 1-dimensional"), so build the date and
+    # value series positionally instead of via column selection.
+    dates = pd.Series(_parse_date_column(df, date_column).to_numpy(), name="_date")
+    values = pd.Series(df[value_column].to_numpy(), name="_value")
+    s = pd.concat([dates, values], axis=1).dropna(subset=["_date"]).set_index("_date")
+    resampled = s["_value"].sort_index().resample(FREQ_MAP[freq]).agg(agg)
 
     points = [
         {"period": _period_label(ts, freq), "value": _clean(val)}

src/tools/invoker.py

@@ -163,6 +163,18 @@ def _materialize(data: Any) -> tuple[pd.DataFrame, None] | tuple[None, str]:
         df = pd.DataFrame(data.get("rows") or [], columns=data["columns"])
         return _normalize_numeric(df), None
 
+    # A {table_id/source_id} dict is a raw catalog reference the planner inlined
+    # instead of chaining a retrieve_data output (Pattern A). analyze_* tools never
+    # self-fetch, so give an actionable message rather than the opaque type name.
+    # The planner validator should reject this upstream (Check 9); this is the
+    # defensive net if a bad plan still reaches execution.
+    if isinstance(data, dict) and ("table_id" in data or "source_id" in data):
+        return None, (
+            "'data' is a table reference (table_id/source_id), not a retrieved "
+            "table — analyze_* consumes the output of retrieve_data, it does not "
+            "fetch data by id (Pattern A)"
+        )
+
     return None, f"unsupported 'data' type: {type(data).__name__}"