/fix report: remove record_id hash citations, EDA (for future tool) change to data source, transform to mdx-safe

src/agents/report/generator.py

@@ -25,6 +25,7 @@ from src.middlewares.logging import get_logger
 
 from ..slow_path.schemas import AnalysisRecord, TaskSummary
 from .errors import ReportError
+from .readiness import has_successful_analysis
 from .schemas import (
     AnalysisReport,
     AttributedNote,
@@ -46,6 +47,13 @@ _STAGE_LABELS: list[tuple[str, str]] = [
     ("evaluation", "Evaluation"),
 ]
 
+# Friendly labels for the catalog's internal source_type enum, shown in Data Sources.
+_SOURCE_TYPE_LABELS: dict[str, str] = {
+    "schema": "Database",
+    "tabular": "Tabular file",
+    "unstructured": "Documents",
+}
+
 _PROMPT_PATH = (
     Path(__file__).resolve().parent.parent.parent / "config" / "prompts" / "report_summary.md"
 )
@@ -182,6 +190,23 @@ def _build_human_content(
     return "\n\n".join(sections)
 
 
+def _mdx_escape(text: str) -> str:
+    """Escape Markdown/MDX syntax characters in a dynamic value.
+
+    Applied only to values authored outside the renderer (LLM findings/caveats,
+    user objective/questions, catalog source & table names, tool names) so that
+    identifiers like ``XL_S_129`` don't italicize and stray ``<``/``{`` don't break
+    MDX compilation. NOT applied to the executive summary (its prompt allows light
+    inline emphasis) nor to the structural markdown the renderer emits itself.
+    """
+    if not text:
+        return text
+    out = text.replace("\\", "\\\\")
+    for ch in ("<", "{", "|", "_", "*"):
+        out = out.replace(ch, "\\" + ch)
+    return out
+
+
 def _render_markdown(report: AnalysisReport) -> str:
     # Version is deliberately NOT in the markdown — it is assigned by the store
     # after rendering and lives in the structured `version` field / API metadata.
@@ -196,11 +221,13 @@ def _render_markdown(report: AnalysisReport) -> str:
 
     ps = report.problem_statement
     if ps.objective:
-        parts.append("## Objective\n" + ps.objective)
+        parts.append("## Objective\n" + _mdx_escape(ps.objective))
     if ps.business_questions:
         parts.append(
             "## Business Questions\n"
-            + "\n".join(f"{i}. {q}" for i, q in enumerate(ps.business_questions, 1))
+            + "\n".join(
+                f"{i}. {_mdx_escape(q)}" for i, q in enumerate(ps.business_questions, 1)
+            )
         )
 
     if report.executive_summary:
@@ -209,32 +236,33 @@ def _render_markdown(report: AnalysisReport) -> str:
     if report.findings:
         lines = ["## Key Findings"]
         for i, f in enumerate(report.findings, 1):
-            cite = f" *({', '.join(f.record_ids)})*" if f.record_ids else ""
-            lines.append(f"{i}. {f.text}{cite}")
+            lines.append(f"{i}. {_mdx_escape(f.text)}")
         parts.append("\n".join(lines))
 
+    # ## EDA — reserved for future exploratory visuals; charts wrapped as MDX
+    # components will render here. Emitted only when it has content; omitted today.
+
     if report.data_sources:
-        lines = ["## EDA", "| source | type | detail |", "|---|---|---|"]
+        lines = ["## Data Sources", "| source | type | detail |", "|---|---|---|"]
         for ds in report.data_sources:
             d = ds.detail
             bits = []
             if d.get("tables"):
-                bits.append("tables: " + ", ".join(d["tables"]))
-            if d.get("row_count"):
-                bits.append(f"{d['row_count']} rows")
+                bits.append("tables: " + ", ".join(_mdx_escape(t) for t in d["tables"]))
             if d.get("columns"):
-                bits.append(f"{len(d['columns'])} cols")
-            lines.append(f"| {ds.name} | {ds.source_type or '—'} | {' · '.join(bits) or '—'} |")
+                bits.append(f"{len(d['columns'])} columns")
+            type_label = _SOURCE_TYPE_LABELS.get(ds.source_type, ds.source_type or "—")
+            lines.append(
+                f"| {_mdx_escape(ds.name)} | {type_label} | {' · '.join(bits) or '—'} |"
+            )
         parts.append("\n".join(lines))
 
     if report.caveats or report.open_questions:
         lines = ["## Notes & Limitations"]
         for n in report.caveats:
-            cite = f" *({', '.join(n.record_ids)})*" if n.record_ids else ""
-            lines.append(f"- {n.text}{cite}")
+            lines.append(f"- {_mdx_escape(n.text)}")
         for n in report.open_questions:
-            cite = f" *({', '.join(n.record_ids)})*" if n.record_ids else ""
-            lines.append(f"- Open: {n.text}{cite}")
+            lines.append(f"- Open: {_mdx_escape(n.text)}")
         parts.append("\n".join(lines))
 
     if report.method_steps:
@@ -244,7 +272,8 @@ def _render_markdown(report: AnalysisReport) -> str:
             if not steps:
                 continue
             rendered = "; ".join(
-                f"{', '.join(s.tools_used) or '—'} ({s.status})" for s in steps
+                f"{', '.join(_mdx_escape(t) for t in s.tools_used) or '—'} ({s.status})"
+                for s in steps
             )
             lines.append(f"**{label}** — {rendered}")
         parts.append("\n".join(lines))
@@ -299,6 +328,10 @@ class ReportGenerator:
         user_name: str | None = None,
     ) -> AnalysisReport:
         records = await self._ensure_record_store().list_for_analysis(analysis_id)
+        # The report reflects only substantive runs — those with a successful
+        # analysis step (the same set the report floor validates). Fully-failed runs
+        # are dropped so their failure narration can't contradict the real findings.
+        records = [r for r in records if has_successful_analysis(r)]
         if not records:
             raise ReportError(f"no analyses recorded for {analysis_id!r} yet")
 

src/agents/report/readiness.py

@@ -71,7 +71,7 @@ def _is_newer(a: datetime, b: datetime) -> bool:
     return a > b
 
 
-def _has_successful_analysis(record) -> bool:
+def has_successful_analysis(record) -> bool:
     """True if the record has at least one *analysis* task that succeeded.
 
     A failed run still writes findings (narrating the failure) and its data-access
@@ -113,7 +113,7 @@ async def report_floor(
         try:
             store = record_store or _default_record_store()
             records = await store.list_for_analysis(analysis_id)
-            substantive = [r for r in records if _has_successful_analysis(r)]
+            substantive = [r for r in records if has_successful_analysis(r)]
         except Exception as exc:  # noqa: BLE001 — never-throw; fail closed to not-ready
             logger.warning(
                 "report_floor: record store read failed — not ready",