@@ -30,11 +30,12 @@
     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,
     AgenticEvalOutcome,
+    LoopExit,
     ReasoningStepEvent,
     ToolCallEvent,
     shift_and_index_events,
@@ -483,6 +484,12 @@ class AlertRunResult:
     response_id: str | None = None
     tool_call_events: list[ToolCallEvent] = field(default_factory=list)
     reasoning_step_events: list[ReasoningStepEvent] = field(default_factory=list)
+    # Why the simulated-user loop stopped, and how many turns it took. Without these a run
+    # that ran out of turns is indistinguishable from one that refused: both land on
+    # alert_created=False, and every downstream check is `alert_created and ...`, so both
+    # also report operator/threshold/metric/recipients as False.
+    exit_reason: LoopExit = LoopExit.BUDGET_EXHAUSTED
+    turns_used: int = 0
 
 
 @dataclass
@@ -681,8 +688,35 @@ def _run_once(conv_id: str) -> AlertRunResult:
             turns = 0
             steps = 0
 
+            # Defaults to BUDGET_EXHAUSTED: every other exit sets it explicitly, so a loop
+            # that simply runs out of range() is correctly labelled without a trailing else.
+            exit_reason = LoopExit.BUDGET_EXHAUSTED
+            turns_used = 0
             for _iteration in range(max_iterations):
-                chat_result = client.send_message(conv_id, current_question)
+                turns_used = _iteration + 1
+                try:
+                    chat_result = client.send_message(conv_id, current_question)
+                except ChatError as exc:
+                    # Without this the exception escapes run_agentic_alert_skill entirely,
+                    # discarding every K-run already completed along with any exit_reason.
+                    print(f"[CHAT] send_message failed for conversation {conv_id}: {exc}")
+                    # The stream can break AFTER create_metric_alert already succeeded
+                    # server-side. That id only ever reached alert_id_to_delete from the
+                    # normal path below, so breaking here left the alert in the workspace for
+                    # the `finally` cleanup to miss -- a real object leaking out of a failed
+                    # run, not a reporting gap.
+                    partial = exc.partial_result
+                    if partial is not None:
+                        reasoning_steps.extend(partial.reasoning_steps or [])
+                        response_id = partial.response_id or response_id
+                        partial_alert_id, _, partial_tool_called = _extract_alert_call(partial.tool_call_events or [])
+                        if partial_tool_called:
+                            alert_id_to_delete = partial_alert_id
+                    exit_reason = LoopExit.CHAT_ERROR
+                    break
+                # `turns_used` counts attempts (set above, so a failed send still shows the
+                # loop reached this iteration); `turns`/`steps` count completed work, so they
+                # advance only once send_message has actually returned.
                 turns += 1
                 steps += chat_result.reasoning_step_count
                 reasoning_steps.extend(chat_result.reasoning_steps or [])
@@ -698,6 +732,7 @@ def _run_once(conv_id: str) -> AlertRunResult:
                 alert_id, actual_args, tool_called = _extract_alert_call(chat_result.tool_call_events or [])
                 if tool_called:
                     alert_id_to_delete = alert_id
+                    exit_reason = LoopExit.SUCCESS
                     break
                 response_text = (chat_result.text_response or "").strip()
                 if not response_text and chat_result.alert_proposals:
@@ -706,13 +741,24 @@ def _run_once(conv_id: str) -> AlertRunResult:
                     response_text = render_answer_text(chat_result)
                 # Stop if agent gave a completely empty response (stuck)
                 if not response_text and not chat_result.tool_call_events:
+                    exit_reason = LoopExit.AGENT_SILENT
                     break
                 # Stop before generating a follow-up for the last iteration
                 if _iteration >= max_iterations - 1:
                     break
-                follow_up = generate_simulated_alert_response(
-                    response_text, expected, conversation_history, question=question
-                )
+                # Recorded rather than raised, matching metric_skill and kda_skill. Letting it
+                # propagate did keep a harness fault from being scored as a content failure,
+                # but it also discarded the K-runs already completed -- and SIMULATED_USER_FAILED
+                # achieves the same separation while keeping them, since reporting reads the
+                # exit reason to classify the run as an error rather than an agent failure.
+                try:
+                    follow_up = generate_simulated_alert_response(
+                        response_text, expected, conversation_history, question=question
+                    )
+                except Exception as exc:  # noqa: BLE001 -- harness-side fault; end only this run
+                    print(f"[SIM-USER] Simulated reply failed for conversation {conv_id}: {exc}")
+                    exit_reason = LoopExit.SIMULATED_USER_FAILED
+                    break
                 # Record this exchange so the next call has full history
                 conversation_history.append({"role": "assistant", "content": response_text})
                 conversation_history.append({"role": "user", "content": follow_up})
@@ -740,6 +786,8 @@ def _run_once(conv_id: str) -> AlertRunResult:
                 response_id=response_id,
                 tool_call_events=all_tool_call_events,
                 reasoning_step_events=all_reasoning_step_events,
+                exit_reason=exit_reason,
+                turns_used=turns_used,
             )
         finally:
             if alert_id_to_delete:
@@ -908,6 +956,11 @@ def _write_scores(ctx: RunTraceContext) -> None:
         "attributes_correct": ev.attributes_correct,
         "granularity_correct": ev.granularity_correct,
         "actual_alert_arguments": best.actual_alert_arguments,
+        # Why the loop stopped. alert_created=False alone cannot tell a refusal from a run
+        # that hit max_iterations while still on track -- see LoopExit.
+        "exit_reason": best.exit_reason.value,
+        "turns_used": best.turns_used,
+        "max_iterations": max_iterations,
         **timeline_detail(best.tool_call_events, best.reasoning_step_events),
     }
 
 
@@ -61,6 +61,7 @@
     AgenticEvalOutcome,
     ChatResult,
     CreatedVisualization,
+    LoopExit,
     ReasoningStepEvent,
     ToolCallEvent,
     shift_and_index_events,
@@ -168,6 +169,10 @@ class TurnResult(BaseModel):
     active_skills: list[str] = Field(default_factory=list)
     clarification_turns_used: int = 0
     output_correct: bool | None = None
+    # Why this turn's clarification loop stopped -- see LoopExit. output_present=False alone
+    # cannot separate a turn that ran out of clarification budget from one where the agent
+    # went silent, and skill_success folds both into the same failure.
+    exit_reason: LoopExit = LoopExit.BUDGET_EXHAUSTED
     mismatches: list[str] = Field(default_factory=list)
     clarifications: list[ClarificationRecord] = Field(default_factory=list)
     depends_on: list[str] = Field(default_factory=list)
@@ -219,6 +224,9 @@ def failure_reasons(self) -> list[str]:
         # What skill_routing was judged against -- without it, a turn showing
         # skill_routing=True and activated_skills=[] looks like a scoring bug.
         "active_skills",
+        # Why the clarification loop ended on this turn, and how much of the budget it
+        # took to get there -- exit_reason alone cannot be related to the limit without it.
+        "exit_reason",
         "clarification_turns_used",
         "mismatches",
         "clarifications",
@@ -569,6 +577,10 @@ class ConversationResult:
     full_skill_coverage: bool
     conversation_success: bool
     total_clarification_turns: int
+    # The configured per-turn clarification budget, so a reader can tell a turn that used
+    # its whole allowance from one that stopped early. Every other agentic kind reports its
+    # limit in detail; without this, conversation is the exception to that contract.
+    max_clarification_turns: int = _DEFAULT_MAX_CLARIFICATION_TURNS
     total_steps: int = 0
     reasoning_steps: list[str] = field(default_factory=list)
     response_id: str | None = None
@@ -770,6 +782,10 @@ def run_agentic_conversation(
                         # read as "nothing was active", which is a different claim.
                         active_skills=sorted(active_skills),
                         output_correct=False,
+                        # This turn's loop never ran at all -- a $ref pointing at an earlier
+                        # turn's output could not be resolved. Labelling it BUDGET_EXHAUSTED
+                        # (the field default) would claim it ran out of clarification turns.
+                        exit_reason=LoopExit.NOT_RUN,
                         mismatches=[str(exc)],
                         depends_on=list(turn.depends_on),
                     )
@@ -790,6 +806,9 @@ def run_agentic_conversation(
             records: list[ClarificationRecord] = []
             answers_left = list(turn.set_answers)
 
+            # Defaults to BUDGET_EXHAUSTED: every other exit assigns explicitly, so a loop
+            # that simply runs out of range() is labelled correctly with no trailing else.
+            turn_exit = LoopExit.BUDGET_EXHAUSTED
             for _iter in range(max_clarification_turns + 1):
                 transcript.append(TranscriptEntry("user", current_message))
                 incomplete = False
@@ -799,11 +818,36 @@ def run_agentic_conversation(
                     chat_result = exc.partial_result or ChatResult()
                     incomplete = True
                 except ChatError as exc:
-                    # The stream can die after create_metric ran server-side; keep what the
-                    # accumulator saw so the cleanup still knows what to delete.
-                    if exc.partial_result is not None:
-                        created.record(exc.partial_result.tool_call_events or [])
-                    raise
+                    # Recorded rather than raised so the turns already completed keep their
+                    # results, and so this turn is distinguishable from one where the agent
+                    # simply failed to produce output. no_error below reads this back.
+                    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. What the stream managed to deliver before it died
+                        # is still this turn's work: left raw, its `call_ts` would restart near
+                        # zero and its indexes at zero, so `timeline_detail` would report a
+                        # late turn as overlapping the first one. The steps count for the same
+                        # reason -- they were taken.
+                        total_steps += partial.reasoning_step_count
+                        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,
+                        )
+                        # The stream can die after create_metric ran server-side; keep what
+                        # the accumulator saw so the cleanup still knows what to delete.
+                        created.record(partial.tool_call_events or [])
+                        final_result = partial
+                        all_tool_calls.extend(partial.tool_call_events or [])
+                        conversation_tool_call_events.extend(partial.tool_call_events or [])
+                        conversation_reasoning_step_events.extend(partial.reasoning_step_events or [])
+                        reasoning_steps.extend(partial.reasoning_steps or [])
+                        response_id = partial.response_id or response_id
+                    turn_exit = LoopExit.CHAT_ERROR
+                    break
                 final_result = chat_result
                 total_steps += chat_result.reasoning_step_count
                 turn_offset, tool_index_offset, reasoning_index_offset = shift_and_index_events(
@@ -833,6 +877,13 @@ def run_agentic_conversation(
                 if _check_output_present(resolved_turn, chat_result):
                     if incomplete:
                         records.append(ClarificationRecord(kind="turn_incomplete", agent_message=clip(response_text)))
+                    turn_exit = LoopExit.SUCCESS
+                    break
+
+                # `incomplete` is excluded deliberately: a turn the server cut short is a
+                # known stall with its own nudge path below, not an agent that said nothing.
+                if not incomplete and not response_text and not chat_result.tool_call_events:
+                    turn_exit = LoopExit.AGENT_SILENT
                     break
 
                 kind: ReplyRecordKind = "turn_incomplete" if incomplete else classify_reply(chat_result, response_text)
@@ -912,11 +963,15 @@ def run_agentic_conversation(
                     expected_skill=turn.expected_skill,
                     skill_routing=skill_routing,
                     output_present=output_present,
-                    no_error=True,  # SDK raises on errors; reaching here means no critical error.
+                    # A chat fault used to escape the whole run, so reaching here did mean no
+                    # error. Now that it is caught and recorded, this has to read it back --
+                    # otherwise a turn whose chat call failed reports no_error=True.
+                    no_error=turn_exit is not LoopExit.CHAT_ERROR,
                     activated_skills=declared or [],
                     active_skills=sorted(active_skills),
                     clarification_turns_used=clarification_turns,
                     output_correct=output_correct,
+                    exit_reason=turn_exit,
                     mismatches=mismatches,
                     clarifications=records,
                     depends_on=list(turn.depends_on),
@@ -943,6 +998,7 @@ def run_agentic_conversation(
         full_skill_coverage=full_skill_coverage,
         conversation_success=conversation_success,
         total_clarification_turns=total_clarification_turns,
+        max_clarification_turns=max_clarification_turns,
         total_steps=total_steps,
         reasoning_steps=reasoning_steps,
         response_id=response_id,
@@ -969,6 +1025,7 @@ def _conversation_detail(result: ConversationResult) -> dict:
         "lost_context_clarifications": result.lost_context_clarifications,
         "stalled_turns": result.stalled_turns,
         "total_clarification_turns": result.total_clarification_turns,
+        "max_clarification_turns": result.max_clarification_turns,
         "judge_model": result.judge_model,
         "turns": [tr.detail() for tr in result.turn_results],
         **timeline_detail(result.tool_call_events, result.reasoning_step_events),
@@ -1033,7 +1090,6 @@ def evaluate_agentic_conversation(
         failed_turns = {tr.turn_id: tr.failure_reasons() for tr in result.turn_results if not tr.context_success}
 
         def _write_scores(ctx: RunTraceContext) -> None:
-
             pt = ctx.trace(result.conversation_id)
             with ctx.observe(
                 pt,