@@ -28,7 +28,7 @@
     utc_now,
 )
 from gooddata_eval.core.chat.render import render_answer_text
-from gooddata_eval.core.chat.sse_client import ChatClient
+from gooddata_eval.core.chat.sse_client import ChatClient, ChatError
 from gooddata_eval.core.config import ReasoningEffort
 from gooddata_eval.core.models import (
     AgenticAssertionError,
@@ -667,8 +667,9 @@ class DashboardRunResult:
     timings: PhaseTimings = field(default_factory=PhaseTimings)
     # Why the loop stopped -- see LoopExit. A dashboard not produced alone cannot tell a
     # refusal from a run that hit max_iterations while still on track (matches
-    # kda_skill.py/alert_skill.py). No CHAT_ERROR/SIMULATED_USER_FAILED member here: this
-    # loop has neither a send_message try/except nor a simulated-user call to fail.
+    # kda_skill.py/alert_skill.py). CHAT_ERROR is reachable; SIMULATED_USER_FAILED is not --
+    # this loop's follow-up is built from the expectation by build_simulated_reply, with no
+    # judge call that could fail.
     exit_reason: LoopExit = LoopExit.BUDGET_EXHAUSTED
 
 
@@ -879,7 +880,33 @@ def _execute_single_dashboard_run(
     for iteration in range(max_iterations):
         turns += 1
         agent_started = time.monotonic()
-        chat_result = client.send_message(conversation_id, current_question)
+        try:
+            chat_result = client.send_message(conversation_id, current_question)
+        except ChatError as exc:
+            # Recorded rather than left to escape: this runs inside one of K runs, so an
+            # uncaught ChatError discarded every run already completed along with this one's
+            # exit_reason, and the item surfaced as a bare error with no per-run diagnosis.
+            # Matches metric_skill.py and conversation.py, which record it the same way.
+            timings.agent_s += time.monotonic() - agent_started
+            print(f"[CHAT] send_message failed for conversation {conversation_id}: {exc}")
+            partial = exc.partial_result
+            if partial is not None:
+                # Shifted and indexed exactly as a completed turn is, before anything reads
+                # the events: left raw, a late turn's call_ts restarts near zero and
+                # timeline_detail reports it as overlapping the first one.
+                reasoning_steps.extend(partial.reasoning_steps or [])
+                response_id = partial.response_id or response_id
+                turn_offset, tool_index_offset, reasoning_index_offset = shift_and_index_events(
+                    partial,
+                    turn_offset=turn_offset,
+                    tool_index_offset=tool_index_offset,
+                    reasoning_index_offset=reasoning_index_offset,
+                )
+                all_tool_call_events.extend(partial.tool_call_events or [])
+                all_reasoning_step_events.extend(partial.reasoning_step_events or [])
+                steps += partial.reasoning_step_count
+            exit_reason = LoopExit.CHAT_ERROR
+            break
         agent_elapsed = time.monotonic() - agent_started
         timings.agent_s += agent_elapsed
         reasoning_steps.extend(chat_result.reasoning_steps or [])
 
@@ -15,6 +15,7 @@
     evaluate_dashboard_response,
     run_agentic_dashboard_skill,
 )
+from gooddata_eval.core.chat.sse_client import ChatError
 from gooddata_eval.core.models import ChatResult, LoopExit, ToolCallEvent
 
 # Ids and titles are the ones the eval layout seeds; shapes are trimmed from real runs of
@@ -1104,6 +1105,54 @@ def test_a_caller_supplied_conversation_is_not_deleted(self):
         client.create_conversation.assert_not_called()
         client.delete_conversation.assert_not_called()
 
+    def test_a_chat_error_is_recorded_rather_than_left_to_escape(self):
+        """It used to escape run_agentic_dashboard_skill, taking every completed K-run with
+        it: no DashboardRunResult, no exit_reason, just a bare error on the item. Recorded
+        the way metric_skill.py and conversation.py record it, so an infrastructure fault
+        stays distinguishable from the agent failing to draft."""
+        client = MagicMock()
+        client.send_message.side_effect = ChatError("gen-ai fell over")
+
+        summary = _run_with(client, _DC05_EXPECTED)
+
+        assert summary.run_results[0].exit_reason is LoopExit.CHAT_ERROR
+        assert summary.run_results[0].evaluation.strict_pass is False
+        assert summary.pass_at_k is False
+
+    def test_a_chat_error_keeps_the_partial_turn_s_work(self):
+        """A bare catch would discard ChatError.partial_result. What the stream delivered
+        before it died is still this turn's work -- the steps were taken and the tools ran."""
+        partial = _chat_result(
+            tool_calls=[{"functionName": "search_objects", "functionArguments": "{}", "callTs": 1, "durationMs": 10}],
+            text="Here is the draft.",
+        )
+        partial.reasoning_steps = ["looked for the charts"]
+        partial.reasoning_step_count = 1
+        client = MagicMock()
+        client.send_message.side_effect = ChatError("stream died mid-answer", partial_result=partial)
+
+        summary = _run_with(client, _DC05_EXPECTED)
+        run = summary.run_results[0]
+
+        assert run.exit_reason is LoopExit.CHAT_ERROR
+        assert run.reasoning_steps == ["looked for the charts"]
+        assert run.total_steps == 1
+        assert [tc.function_name for tc in run.tool_call_events] == ["search_objects"]
+
+    def test_a_chat_error_on_a_later_turn_keeps_the_earlier_ones(self):
+        """The whole point of recording it: turns already completed survive the fault."""
+        client = MagicMock()
+        client.send_message.side_effect = [
+            _chat_result(text="Which charts did you have in mind?"),
+            ChatError("gen-ai fell over"),
+        ]
+
+        summary = _run_with(client, _DC05_EXPECTED)
+        run = summary.run_results[0]
+
+        assert run.exit_reason is LoopExit.CHAT_ERROR
+        assert run.total_turns == 2
+
 
 class TestEvaluateEntryPoint:
     def test_a_failing_run_raises_with_the_failures_attached(self):