Name the entity behind the movement-warning burst

The server performance block reported a movement_warnings count with no way to attribute it. Measured: the counter went 0 -> 107 in under a minute and then stopped, so it is a burst from one event, not the server degrading. A count cannot say whether that is a player joining, a bot reconnecting, or the whole simulation falling behind, and the vanilla lines that carry the answer were not published anywhere -- the HF log stream served a frozen window and /voyager/status strips its log tail on purpose.

performance.movement_warning_samples now carries up to five of those lines, truncated to 200 characters each, so the entity is visible. They are deduplicated on the message rather than the raw line: every entry in a burst has its own timestamp, so comparing raw lines would fill the payload with five copies of one problem instead of showing five distinct ones. Verified directly: 40 warnings from one bot collapse to one sample, and adding a second bot's warning produces two.

This is diagnosis, not a fix. It says which entity to investigate; the cause still has to be established from the lines themselves.

Suite: 128 -> 131 passed, 0 failed. pyflakes clean.

minecraft_stack.py

@@ -350,12 +350,31 @@ def _server_performance(lines: list[str], now: datetime.datetime | None = None)
     tick_lag = [line for line in recent if "Can't keep up!" in line]
     delays = [int(match.group(1)) for line in tick_lag
               if (match := re.search(r"Running (\d+)ms or \d+ ticks behind", line))]
+    movement = [line for line in recent
+                if "moved too quickly" in line or "moved wrongly" in line]
+    # The count alone cannot say whether this is one entity joining or the whole
+    # server degrading. Measured: the counter went 0 -> 107 in under a minute and
+    # then stopped, which is a burst, so the entity behind it has to be visible.
+    # Deduplicate on the message, not the raw line: a burst carries a distinct
+    # timestamp on every entry, so comparing raw lines would fill the payload with
+    # five copies of one problem instead of showing five distinct ones.
+    samples: list[str] = []
+    seen: set[str] = set()
+    for line in movement:
+        trimmed = line.strip()[:200]
+        key = re.sub(r"^\[[^\]]*\]\s*", "", trimmed)
+        if key in seen:
+            continue
+        seen.add(key)
+        samples.append(trimmed)
+        if len(samples) >= 5:
+            break
     return {
         "window_seconds": 300,
         "tick_lag_events": len(tick_lag),
         "max_reported_tick_delay_ms": max(delays, default=None),
-        "movement_warnings": sum("moved too quickly" in line or "moved wrongly" in line
-                                 for line in recent),
+        "movement_warnings": len(movement),
+        "movement_warning_samples": samples,
         "last_tick_lag_at": tick_lag[-1][1:20] if tick_lag else None,
     }
 

tests/test_server_performance.py

@@ -17,11 +17,58 @@ def test_tick_lag_and_movement_are_distinct():
         "tick_lag_events": 1,
         "max_reported_tick_delay_ms": 321,
         "movement_warnings": 2,
+        "movement_warning_samples": [
+            "[2026-09-27 16:27:00] minecraft> [Server thread/WARN]: IffyBinkie6134 moved too quickly!",
+            "[2026-09-27 16:29:10] minecraft> [Server thread/WARN]: IffyBinkie6134 moved wrongly!",
+        ],
         "last_tick_lag_at": "2026-09-27 16:29:00",
     }
     assert _server_performance(lines[:1], now)["max_reported_tick_delay_ms"] is None
 
 
+def test_movement_samples_name_the_entity_behind_the_burst():
+    # Measured: the counter went 0 -> 107 in under a minute and then stopped. A
+    # count cannot say whether one entity joining caused it or the whole server is
+    # degrading, so the entity has to be in the payload.
+    now = datetime.datetime(2026, 9, 29, 10, 30, 0)
+    lines = [
+        f"[2026-09-29 10:29:{second:02d}] minecraft> [Server thread/WARN]: Naldo_Bot moved too quickly! 12.5,0.0,-8.25"
+        for second in range(0, 40)
+    ]
+    result = _server_performance(lines, now)
+    assert result["movement_warnings"] == 40
+    # The burst carries a distinct timestamp per entry, so the samples must
+    # collapse on the message: one entity, one problem, one sample.
+    assert result["movement_warning_samples"] == [
+        "[2026-09-29 10:29:00] minecraft> [Server thread/WARN]: Naldo_Bot moved too quickly! 12.5,0.0,-8.25"
+    ], "a burst from one entity must not fill the payload with copies"
+    assert "Naldo_Bot" in result["movement_warning_samples"][0]
+
+
+def test_movement_samples_are_bounded():
+    now = datetime.datetime(2026, 9, 29, 10, 30, 0)
+    lines = [
+        f"[2026-09-29 10:29:{second:02d}] minecraft> [Server thread/WARN]: Bot{second} moved wrongly!"
+        for second in range(0, 20)
+    ]
+    result = _server_performance(lines, now)
+    assert result["movement_warnings"] == 20
+    assert len(result["movement_warning_samples"]) == 5, "the payload must stay small"
+    assert all(len(sample) <= 200 for sample in result["movement_warning_samples"])
+
+
+def test_samples_are_empty_when_nothing_moved_wrongly():
+    now = datetime.datetime(2026, 9, 29, 10, 30, 0)
+    result = _server_performance(
+        ["[2026-09-29 10:29:00] minecraft> [Server thread/INFO]: Done (1.2s)!"], now
+    )
+    assert result["movement_warnings"] == 0
+    assert result["movement_warning_samples"] == []
+
+
 if __name__ == "__main__":
     test_tick_lag_and_movement_are_distinct()
+    test_movement_samples_name_the_entity_behind_the_burst()
+    test_movement_samples_are_bounded()
+    test_samples_are_empty_when_nothing_moved_wrongly()
     print("PASS bounded vanilla tick-lag and movement diagnostics")