[KM-715] report: embed charts as plotly EDA fences; render_chart counts toward the floor

FE fence hook verified by the lead, so the deferred embedding lands as sketched
in SPINE_V2_PLAN's decision log: _collect_charts copies dataeyond.chart.v1
envelopes verbatim (INV-4, <=3/record) from results_snapshot into
AnalysisReport.charts; _render_markdown emits them in the reserved ## EDA
section as ```plotly fences (content = the FULL envelope, pretty-printed — the
FE hook's verified shape; bare {data,layout} does not render).
has_successful_analysis now counts a successful render_chart, so a chart-only
session is substantive and satisfies the report floor (deliberate extension,
Rifqi-approved). Verified live: report v4 on analysis 7be50846 embeds 3 charts,
FE-rendered OK. Suite 381 passed, 7 skipped (+5 chart-embed tests).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/agents/report/generator.py

@@ -13,6 +13,7 @@ Chain construction mirrors `agents/slow_path/assembler.py`.
 
 from __future__ import annotations
 
+import json
 import re
 from datetime import UTC, datetime
 from pathlib import Path
@@ -201,6 +202,33 @@ def _collect_evidence(records: list[AnalysisRecord]) -> dict[str, list[EvidenceT
     return out
 
 
+_CHARTS_MAX_PER_RECORD = 3  # mirrors _EVIDENCE_MAX_TABLES
+
+
+def _collect_charts(records: list[AnalysisRecord]) -> dict[str, list[dict]]:
+    """Copy chart envelopes out of each record's `results_snapshot` (INV-4).
+
+    `render_chart` outputs only — the full `dataeyond.chart.v1` envelope, verbatim
+    (the snapshot trimmer never touches chart-kind outputs, so the spec is whole).
+    Rendered as ```plotly fenced blocks in the markdown EDA section.
+    """
+    out: dict[str, list[dict]] = {}
+    for rec in records:
+        charts: list[dict] = []
+        for result in rec.results_snapshot.values():
+            for output in result.outputs:
+                if len(charts) >= _CHARTS_MAX_PER_RECORD:
+                    break
+                if output.kind != "chart" or not isinstance(output.value, dict):
+                    continue
+                if not isinstance(output.value.get("plotly"), dict):
+                    continue
+                charts.append(output.value)
+        if charts:
+            out[rec.record_id] = charts
+    return out
+
+
 def _unresolved_note(rec: AnalysisRecord) -> AttributedNote:
     # Goal + the record's own first caveat as the "why" — both Assembler-authored,
     # nothing new is synthesized here.
@@ -446,8 +474,26 @@ def _render_markdown(report: AnalysisReport) -> str:
             blocks.append("\n".join(block))
         parts.append("\n\n".join(blocks))
 
-    # ## EDA — reserved for future exploratory visuals; charts wrapped as MDX
-    # components will render here. Emitted only when it has content; omitted today.
+    # ## EDA — charts (W2, 2026-07-14). Each chart a `render_chart` task produced
+    # is emitted as a ```plotly fenced block the FE's fence hook renders with
+    # plotly.js. Fence content is the FULL dataeyond.chart.v1 envelope, verbatim
+    # (INV-4) and pretty-printed — the shape the FE hook parses (verified against
+    # the FE 2026-07-14; it reads spec.plotly internally). Section omitted when no
+    # record produced a chart.
+    if report.charts:
+        lines = ["## EDA"]
+        ordered_rids = [rid for rid in report.record_ids if rid in report.charts]
+        ordered_rids += [rid for rid in report.charts if rid not in ordered_rids]
+        for rid in ordered_rids:
+            for envelope in report.charts[rid]:
+                caption = envelope.get("title") or report.record_goals.get(rid) or "Chart"
+                lines.append(f"**{_mdx_escape(str(caption))}**")
+                lines.append("")
+                lines.append("```plotly")
+                lines.append(json.dumps(envelope, ensure_ascii=False, indent=2))
+                lines.append("```")
+                lines.append("")
+        parts.append("\n".join(lines).rstrip())
 
     if report.data_sources:
         lines = ["## Data Sources", "| source | type | detail |", "|---|---|---|"]
@@ -607,6 +653,7 @@ class ReportGenerator:
             unresolved=[_unresolved_note(r) for r in unresolved_records],
             excluded=[_excluded_note(r) for r in excluded],
             evidence_tables=_collect_evidence(records),
+            charts=_collect_charts(records),
             data_sources=data_sources,
             method_steps=method_steps,
         )

src/agents/report/readiness.py

@@ -72,15 +72,18 @@ def _is_newer(a: datetime, b: datetime) -> bool:
 
 
 def has_successful_analysis(record) -> bool:
-    """True if the record has at least one *analysis* task that succeeded.
+    """True if the record has at least one *result-producing* task that succeeded.
 
     A failed run still writes findings (narrating the failure) and its data-access
     tasks (check_/retrieve_) succeed, so we can't key on findings or on "any task
-    succeeded". An analysis tool (analyze_*) completing is the real "we produced a
-    result" signal.
+    succeeded". A completed analysis tool (analyze_*) — or, since W2 charts
+    (2026-07-14), a completed `render_chart`, whose viz-tail upstream necessarily
+    computed the numbers being charted — is the real "we produced a result"
+    signal. A chart-only session therefore satisfies the report floor.
     """
     return any(
-        t.status == "success" and any(tool.startswith("analyze") for tool in t.tools_used)
+        t.status == "success"
+        and any(tool.startswith("analyze") or tool == "render_chart" for tool in t.tools_used)
         for t in record.tasks_run
     )
 

src/agents/report/schemas.py

@@ -146,6 +146,10 @@ class AnalysisReport(BaseModel):
     excluded: list[AttributedNote] = Field(default_factory=list)
     # record_id -> small result tables copied from that record's results_snapshot.
     evidence_tables: dict[str, list[EvidenceTable]] = Field(default_factory=dict)
+    # record_id -> dataeyond.chart.v1 envelopes, copied verbatim from that record's
+    # results_snapshot (W2 charts, 2026-07-14). The markdown renders each as a
+    # ```plotly fenced block in the EDA section; the FE's fence hook draws it.
+    charts: dict[str, list[dict]] = Field(default_factory=dict)
     data_sources: list[DataSourceRef] = Field(default_factory=list)
     method_steps: list[TaskSummary] = Field(default_factory=list)  # carries `stage`
     rendered_markdown: str = ""