@@ -340,7 +340,9 @@ Each item also states its `mode`, its `trace_latencies_s` and its `run_latencies
   Its latency is that turn's response time, from sending the message to the end of its stream
   (`turn_wall_clock_sec`), recorded where the chat client completes the turn. It holds none of the LLM judge,
   the simulated user or conversation create/delete. `dashboard_summary` is timed the same way around its one
-  request. A turn that raised was never completed and has no entry.
+  request. A turn cut off by its turn or item deadline (or ended by an error event) still counts, with the
+  time it ran for: those are the slowest turns, and the run that scored them is in the per-run figures too. An
+  item that errored outside its evaluator's own failure reporting contributes neither.
 - **Single-shot** runs are exactly one trace, so `traces_s` is also the latency of a run.
 - **Multi-turn** runs span several traces, so they get both views: `traces_s` over every turn of every
   conversation (comparable with single-shot), and `runs_s`, the wall clock of each whole conversation from just
@@ -409,8 +411,8 @@ simulated user), which are `single_shot` and `multi_turn` in the JSON.
   the runs in play has it (so "Failed" over previous and latest finds every test case that broke in either), and the
   expression is evaluated once per run in play with the same any-run rule. A filtered page states how many test cases
   it covers, and each tier has its own Reset.
-- **Results** — three headline cards for the latest run: test cases passed, the average quality score and the median
-  time per attempt. With an earlier run each card carries one change line in words, "down from 86% on Sep 28", rather
+- **Results** — three headline cards for the latest run: test cases passed (of those evaluated: skipped ones are not
+  counted, as in the console's percentage), the average quality score and the median time per attempt. With an earlier run each card carries one change line in words, "down from 86% on Sep 28", rather
   than a signed number. The line is green when that direction is good and red when it is not, with a chevron and
   screen-reader text (*Better* / *Worse*) so colour is not the only signal. From three runs each card also has a
   sparkline of every run: hover a point for its value, click it to compare the latest run with that one instead of the
@@ -428,8 +430,9 @@ simulated user), which are `single_shot` and `multi_turn` in the JSON.
   decimal and no redundant ".0" (`3s`, `4.6s`).
 - **A test case table**, newest first: the latest run's result, a **Since previous run** column, then the earlier runs
   going back in time (click any result to open the drawer on that run). The change column reads *Regressed* (passed in
-  the previous run, not in the latest), *Fixed*, *Flaky* (flipped between pass and fail more than once), *New* or
-  *Removed*. With several runs the table opens on the regressions. Two time columns
+  the previous run, not in the latest), *Fixed*, *Flaky* (flipped between pass and fail more than once), *New*
+  (in no earlier run) or *Removed* (in an earlier run, gone from the latest). A test case skipped in the latest run
+  has no label, since the change would describe earlier runs. With several runs the table opens on the regressions. Two time columns
   keep the populations apart: **Response time** is the median of the test case's assistant responses, and **Time per
   attempt** is the mean wall-clock of a whole attempt (the responses plus the judge and, for conversations, the
   simulated user). With more than two runs shown they follow the latest run only. Hover a value to see every sample
 
@@ -545,6 +545,12 @@ def _process_item(index: int, item: DatasetItem) -> ItemReport:
             # judge broke should not also report the agent as costing 0s. Kinds that
             # attach no timings to the exception keep their 0.0 defaults.
             _apply_timings(item_report, getattr(exc, "timings", None))
+            # Phase timings stay, but the per-turn response times do not: this item reports no
+            # runs (and so no run latencies), and keeping its turns would put them in the
+            # response population with no attempt beside them. An item that completed 2 of 3
+            # runs and then raised would otherwise show up in the per-response table and not in
+            # the per-conversation one.
+            traces.discard()
         finally:
             item_report.latency_s = time.perf_counter() - t0
             item_report.trace_latencies_s = traces.stop()
 
@@ -588,10 +588,21 @@ def _do() -> ChatResult:
                 result.turn_wall_clock_sec = time.monotonic() - t0
                 return result
 
-        result = _retry_transient(_do, is_retryable=_is_retryable_exc)
-        # One completed turn is one gen-ai trace. Recorded here, from the figure the turn already
-        # carries, so every caller is covered and no extra clock is read. A turn that raised is
-        # not recorded: it has no completed response to time.
+        try:
+            result = _retry_transient(_do, is_retryable=_is_retryable_exc)
+        except ChatError as exc:
+            # A turn that ended in a ChatError (a turn or item deadline, an error event, an
+            # incomplete turn) is still one gen-ai trace, and several evaluators score its
+            # partial result as a run. Recording it keeps the response population matching the
+            # runs that were scored: left out, the slowest turns -- the ones that hit a deadline --
+            # would vanish and pull the tail down exactly when the agent is slowest.
+            if exc.partial_result is not None:
+                note_trace_latency(exc.partial_result.turn_wall_clock_sec)
+            raise
+        # One turn is one gen-ai trace. Recorded here, from the figure the turn already carries,
+        # so every caller is covered and no extra clock is read. A turn that failed without a
+        # ChatError carries no partial result, so there is no response to time and it is not
+        # recorded.
         note_trace_latency(result.turn_wall_clock_sec)
         return result
 
 
@@ -415,13 +415,15 @@ <h2>Test cases</h2>
   const total = c.total ?? s.total ?? 0, passed = c.passed ?? s.passed ?? 0;
   return {
     total, passed, errored: s.errored ?? 0, skipped: s.skipped ?? 0,
-    pass_rate: c.pass_rate ?? (total ? passed / total : 0),
     avg_quality_score: c.avg_quality_score,
     avg_latency_s: c.avg_latency_s ?? s.avg_latency_s,
     total_latency_s: c.total_latency_s ?? s.latency_s,
     by_mode: c.by_mode || s.by_mode || null,
   };
 }
+// Share of the evaluated test cases that passed, for reported and recomputed figures alike. A skipped test case never
+// ran, so it is left out of the divisor, as the console's percentage does; null when nothing was evaluated.
+const passRateOf = (f) => (f.total - f.skipped > 0 ? f.passed / (f.total - f.skipped) : null);
 const r3 = (v) => Math.round(v * 1000) / 1000;
 // Linear interpolation between closest ranks, as gd-eval computes it, so P50 is the median.
 function percentile(sorted, p) {
@@ -459,7 +461,7 @@ <h2>Test cases</h2>
   }
   return {
     total: items.length, passed, errored: items.filter((it) => it.error != null).length,
-    skipped: items.filter((it) => it.skipped).length, pass_rate: items.length ? passed / items.length : 0,
+    skipped: items.filter((it) => it.skipped).length,
     avg_quality_score: evaluated.length ? mean(evaluated.map(qualityOf)) : 0,
     avg_latency_s: runs ? latency / runs : 0, total_latency_s: latency, by_mode,
   };
@@ -521,7 +523,7 @@ <h2>Test cases</h2>
 function renderSummary() {
   const base = runsShown.length > 1 ? compareBase() : null;
   $('#summary').innerHTML = '<h2>Results</h2><div class="trendgrid">' +
-    kpiCard({ title: 'Test cases passed', get: (l) => (figures[l].total ? figures[l].passed / figures[l].total : null), fmt: pct, higher: true,
+    kpiCard({ title: 'Test cases passed', get: (l) => passRateOf(figures[l]), fmt: pct, higher: true,
       isSame: (d) => Math.round(d * 100) === 0, base, after: ' <a href="#items-section" class="which">which?</a>' }) +
     kpiCard({ title: 'Average quality score', get: (l) => (figures[l].total ? figures[l].avg_quality_score : null), fmt: pct, higher: true,
       isSame: (d) => Math.abs(d) < 0.01, base }) +
@@ -843,14 +845,20 @@ <h2>Test cases</h2>
     return (va < vb ? -1 : va > vb ? 1 : 0) * sortDir;
   });
 }
-// How a test case moved between the last two runs shown, and whether it has flipped back and forth across all of them.
+// How a test case moved between the last two runs it was evaluated in, and whether it has flipped back and forth across
+// all of them. Every label describes the latest run, so none is given when that run skipped the test case or lacks it.
 const CHANGE_ORDER = { Regressed: 0, New: 1, Removed: 2, Flaky: 3, 'Still failing': 4, Fixed: 5, 'Still passing': 6, '': 7 };
 function changeOf(r, runList) {
+  const cur = r.per[runList[runList.length - 1]];
+  // New and Removed look at every earlier run, not just the one before: a test case that skipped a run and came back
+  // is not new, and its pass or fail history still says whether it was fixed or is flaky.
+  const earlier = runList.slice(0, -1).some((l) => r.per[l]);
   if (runList.length > 1) {
-    const prevIt = r.per[runList[runList.length - 2]], curIt = r.per[runList[runList.length - 1]];
-    if (curIt && !prevIt) return 'New';
-    if (prevIt && !curIt) return 'Removed';
+    if (cur && !earlier) return 'New';
+    if (!cur && earlier) return 'Removed';
   }
+  // Skipped in the latest run (or missing from it): the earlier runs alone would label a result the row does not show.
+  if (['none', 'skip'].includes(statusOf(cur))) return '';
   const st = runList.map((l) => statusOf(r.per[l])).filter((x) => x !== 'none' && x !== 'skip');
   if (st.length < 2) return '';
   const ok = st.map((x) => x === 'pass');
@@ -926,7 +934,7 @@ <h2>Test cases</h2>
     { k: 'id', html: 'Test case' }, { k: 'kind', html: 'Category' }, { k: 'mode', html: 'Format' }, { k: 'question', html: 'Question' },
     // Newest first: the latest result, what changed since the previous run, then earlier runs going back in time.
     ...(multi ? [{ k: 's:' + runList[runList.length - 1], html: esc(roleOf(runList[runList.length - 1])) + LATEST_PILL }] : []),
-    ...(multi ? [{ k: 'chg', html: 'Since previous run', help: 'Regressed: passed in the previous run, not in the latest. Fixed: the reverse. Flaky: has flipped between pass and fail more than once across the runs shown. New / Removed: the test case was added to or dropped from the suite.' }] : []),
+    ...(multi ? [{ k: 'chg', html: 'Since previous run', help: 'Regressed: passed in the previous run, not in the latest. Fixed: the reverse. Flaky: has flipped between pass and fail more than once across the runs shown. New / Removed: the test case first appears in the latest run, or was in an earlier run and is gone from the latest. A test case skipped in the latest run has no label.' }] : []),
     ...(multi ? runList.slice(0, -1).reverse() : runList).map((l) => ({ k: 's:' + l, html: esc(roleOf(l)) })),
     ...timeRuns.map((l) => ({ k: 'lt:' + l, html: 'Response time' + runHdr(l), help: TRACE_HELP, num: true })),
     ...timeRuns.map((l) => ({ k: 'lr:' + l, html: 'Time per attempt' + runHdr(l), help: RUN_HELP, num: true })),
 
@@ -5,7 +5,7 @@
 import traceback
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass, field
-from functools import partial
+from functools import cached_property, partial
 from typing import Callable, Protocol
 
 from gooddata_eval.core.config import DEFAULT_GATE, EvalGate
@@ -67,8 +67,10 @@ class ItemReport:
     # The response time of every chat turn the item completed, in order -- one gen-ai trace
     # each, timed from sending the message to the end of its stream. For a single-shot item that
     # is one value per run; a multi-turn run contributes one per turn. Unlike `run_latencies_s`
-    # it holds none of the judge, simulated-user or conversation set-up time. A turn that raised
-    # has no entry, but a turn whose scoring raised afterwards does: it completed.
+    # it holds none of the judge, simulated-user or conversation set-up time. A turn that ended in
+    # a ChatError carrying a partial result has an entry, because evaluators score that result as a
+    # run; so does a turn whose scoring raised afterwards. An item that errored outside the
+    # evaluator's own failure reporting has none: it reports no runs for them to sit beside.
     trace_latencies_s: list[float] = field(default_factory=list)
     # Per-phase breakdown of what the item's time was spent on. Additive to latency_s,
     # which remains the item's own critical path. langfuse_latency_s is
@@ -200,10 +202,14 @@ def avg_quality_score(self) -> float:
         evaluated = [i.quality_score for i in self.items if not i.skipped and i.error is None]
         return sum(evaluated) / len(evaluated) if evaluated else 0.0
 
-    @property
+    @cached_property
     def by_mode(self) -> dict[str, dict]:
         """How the run did on its single-shot and on its multi-turn items, with latency for each.
 
+        Computed on first read and kept: the console, the comparison and both JSON builders all
+        read it, and each read would otherwise sort every latency sample again. Read it once the
+        report is complete -- items added afterwards are not reflected.
+
         ``total`` and ``passed`` count the evaluated items of that mode (skipped ones belong to
         neither). ``traces_s`` is the distribution of per-trace chat-turn response times; a
         single-shot run is one trace, so for that mode it is also the per-run latency. A
 
@@ -167,6 +167,11 @@ def stop(self) -> list[float]:
             self._token = None
         return self.latencies
 
+    def discard(self) -> None:
+        """Detach and drop what was recorded, for an item whose turns have no scored run to sit beside."""
+        self.stop()
+        self.latencies.clear()
+
 
 def note_trace_latency(seconds: float | None) -> None:
     """Record one completed chat turn on the active recorder, if there is one.
 
@@ -1065,14 +1065,33 @@ def test_turns_completed_before_a_failed_gate_still_count_as_traces():
     assert report.items[0].trace_latencies_s == [3.0, 4.0]
 
 
-def test_turns_completed_before_an_item_errored_still_count_as_traces():
-    """The agent answered those turns however the item ended, so they are real response times."""
+def test_an_item_that_errored_outside_its_evaluator_reports_no_trace_latencies():
+    """Such an item reports no runs, so keeping its turns would put them in the per-response
+    population with nothing beside them in the per-conversation one."""
     with patch(
         "gooddata_eval.cli.agentic_runner.evaluate_agentic_alert_skill",
-        side_effect=_noting(2.0, then=RuntimeError("simulated user failed")),
+        side_effect=_noting(2.0, 3.0, then=RuntimeError("simulated user failed")),
     ):
         report = run_agentic_items([_item()], host="http://host", token="tok", workspace_id="ws1", run_ts="2026-01-01")
-    assert report.items[0].error is not None
+    item = report.items[0]
+    assert item.error is not None
+    assert item.runs == 0
+    assert item.run_latencies_s == []
+    assert item.trace_latencies_s == []
+    assert report.by_mode["multi_turn"]["traces_s"] is None
+
+
+def test_an_ungraded_item_keeps_the_turns_it_drove():
+    """Unlike the case above, a judge fault leaves every run's time on the exception, so the
+    per-response and per-conversation populations still cover the same item."""
+    err = JudgeResponseError("judge returned no readable verdict for any of the 2 run(s)")
+    err.runs_effective = 2
+    err.run_latencies_s = [7.0, 9.5]
+    with patch("gooddata_eval.cli.agentic_runner.evaluate_agentic_alert_skill", side_effect=_noting(2.0, then=err)):
+        report = run_agentic_items(
+            [_item()], host="http://host", token="tok", workspace_id="ws1", run_ts="2026-01-01", k=2
+        )
+    assert report.items[0].run_latencies_s == [7.0, 9.5]
     assert report.items[0].trace_latencies_s == [2.0]