diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml
index 391aa3b1c..52405f5a3 100644
--- a/.github/workflows/pr.yml
+++ b/.github/workflows/pr.yml
@@ -127,6 +127,10 @@ jobs:
         run: pnpm run typecheck
         working-directory: ./frontend
 
+      - name: Frontend telemetry tests
+        run: pnpm run test:telemetry
+        working-directory: ./frontend
+
       - name: Frontend build
         run: pnpm run build
         working-directory: ./frontend
diff --git a/Makefile b/Makefile
index f63990b58..bdfa70962 100644
--- a/Makefile
+++ b/Makefile
@@ -108,6 +108,7 @@ check-js:
 	$(DEV) pnpm --dir frontend run check
 
 check-frontend:
+	$(DEV) pnpm --dir frontend run test:telemetry
 	$(DEV) pnpm --dir frontend run typecheck
 	$(DEV) pnpm --dir frontend run build
 
diff --git a/docs/antibot-review.md b/docs/antibot-review.md
new file mode 100644
index 000000000..dfcd1ea2f
--- /dev/null
+++ b/docs/antibot-review.md
@@ -0,0 +1,120 @@
+# Fair play reports and evaluation
+
+`/games/:id/ml` is a heuristic review aid, not a trained ML model or a cheating
+verdict. The worker persists reports after games and can alert tournament
+moderators. Scores do not automatically ban users.
+
+## What changed after the production audit
+
+The October 27, 2026 export contained 2,222 available non-site-bot reports, with
+866 medium/high results, but no independently confirmed outcomes. It exposed
+contradictory timing counters, missing batches in cached reports, legacy Enter
+handling and inconsistent offsets. These are collection defects, not labels for
+whether a player cheated. The export and scratch analysis live under ignored
+`tmp/`; they are not application assets or test fixtures.
+
+The earlier version-5 offline experiment reduced medium/high results to 264.
+That measured alert volume only, using exported batches and cached code/history
+features. Those figures do not describe the final version-6 scorer, and do not
+establish precision, recall or a false-positive rate.
+
+Report version 6 implements these changes:
+
+- Code style, GPT-like phrases, comment ratios, missing backspaces, zero idle
+  pauses, incomplete edit coverage, browser focus loss and missing telemetry do
+  not add suspicion. Measurements can remain available for review. Incomplete
+  coverage is explicitly a collection limitation.
+- Overlapping edit rules use their maximum. Timing and blocked-paste support is
+  capped at four points, below the review threshold of five. These weights are
+  priorities, not calibrated probabilities.
+- Modern version-3 collectors record bounded individual bulk-edit evidence with
+  offsets and explanations from the corresponding editor change. A paste or
+  undo elsewhere cannot explain that edit. Vim commands, IME composition,
+  completions, indentation, undo and permitted self-paste are accounted for.
+  Client-declared origins remain untrusted hints.
+- Legacy edit counters are evaluated per collection window, with explanations
+  limited to that window. They cannot identify the source of an individual edit.
+  Server replay jumps remain review context; a client throttle does not prove
+  that code was typed within 250 ms. Server diffs exclude unchanged code between
+  separate edits.
+- Reports persist structured evidence: stable code, category, weight, message,
+  measurements and replay offset where available. Compatibility signal strings
+  remain for existing consumers.
+
+## Collection quality and competitive evidence
+
+Version 2 introduced first/last key offsets; aggregation includes pauses between
+windows. Version 3 adds collector-session IDs, batch sequence numbers and edit
+records. A database uniqueness constraint makes retries of an identified batch
+idempotent. Missing sequences and multiple sessions are limitations, never
+positive suspicion. Legacy batches without identities remain supported.
+
+Timing is checked for contradictory samples, interval ordering, pause counts,
+missing boundaries, overlaps, session changes and offsets beyond game duration.
+Unreliable timing is excluded from rhythm scoring. Missing optional fields stay
+absent; they are not silently converted into measured zeroes. Unavailable timing
+metrics display as unavailable.
+
+Competitive code and replay history stop at the first completion marker, including
+submission code that arrived before the final throttled editor update. Finished
+non-tournament give-ups also close this boundary. Later practice edits are not
+used as the competitive solution. The report stores that solution and language,
+so cached pages display the same code that was analyzed.
+
+Only complete telemetry windows ending within the known competitive duration are
+used. Duration is recorded in whole seconds; its last partial second is allowed.
+A window crossing the boundary is excluded as a whole rather than attributing its
+aggregate counters to competitive play. Excluded windows and incomplete coverage
+are shown as limitations when retained telemetry is available; an entirely
+missing competitive sample shows insufficient telemetry.
+
+Finished caches include batch count, maximum ID, game state and duration. Every
+read checks the snapshot and requires a current report for each eligible player.
+Late flushes, lower-ID transactions committing late and changes from playing to
+finished invalidate reports. Live reports recompute even without new batches.
+Writes after an analysis read are detected on the next read.
+
+## Moderator decisions and evaluation
+
+Admins and moderators can append a review on the report page with one of:
+`confirmed_assistance` (confirmed unauthorized assistance), `legitimate`, or
+`inconclusive`. A reason is required; a replay offset is optional. Records retain
+the reviewer, timestamp, detector version and report snapshot. Re-analysis does
+not overwrite decisions. Decisions are distinct from user complaints and solution
+approval; their reasons are only sent to moderators.
+
+Run the read-only evaluation command inside the dev container:
+
+```sh
+./bin/dev mix codebattle.antibot.evaluate
+```
+
+It starts only the database reader and registry, without application workers,
+and uses a read-only, repeatable-read transaction. It recomputes the current rules
+against the latest decision for each player/game in finished games,
+without persisting reports or broadcasting alerts. It reports confusion counts,
+precision, recall, false-positive rate, inconclusive/missing cases and language/
+collector cohorts. Undefined rates are null. These metrics describe the reviewed
+sample; selection bias and repeated players still matter. Without labels the
+command does not claim accuracy.
+
+For a silent historical report backfill, invoke
+`Codebattle.Game.BotDetection.analyze_and_persist(game_id)` for a bounded set of
+finished games. The worker path can broadcast tournament alerts and should not
+be used for a silent audit.
+
+## Rollout and ML
+
+Apply all additive report/review migrations before deploying the application.
+Deploy the collector and scorer together; old clients remain supported. Monitor
+missing/legacy/inconsistent telemetry separately from score and alert counts.
+Review low-scoring games as well as flagged games to measure missed detections.
+
+Build independently reviewed examples covering mobile/IME, Vim, completions,
+undo, self-paste, reconnects, slow networks and known injection/autotyper cases.
+Do not turn complaints, existing heuristic scores or practice bots into cheating
+labels. Split future ML datasets by player and reserve a later time period for
+drift evaluation. Compare candidates with these rules on the same held-out cases,
+set a moderator workload and false-positive target, and run models in shadow mode
+before using them for alerts. Keep replay review and avoid automatic bans from
+scores alone.
diff --git a/frontend/package.json b/frontend/package.json
index b2ca627d1..e28955cb0 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -7,6 +7,7 @@
     "dev": "vite",
     "build": "vite build",
     "preview": "vite preview",
+    "test:telemetry": "node --test test/telemetry.test.mjs",
     "typecheck": "tsc --noEmit",
     "lint": "oxlint --deny-warnings",
     "check": "tsc --noEmit && oxlint --deny-warnings"
diff --git a/frontend/src/features/game/components/TopBar.tsx b/frontend/src/features/game/components/TopBar.tsx
index 052d078af..d0ac0777e 100644
--- a/frontend/src/features/game/components/TopBar.tsx
+++ b/frontend/src/features/game/components/TopBar.tsx
@@ -165,8 +165,8 @@ export function TopBar({
         </ActionIcon>
       </Tooltip>
       {(canManage || over) && (
-        <Tooltip label={t('Bot detection (ML)')}>
-          <ActionIcon component="a" href={`/games/${game.id}/ml`} size="sm" variant="default" aria-label={t('Bot detection (ML)')}>
+        <Tooltip label={t('Fair play review')}>
+          <ActionIcon component="a" href={`/games/${game.id}/ml`} size="sm" variant="default" aria-label={t('Fair play review')}>
             <IconRobot size={14} />
           </ActionIcon>
         </Tooltip>
diff --git a/frontend/src/features/game/editor/telemetry.ts b/frontend/src/features/game/editor/telemetry.ts
index 72453ca47..ce26319f7 100644
--- a/frontend/src/features/game/editor/telemetry.ts
+++ b/frontend/src/features/game/editor/telemetry.ts
@@ -24,6 +24,7 @@ export interface TelemetryEvent {
   large_insert_count?: number;
   assisted_chars?: number;
   completion_insert_count?: number;
+  command_insert_count?: number;
   paste_chars?: number;
   /** focus_return: how long the page was hidden or unfocused. */
   away_ms?: number;
@@ -31,9 +32,13 @@ export interface TelemetryEvent {
 
 export const WINDOW_MS = 10_000;
 export const EVENT_LIMIT = 100;
+// Version 2 records key boundaries so pauses between batches remain observable.
+export const COLLECTOR_VERSION = 3;
 
 interface TelemetryWindow {
+  edit_evidence: { offset_ms: number; inserted_chars: number; assisted_chars: number; paste_chars: number; printable_keys: number }[];
   event_count: number;
+  collector_version: number;
   window_start_offset_ms: number;
   window_end_offset_ms: number;
   lang_slug: string;
@@ -64,6 +69,7 @@ interface TelemetryWindow {
   large_insert_count: number;
   assisted_chars: number;
   completion_insert_count: number;
+  command_insert_count: number;
   paste_chars: number;
   blur_count: number;
   away_ms: number;
@@ -74,10 +80,13 @@ interface TelemetryWindow {
   max_key_delta_ms: number;
   idle_pause_over_2s_count: number;
   last_key_offset_ms: number | null;
+  first_key_offset_ms: number | null;
 }
 
 const newWindow = (event: TelemetryEvent): TelemetryWindow => ({
+  edit_evidence: [],
   event_count: 0,
+  collector_version: COLLECTOR_VERSION,
   window_start_offset_ms: event.offset_ms,
   window_end_offset_ms: event.offset_ms,
   lang_slug: event.lang_slug,
@@ -108,6 +117,7 @@ const newWindow = (event: TelemetryEvent): TelemetryWindow => ({
   large_insert_count: 0,
   assisted_chars: 0,
   completion_insert_count: 0,
+  command_insert_count: 0,
   paste_chars: 0,
   blur_count: 0,
   away_ms: 0,
@@ -118,6 +128,7 @@ const newWindow = (event: TelemetryEvent): TelemetryWindow => ({
   max_key_delta_ms: 0,
   idle_pause_over_2s_count: 0,
   last_key_offset_ms: null,
+  first_key_offset_ms: null,
 });
 
 const ARROWS = new Set(['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight']);
@@ -132,6 +143,7 @@ export function addEvent(current: TelemetryWindow | null, event: TelemetryEvent)
 
   switch (event.type) {
     case 'keydown': {
+      if (w.first_key_offset_ms == null) w.first_key_offset_ms = event.offset_ms;
       w.key_event_count += 1;
       const modifier = event.ctrl_key || event.meta_key;
       if (typeof event.key === 'string' && event.key.length === 1 && !modifier && !event.alt_key) w.printable_key_count += 1;
@@ -167,6 +179,11 @@ export function addEvent(current: TelemetryWindow | null, event: TelemetryEvent)
       w.drop_blocked_count += 1;
       break;
     case 'content_change':
+      if ((event.inserted_chars ?? 0) >= 8) w.edit_evidence.push({
+        offset_ms: event.offset_ms, inserted_chars: event.inserted_chars ?? 0,
+        assisted_chars: event.assisted_chars ?? 0, paste_chars: event.paste_chars ?? 0,
+        printable_keys: w.last_key_offset_ms != null && event.offset_ms - w.last_key_offset_ms <= 500 ? 1 : 0,
+      });
       w.content_change_count += event.change_count ?? 0;
       w.chars_inserted += event.inserted_chars ?? 0;
       w.chars_deleted += event.deleted_chars ?? 0;
@@ -179,6 +196,7 @@ export function addEvent(current: TelemetryWindow | null, event: TelemetryEvent)
       w.large_insert_count += event.large_insert_count ?? 0;
       w.assisted_chars += event.assisted_chars ?? 0;
       w.completion_insert_count += event.completion_insert_count ?? 0;
+      w.command_insert_count += event.command_insert_count ?? 0;
       w.paste_chars += event.paste_chars ?? 0;
       break;
     case 'focus_return':
@@ -195,7 +213,7 @@ export function addEvent(current: TelemetryWindow | null, event: TelemetryEvent)
 /** The summary pushed to the server; null for an empty window. */
 export function finalize(w: TelemetryWindow | null) {
   if (!w || w.event_count <= 0) return null;
-  const { last_key_offset_ms: _last, key_delta_total_ms: total, ...rest } = w;
+  const { key_delta_total_ms: total, ...rest } = w;
   return { ...rest, avg_key_delta_ms: w.key_delta_sample_count > 0 ? Math.round(total / w.key_delta_sample_count) : 0 };
 }
 
@@ -226,16 +244,20 @@ export interface ContentChangeEvent {
 /** The `executeEdits` source of our own text syncs (language switch, reset, the server's copy). */
 export const SYNC_EDIT_SOURCE = 'cb-sync';
 
-type EditOrigin = 'sync' | 'typed' | 'completion' | 'command' | 'paste' | 'other';
+type EditOrigin = 'sync' | 'composition' | 'typed' | 'completion' | 'command' | 'paste' | 'other';
 
 const originOf = (reason: EditReason | undefined, event: ContentChangeEvent): EditOrigin => {
   if (event.isFlush) return 'sync';
   if (event.isUndoing || event.isRedoing) return 'command';
   const { source, kind, name } = reason?.metadata ?? {};
   if (source === 'setValue' || (source === 'unknown' && name === SYNC_EDIT_SOURCE)) return 'sync';
+  // Our installed Vim adapter uses executeEdits('vim') for normal-mode commands.
+  // This is an origin hint, not a trusted assertion that the player is human.
+  if (source === 'unknown' && name === 'vim') return 'command';
   if (source === 'suggest' || source === 'snippet') return 'completion';
   if (source === 'cursor') {
-    if (kind === 'type' || kind === 'compositionType' || kind === 'compositionEnd') return 'typed';
+    if (kind === 'compositionType' || kind === 'compositionEnd') return 'composition';
+    if (kind === 'type') return 'typed';
     // Tab / indent / comment toggles and the like.
     if (kind === 'executeCommand' || kind === 'executeCommands') return 'command';
     // The paste guard only lets through text copied from this editor (pasteGuard.ts).
@@ -278,6 +300,7 @@ export function contentMetrics(event: ContentChangeEvent) {
     large_insert_count: 0,
     assisted_chars: 0,
     completion_insert_count: 0,
+    command_insert_count: 0,
     paste_chars: 0,
   };
 
@@ -294,7 +317,7 @@ export function contentMetrics(event: ContentChangeEvent) {
 
     // One key, more text: auto-indent ("\n" + spaces) or an auto-closed pair.
     const keyAssisted = origin === 'typed' && (inserted <= 2 || change.text.trim() === '');
-    const assisted = keyAssisted || origin === 'completion' || origin === 'command';
+    const assisted = keyAssisted || origin === 'completion' || origin === 'command' || origin === 'composition';
     if (origin === 'paste') {
       metrics.paste_chars += inserted;
       return;
@@ -303,6 +326,7 @@ export function contentMetrics(event: ContentChangeEvent) {
       if (origin === 'typed') metrics.max_single_insert_len = Math.max(metrics.max_single_insert_len, Math.min(inserted, 1));
       metrics.assisted_chars += origin === 'typed' ? Math.max(0, inserted - 1) : inserted;
       if (origin === 'completion') metrics.completion_insert_count += 1;
+      if (origin === 'command' && inserted > 0) metrics.command_insert_count += 1;
       return;
     }
 
diff --git a/frontend/src/features/game/editor/useEditorTelemetry.ts b/frontend/src/features/game/editor/useEditorTelemetry.ts
index fea74b686..a2511c682 100644
--- a/frontend/src/features/game/editor/useEditorTelemetry.ts
+++ b/frontend/src/features/game/editor/useEditorTelemetry.ts
@@ -5,7 +5,7 @@ import { useLatest } from '@/shared/useLatest';
 import type { EditorTelemetry } from './CodeEditor';
 import { addEvent, EVENT_LIMIT, finalize, WINDOW_MS } from './telemetry';
 
-type Send = (summary: NonNullable<ReturnType<typeof finalize>>, lang: string) => void;
+type Send = (summary: NonNullable<ReturnType<typeof finalize>> & { collector_session: string; batch_sequence: number }, lang: string) => void;
 
 /**
  * Collects my editor's telemetry into windows (≤ 10 s / ≤ 100 events, one language each)
@@ -13,6 +13,8 @@ type Send = (summary: NonNullable<ReturnType<typeof finalize>>, lang: string) =>
  */
 export function useEditorTelemetry({ enabled, lang, startedAtMs, send }: { enabled: boolean; lang: string; startedAtMs: number; send: Send }) {
   const windowRef = useRef<ReturnType<typeof addEvent> | null>(null);
+  const collectorSession = useRef(crypto.randomUUID());
+  const sequence = useRef(0);
   const timer = useRef<number | null>(null);
   const sendRef = useLatest(send);
 
@@ -23,7 +25,7 @@ export function useEditorTelemetry({ enabled, lang, startedAtMs, send }: { enabl
     }
     const summary = finalize(windowRef.current);
     windowRef.current = null;
-    if (summary) sendRef.current(summary, summary.lang_slug);
+    if (summary) sendRef.current({ ...summary, collector_session: collectorSession.current, batch_sequence: sequence.current++ }, summary.lang_slug);
   }, [sendRef]);
 
   const add = useCallback(
diff --git a/frontend/src/features/gameMl/Comparison.tsx b/frontend/src/features/gameMl/Comparison.tsx
index 82a32f5bb..767ef9bbf 100644
--- a/frontend/src/features/gameMl/Comparison.tsx
+++ b/frontend/src/features/gameMl/Comparison.tsx
@@ -47,9 +47,22 @@ function PlayerHeader({ column }: { column: MlColumn }) {
   const { t } = useTranslation();
   const { player } = column;
   const report = player.report;
-  const risk = RISK[report?.level ?? 'none'] ?? RISK.none;
+  const hasActivity = report?.stats && (report.stats.total_key_events > 0 || report.stats.total_content_changes > 0);
+  const risk = hasActivity ? RISK[report?.level ?? 'none'] ?? RISK.none : { label: 'Insufficient telemetry', color: 'gray' };
   const score = report?.score ?? 0;
   const signals = report?.signals ?? [];
+  const qualityIssues: Record<string, string> = {
+    missing_batch_identity: t('Missing telemetry batch identity'),
+    missing_batch_sequence: t('Missing telemetry batches'),
+    multiple_collector_sessions: t('Multiple editor sessions'),
+    incomplete_edit_coverage: t('Incomplete edit coverage'),
+    excluded_post_game_batches: t('Batches outside competitive play excluded'),
+    legacy_collector: t('Legacy telemetry'),
+    inconsistent_key_timing: t('Conflicting timing counters'),
+    outside_game_window: t('Timing exceeds game duration'),
+    overlapping_key_windows: t('Overlapping telemetry windows'),
+    incomplete_key_boundaries: t('Missing key timing boundaries'),
+  };
 
   return (
     <div className={classes.playerHead} style={colorStyle(column.color)}>
@@ -73,17 +86,19 @@ function PlayerHeader({ column }: { column: MlColumn }) {
           </Stack>
         </Group>
         {report && (
-          <Tooltip label={t('Risk score: 1+ low, 5+ suspicious, 10+ likely bot')}>
+          <Tooltip label={t('Heuristic score, not a probability. 5+ suggests review; 10+ indicates stronger signals.')}>
             <Stack gap={4} align="flex-end">
               <Badge size="md" variant="light" color={risk.color}>
                 {t(risk.label)}
               </Badge>
-              <Group gap={6} wrap="nowrap">
-                <Progress value={Math.min(100, (score / HIGH_SCORE) * 100)} color={risk.color} size="sm" w={64} aria-label={t('Risk score')} />
-                <Text size="xs" c="dimmed" ff="monospace">
-                  {score}
-                </Text>
-              </Group>
+              {(hasActivity || score > 0) && (
+                <Group gap={6} wrap="nowrap">
+                  <Progress value={Math.min(100, (score / HIGH_SCORE) * 100)} color={risk.color} size="sm" w={64} aria-label={t('Risk score')} />
+                  <Text size="xs" c="dimmed" ff="monospace">
+                    {score}
+                  </Text>
+                </Group>
+              )}
             </Stack>
           </Tooltip>
         )}
@@ -95,9 +110,18 @@ function PlayerHeader({ column }: { column: MlColumn }) {
         </Text>
       )}
 
-      {report && !report.stats && (
-        <Alert variant="light" color="orange" icon={<IconAlertTriangle size={16} />} py={6} mt="sm" title={t('No telemetry batches recorded.')}>
-          {t('Either the player never typed, or their solution was injected via WebSocket without using the editor.')}
+      {report && !hasActivity && (
+        <Alert variant="light" color="orange" icon={<IconAlertTriangle size={16} />} py={6} mt="sm" title={t('Insufficient telemetry')}>
+          {t('Missing telemetry does not establish automation. Check the replay for connection gaps and editor activity.')}
+        </Alert>
+      )}
+
+      {hasActivity && Boolean(report?.stats?.quality_issues?.length) && (
+        <Alert variant="light" color="gray" icon={<IconInfoCircle size={16} />} py={6} mt="sm" title={t('Telemetry limitations')}>
+          <Text size="xs">{t('Unreliable timing features are excluded from scoring.')}</Text>
+          <Text size="xs" c="dimmed">
+            {report?.stats?.quality_issues?.map((issue) => qualityIssues[issue] ?? t('Incomplete telemetry')).join(', ')}
+          </Text>
         </Alert>
       )}
 
@@ -105,14 +129,17 @@ function PlayerHeader({ column }: { column: MlColumn }) {
         <Alert variant="light" color={risk.color} icon={<IconAlertTriangle size={16} />} py={6} mt="sm" title={t('Signals')}>
           {/* Reasons are the risk scorer's English text. */}
           <ul className={classes.signals}>
-            {signals.map((signal) => (
-              <li key={signal}>{signal}</li>
+            {(report?.evidence?.length ? report.evidence : signals.map(message => ({ message, code: 'legacy', weight: 0, replay_offset_ms: null }))).map((signal, index) => (
+              <li key={`${signal.code}-${index}`}>
+                {signal.message}
+                {signal.replay_offset_ms != null && <> · {Math.round(signal.replay_offset_ms / 1000)} s</>}
+              </li>
             ))}
           </ul>
         </Alert>
       )}
 
-      {report && report.stats && signals.length === 0 && (
+      {hasActivity && signals.length === 0 && (
         <Group gap={6} mt="sm" c="dimmed">
           <IconInfoCircle size={14} />
           <Text size="xs">{t('No signals.')}</Text>
@@ -181,15 +208,15 @@ function useMetricGroups(): MetricGroup[] {
           },
           { label: t('Effective added length'), cell: report((r) => count(r.effective_added_length)) },
           {
-            label: t('Typed coverage'),
-            help: t('Chars typed in the editor against the code added on top of the template.'),
+            label: t('Recorded edit coverage'),
+            help: t('Gross inserted characters compared with final added length. Includes editor assistance and repeated replacements.'),
             cell: report((r) => {
               const added = r.effective_added_length ?? 0;
               const typed = r.stats?.total_chars_inserted;
               if (!isNum(typed) || added <= 0) return { value: '—' };
               const coverage = typed / added;
               const low = added >= 60 && coverage < 0.6;
-              return { value: `${(coverage * 100).toFixed(0)}%`, bar: coverage, warn: low, hint: low ? t('low → likely injected/pasted') : undefined };
+              return { value: `${(coverage * 100).toFixed(0)}%`, bar: coverage, warn: low, hint: low ? t('Incomplete telemetry or unrecorded edits') : undefined };
             }),
           },
           { label: t('Total chars / lines'), cell: code((c) => ({ value: pair(c.total_chars, c.total_lines), bar: c.total_chars })) },
@@ -205,7 +232,7 @@ function useMetricGroups(): MetricGroup[] {
               const phrases = c.gpt_phrase_matches ?? [];
               return {
                 ...count(c.gpt_phrase_hits),
-                warn: phrases.length > 0,
+
                 hint: phrases.length > 0 ? `“${phrases.slice(0, 2).join('”, “')}”${phrases.length > 2 ? ', …' : ''}` : undefined,
               };
             }),
@@ -216,7 +243,7 @@ function useMetricGroups(): MetricGroup[] {
         title: t('Keystrokes'),
         rows: [
           { label: t('Batches'), cell: stats((s) => count(s.batch_count)) },
-          { label: t('Total events'), cell: stats((s) => ({ ...count(s.total_events), hint: `${(s.events_per_sec ?? 0).toFixed(2)}/s` })) },
+          { label: t('Total events'), cell: stats((s) => ({ ...count(s.total_events), hint: s.timing_reliable === false ? undefined : `${(s.events_per_sec ?? 0).toFixed(2)}/s` })) },
           { label: t('Key events'), cell: stats((s) => count(s.total_key_events)) },
           { label: t('Printable keys'), cell: stats((s) => count(s.total_printable_keys)) },
           {
@@ -224,7 +251,7 @@ function useMetricGroups(): MetricGroup[] {
             cell: stats((s) => ({
               value: pair(s.total_chars_inserted, s.total_chars_deleted),
               bar: s.total_chars_inserted,
-              hint: t('%{rate} ins/s', { rate: (s.chars_per_sec ?? 0).toFixed(2) }),
+              hint: s.timing_reliable === false ? undefined : t('%{rate} ins/s', { rate: (s.chars_per_sec ?? 0).toFixed(2) }),
             })),
           },
           {
@@ -232,6 +259,11 @@ function useMetricGroups(): MetricGroup[] {
             help: t('Inserted by the editor for a keystroke: auto-indent, closing brackets, accepted autocomplete. Not counted as pasted.'),
             cell: stats((s) => ({ value: pair(s.total_assisted_chars, s.total_completion_inserts), bar: s.total_assisted_chars ?? 0 })),
           },
+          {
+            label: t('Editor command inserts'),
+            help: t('Edits attributed to editor commands, including Vim. An origin hint, not proof of fair play.'),
+            cell: stats((s) => count(s.total_command_inserts)),
+          },
           {
             label: t('Pasted chars'),
             help: t('Pastes can only bring back code copied from this editor.'),
@@ -254,13 +286,13 @@ function useMetricGroups(): MetricGroup[] {
       {
         title: t('Timing and edits'),
         rows: [
-          { label: t('Session length'), cell: stats((s) => ({ value: formatMs(s.elapsed_ms), bar: s.elapsed_ms })) },
-          { label: t('Avg key delta'), cell: stats((s) => ({ value: formatMs(s.avg_key_delta_ms), bar: s.avg_key_delta_ms })) },
+          { label: t('Session length'), cell: stats((s) => s.timing_reliable === false ? { value: '—' } : { value: formatMs(s.elapsed_ms), bar: s.elapsed_ms }) },
+          { label: t('Avg key delta'), cell: stats((s) => s.timing_reliable === false ? { value: '—' } : { value: formatMs(s.avg_key_delta_ms), bar: s.avg_key_delta_ms }) },
           {
             label: t('Min / Max key delta'),
-            cell: stats((s) => ({ value: `${formatMs(s.min_key_delta_ms)} / ${formatMs(s.max_key_delta_ms)}`, bar: s.max_key_delta_ms })),
+            cell: stats((s) => s.timing_reliable === false ? { value: '—' } : { value: `${formatMs(s.min_key_delta_ms)} / ${formatMs(s.max_key_delta_ms)}`, bar: s.max_key_delta_ms }),
           },
-          { label: t('Idle pauses >2s'), cell: stats((s) => count(s.total_idle_pauses)) },
+          { label: t('Idle pauses >2s'), cell: stats((s) => s.idle_pauses_reliable ? count(s.total_idle_pauses) : { value: '—' }) },
           {
             label: t('Multi-char inserts / deletes'),
             cell: stats((s) => ({ value: pair(s.total_multi_char_inserts, s.total_multi_char_deletes), bar: s.total_multi_char_inserts })),
@@ -272,19 +304,16 @@ function useMetricGroups(): MetricGroup[] {
               value: pair(s.max_single_insert_len, s.max_single_delete_len),
               bar: s.max_single_insert_len,
               warn: s.max_single_insert_len >= 8,
-              hint: s.max_single_insert_len >= 8 ? t('≥8 → likely paste') : undefined,
+              hint: s.max_single_insert_len >= 8 ? t('Bulk edit; review its origin') : undefined,
             })),
           },
           { label: t('Large inserts (≥50)'), cell: stats((s) => ({ ...count(s.total_large_inserts), warn: s.total_large_inserts > 0 })) },
           {
             label: t('Content changes / printable keys'),
             cell: stats((s) => {
-              const programmatic = s.total_content_changes > s.total_printable_keys + 1;
               return {
                 value: pair(s.total_content_changes, s.total_printable_keys),
                 bar: s.total_content_changes,
-                warn: programmatic,
-                hint: programmatic ? t('more changes than keys → programmatic') : undefined,
               };
             }),
           },
@@ -294,11 +323,11 @@ function useMetricGroups(): MetricGroup[] {
         title: t('Focus and the server copy'),
         rows: [
           {
-            label: t('Left the game / time away'),
-            help: t('Switches to another tab or window while playing.'),
+            label: t('Page focus loss / time unfocused'),
+            help: t('Browser focus or visibility changes, including other windows and dialogs. Context only; does not affect the score.'),
             cell: stats((s) =>
-              isNum(s.total_blurs)
-                ? { value: `${formatNumber(s.total_blurs)} / ${formatMs(s.total_away_ms)}`, bar: s.total_away_ms ?? 0, warn: (s.total_away_ms ?? 0) >= 30_000 }
+              s.focus_tracked && isNum(s.total_blurs)
+                ? { value: `${formatNumber(s.total_blurs)} / ${formatMs(s.total_away_ms)}`, bar: s.total_away_ms ?? 0 }
                 : { value: '—' },
             ),
           },
@@ -309,11 +338,11 @@ function useMetricGroups(): MetricGroup[] {
           },
           {
             label: t('Largest jump between updates'),
-            help: t('Most characters (not counting spaces) one update added. Typing adds a few; a big jump without a paste was not typed.'),
+            help: t('Most inserted characters (excluding spaces) in one received update. Connection gaps, undo and editor commands can also produce large updates.'),
             cell: report((r) => {
               if (!r.editor_history) return { value: '—' };
               const jump = r.editor_history.max_jump;
-              return { ...count(jump), warn: jump >= 80, hint: jump >= 80 ? t('≥80 → not typed') : undefined };
+              return { ...count(jump), warn: jump >= 80, hint: jump >= 80 ? t('Large update; check the replay') : undefined };
             }),
           },
         ],
diff --git a/frontend/src/features/gameMl/format.ts b/frontend/src/features/gameMl/format.ts
index 6666b0ad4..f5ec38932 100644
--- a/frontend/src/features/gameMl/format.ts
+++ b/frontend/src/features/gameMl/format.ts
@@ -1,10 +1,10 @@
 import type { RiskLevel } from './types';
 
 export const RISK: Record<RiskLevel, { label: string; color: string }> = {
-  none: { label: 'Looks human', color: 'green' },
-  low: { label: 'Low risk', color: 'blue' },
-  medium: { label: 'Suspicious', color: 'orange' },
-  high: { label: 'Likely bot', color: 'red' },
+  none: { label: 'No suspicious signals', color: 'gray' },
+  low: { label: 'Weak signals', color: 'blue' },
+  medium: { label: 'Review suggested', color: 'orange' },
+  high: { label: 'Strong signals', color: 'red' },
 };
 
 /** The score at which the risk scorer says "high" (RiskScorer.classify/1). */
diff --git a/frontend/src/features/gameMl/types.ts b/frontend/src/features/gameMl/types.ts
index 1e4d89f2d..50a5ef438 100644
--- a/frontend/src/features/gameMl/types.ts
+++ b/frontend/src/features/gameMl/types.ts
@@ -21,9 +21,15 @@ export interface MlStats {
   /** Auto-indent, auto-closed pairs, accepted completions (newer telemetry only). */
   total_assisted_chars?: number;
   total_completion_inserts?: number;
+  total_command_inserts?: number;
+  collector_versions?: number[];
+  quality_issues?: string[];
+  timing_reliable?: boolean;
+  idle_pauses_reliable?: boolean;
   /** Pastes (of the player's own code) and leaving the game (newer telemetry only). */
   total_paste_chars?: number;
   paste_tracked?: boolean;
+  focus_tracked?: boolean;
   total_blurs?: number;
   total_away_ms?: number;
   total_paste_attempts: number;
@@ -62,6 +68,7 @@ export interface MlReport {
   level: RiskLevel;
   /** Human-readable reasons from the risk scorer (server English). */
   signals: string[];
+  evidence?: { code: string; category: string; weight: number; message: string; evidence: Record<string, unknown>; replay_offset_ms: number | null }[];
   stats: MlStats | null;
   code_analysis: MlCodeAnalysis | null;
   /** BotDetection.EditorHistory: the editor updates the server received. */
diff --git a/frontend/src/features/lobby/components/Tournaments.tsx b/frontend/src/features/lobby/components/Tournaments.tsx
index 50576e363..aa0a0da55 100644
--- a/frontend/src/features/lobby/components/Tournaments.tsx
+++ b/frontend/src/features/lobby/components/Tournaments.tsx
@@ -1,4 +1,4 @@
-import { ActionIcon, Button, Card, Group, Popover, SimpleGrid, Stack, Text, Title, Tooltip } from '@mantine/core';
+import { ActionIcon, Badge, Button, Card, Group, Popover, SimpleGrid, Stack, Tabs, Text, Title, Tooltip } from '@mantine/core';
 import { useInterval } from '@mantine/hooks';
 import { IconCalendarUser, IconClockFilled, IconHistory, IconInfoCircle, IconPlus, IconUsers, IconUserStar } from '@tabler/icons-react';
 import { type ReactNode, useEffect, useMemo, useState } from 'react';
@@ -184,6 +184,8 @@ export function Tournaments({ isAdmin }: { isAdmin: boolean }) {
       ({ state }) => state !== 'finished' && state !== 'canceled',
     );
   }, [live, upcoming]);
+  const seasonTournaments = tournaments.filter(({ grade }) => grade !== 'open');
+  const customTournaments = tournaments.filter(({ grade }) => grade === 'open');
 
   return (
     <Stack gap="sm">
@@ -201,19 +203,48 @@ export function Tournaments({ isAdmin }: { isAdmin: boolean }) {
           </Button>
         </Group>
       </Stack>
-      {tournaments.length === 0 ? (
-        <Card>
-          <Text c="dimmed" ta="center" py="md">
-            {t("Competition hasn't started yet. Check the schedule for upcoming tournaments.")}
-          </Text>
-        </Card>
-      ) : (
-        <SimpleGrid cols={{ base: 1, xs: 2, lg: 3 }} spacing="sm">
-          {tournaments.map((tournament) => (
-            <TournamentCard key={tournament.id} tournament={tournament} isAdmin={isAdmin} />
-          ))}
-        </SimpleGrid>
-      )}
+      <Tabs defaultValue="season" keepMounted={false}>
+        <Tabs.List mb="sm">
+          <Tabs.Tab value="season">{t('Season tournaments')}</Tabs.Tab>
+          <Tabs.Tab
+            value="custom"
+            rightSection={customTournaments.length > 0 ? <Badge size="xs" variant="light">{customTournaments.length}</Badge> : undefined}
+          >
+            {t('Custom tournaments')}
+          </Tabs.Tab>
+        </Tabs.List>
+        <Tabs.Panel value="season">
+          {seasonTournaments.length === 0 ? (
+            <Card>
+              <Text c="dimmed" ta="center" py="md">
+                {t("Competition hasn't started yet. Check the schedule for upcoming tournaments.")}
+              </Text>
+            </Card>
+          ) : (
+            <SimpleGrid cols={{ base: 1, xs: 2, lg: 3 }} spacing="sm">
+              {seasonTournaments.map((tournament) => (
+                <TournamentCard key={tournament.id} tournament={tournament} isAdmin={isAdmin} />
+              ))}
+            </SimpleGrid>
+          )}
+        </Tabs.Panel>
+        <Tabs.Panel value="custom">
+          {customTournaments.length === 0 ? (
+            <Card>
+              <Text c="dimmed" ta="center" py="md">{t('No open custom tournaments right now.')}</Text>
+              <Button component="a" href="/tournaments#create" variant="subtle" size="compact-sm" mx="auto">
+                {t('Create tournament')}
+              </Button>
+            </Card>
+          ) : (
+            <SimpleGrid cols={{ base: 1, xs: 2, lg: 3 }} spacing="sm">
+              {customTournaments.map((tournament) => (
+                <TournamentCard key={tournament.id} tournament={tournament} isAdmin={isAdmin} />
+              ))}
+            </SimpleGrid>
+          )}
+        </Tabs.Panel>
+      </Tabs>
     </Stack>
   );
 }
diff --git a/frontend/src/pages/GameMl.tsx b/frontend/src/pages/GameMl.tsx
index bbad37e0b..5d11038ec 100644
--- a/frontend/src/pages/GameMl.tsx
+++ b/frontend/src/pages/GameMl.tsx
@@ -1,5 +1,5 @@
-import { Head } from '@inertiajs/react';
-import { Alert, Button, Stack } from '@mantine/core';
+import { Head, router } from '@inertiajs/react';
+import { Alert, Button, NativeSelect, NumberInput, Paper, Stack, Textarea } from '@mantine/core';
 import { IconAlertTriangle, IconArrowLeft, IconRefresh } from '@tabler/icons-react';
 import { useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
@@ -18,12 +18,13 @@ interface GameMlProps {
   can_manage?: boolean;
   players: MlPlayer[];
   batches: MlBatch[];
+  reviews?: { id: number; user_id: number; reviewer_id: number; outcome: string; reason: string; replay_offset_ms: number | null }[];
 }
 
 /** Bot/human signal review of a game: each player's risk report from editor telemetry. */
 export default function GameMl() {
   const { t } = useTranslation();
-  const { game_id: gameId, can_manage: canManage = false, players = [], batches = [] } = useSharedProps<GameMlProps>();
+  const { game_id: gameId, can_manage: canManage = false, players = [], batches = [], reviews = [] } = useSharedProps<GameMlProps>();
 
   // One column per player, left to right: verdict, per-batch charts, the metrics head to head, code.
   const columns = useMemo<MlColumn[]>(() => {
@@ -43,7 +44,7 @@ export default function GameMl() {
       <PageHeader
         title={t('Game #%{id}: bot/human signal review', { id: gameId })}
         subtitle={t(
-          'Higher risk score / more signals → more bot-like. Always confirm by playing back the editor history. Reports are computed once and cached; Re-analyze forces a fresh run.',
+          'Review aid, not a bot verdict. Missing signals do not prove fair play. Confirm against the replay before taking action.',
         )}
         actions={
           <>
@@ -69,6 +70,28 @@ export default function GameMl() {
           <BatchCharts columns={columns} />
           <VersusTable columns={columns} />
           <CodeColumns columns={columns} />
+          {canManage && players.filter(player => !player.is_bot).map(player => (
+            <form key={player.id} onSubmit={event => {
+              event.preventDefault();
+              const data = Object.fromEntries(new FormData(event.currentTarget));
+              router.post(`/games/${gameId}/ml/reviews`, { ...data, user_id: player.id });
+            }}>
+              <Paper withBorder p="md"><Stack gap="xs">
+                <strong>{t('Moderator review')}: {player.name}</strong>
+                <NativeSelect name="outcome" label={t('Outcome')} required data={[
+                  { value: 'inconclusive', label: t('Inconclusive') },
+                  { value: 'legitimate', label: t('Legitimate') },
+                  { value: 'confirmed_assistance', label: t('Confirmed unauthorized assistance') },
+                ]} />
+                <NumberInput label={t('Replay position (ms)')} name="replay_offset_ms" min={0} allowDecimal={false} />
+                <Textarea label={t('Reason')} name="reason" required minLength={10} maxLength={5000} />
+                <Button type="submit">{t('Save review')}</Button>
+                {reviews.filter(review => review.user_id === player.id).map(review => (
+                  <div key={review.id}>{review.outcome}: {review.reason} ({t('Reviewer')} #{review.reviewer_id}, {review.replay_offset_ms ?? '—'} ms)</div>
+                ))}
+              </Stack></Paper>
+            </form>
+          ))}
         </Stack>
       )}
     </AppLayout>
diff --git a/frontend/src/pages/Landing.tsx b/frontend/src/pages/Landing.tsx
index 20b2dfb14..429327ce3 100644
--- a/frontend/src/pages/Landing.tsx
+++ b/frontend/src/pages/Landing.tsx
@@ -254,7 +254,7 @@ export default function Landing() {
           <SimpleGrid cols={{ base: 1, sm: 3 }} spacing="lg">
             {[
               [t('Choose your language'), t('Preview an approachable task before starting. Your practice opponent is a bot.')],
-              [t('Write it. Run it.'), t('Fill in the solution and run the tests. Use the results to improve your code.')],
+              [t('Write code and run tests'), t('Fill in the solution and run the tests. Use the results to improve your code.')],
               [t('Play again or meet a rival'), t('Try another task, then create an account to challenge real players.')],
             ].map(([title, text], index) => (
               <Card key={title} className={classes.step} padding="lg" style={{ '--medal': `var(--cb-medal-${index + 1})` } as CSSProperties}>
diff --git a/frontend/test/telemetry.test.mjs b/frontend/test/telemetry.test.mjs
new file mode 100644
index 000000000..5fe6fb6cc
--- /dev/null
+++ b/frontend/test/telemetry.test.mjs
@@ -0,0 +1,71 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { addEvent, contentMetrics, finalize, SYNC_EDIT_SOURCE } from '../src/features/game/editor/telemetry.ts';
+
+const edit = (metadata) => ({
+  changes: [{ text: 'const answer = 42;\n'.repeat(10), rangeLength: 0 }],
+  detailedReasons: [{ metadata }],
+  detailedReasonsChangeLengths: [1],
+});
+
+test('Vim commands remain visible as assistance rather than unexplained injection', () => {
+  const metrics = contentMetrics(edit({ source: 'unknown', name: 'vim' }));
+  assert.equal(metrics.command_insert_count, 1);
+  assert.equal(metrics.assisted_chars, metrics.inserted_chars);
+  assert.equal(metrics.large_insert_count, 0);
+  assert.equal(metrics.multi_line_insert_count, 0);
+});
+
+test('unrecognized external edits still produce bulk-insert evidence', () => {
+  const metrics = contentMetrics(edit({ source: 'unknown', name: 'extension' }));
+  assert.equal(metrics.assisted_chars, 0);
+  assert.equal(metrics.large_insert_count, 1);
+  assert.equal(metrics.multi_line_insert_count, 1);
+});
+
+test('our own text syncs are excluded, while ordinary completions remain accounted for', () => {
+  assert.equal(contentMetrics(edit({ source: 'unknown', name: SYNC_EDIT_SOURCE })), null);
+  const metrics = contentMetrics(edit({ source: 'suggest' }));
+  assert.equal(metrics.assisted_chars, metrics.inserted_chars);
+  assert.equal(metrics.completion_insert_count, 1);
+});
+
+test('flushed windows retain the key boundaries needed to count pauses between windows', () => {
+  const key = (offset_ms) => ({ type: 'keydown', key: 'a', lang_slug: 'js', offset_ms });
+  let first = addEvent(null, key(100));
+  first = addEvent(first, key(200));
+  const before = finalize(first);
+  const after = finalize(addEvent(null, key(5200)));
+  assert.equal(before.collector_version, 3);
+  assert.equal(before.first_key_offset_ms, 100);
+  assert.equal(before.last_key_offset_ms, 200);
+  assert.equal(after.first_key_offset_ms - before.last_key_offset_ms, 5000);
+  assert.equal(after.last_key_offset_ms, 5200);
+});
+
+test('a pause within a window agrees with its maximum key interval', () => {
+  let window = addEvent(null, { type: 'keydown', key: 'a', lang_slug: 'js', offset_ms: 0 });
+  window = addEvent(window, { type: 'keydown', key: 'b', lang_slug: 'js', offset_ms: 2500 });
+  const summary = finalize(window);
+  assert.equal(summary.idle_pause_over_2s_count, 1);
+  assert.equal(summary.max_key_delta_ms, 2500);
+});
+
+
+test('bulk edit evidence retains local explanations and timestamps separately', () => {
+  const base = { type: 'content_change', lang_slug: 'js', change_count: 1, inserted_chars: 100 };
+  let window = addEvent(null, { ...base, offset_ms: 1000, assisted_chars: 100 });
+  window = addEvent(window, { ...base, offset_ms: 5000 });
+  assert.deepEqual(finalize(window).edit_evidence, [
+    { offset_ms: 1000, inserted_chars: 100, assisted_chars: 100, paste_chars: 0, printable_keys: 0 },
+    { offset_ms: 5000, inserted_chars: 100, assisted_chars: 0, paste_chars: 0, printable_keys: 0 },
+  ]);
+});
+
+
+test('IME composition does not become an unexplained bulk edit', () => {
+  const metrics = contentMetrics(edit({ source: 'cursor', kind: 'compositionEnd' }));
+  assert.equal(metrics.assisted_chars, metrics.inserted_chars);
+  assert.equal(metrics.large_insert_count, 0);
+});
diff --git a/lib/codebattle/game/bot_detection.ex b/lib/codebattle/game/bot_detection.ex
index e450ede7c..0ab1c1e61 100644
--- a/lib/codebattle/game/bot_detection.ex
+++ b/lib/codebattle/game/bot_detection.ex
@@ -44,7 +44,7 @@ defmodule Codebattle.Game.BotDetection do
   alias Codebattle.User
 
   # Bump when the scoring or the stats change: older persisted reports are recomputed on read.
-  @report_version 3
+  @report_version 6
   @after_game_delay_sec 10
 
   @doc """
@@ -64,11 +64,13 @@ defmodule Codebattle.Game.BotDetection do
           |> Helpers.get_players()
           |> Enum.reject(&ignored_player?/1)
 
-        history = if players == [], do: %{}, else: EditorHistory.summarize(game)
+        replay = if players == [], do: %{texts: %{}, summaries: %{}}, else: EditorHistory.snapshot(game)
 
         analyses =
           Enum.map(players, fn player ->
-            analyze_player(game, player, Map.get(batches_by_user, player.id, []), Map.get(history, player.id))
+            player = competitive_player(player, replay.texts[player.id])
+
+            analyze_player(game, player, Map.get(batches_by_user, player.id, []), Map.get(replay.summaries, player.id))
           end)
 
         {:ok, analyses}
@@ -86,17 +88,21 @@ defmodule Codebattle.Game.BotDetection do
   """
   @spec analyze_player(map(), map(), [EditorEventBatch.t()], map() | nil) :: Analysis.t()
   def analyze_player(game, player, batches, history \\ nil) do
-    stats = BatchAggregator.aggregate(batches)
+    snapshot = EditorEventBatch.snapshot(batches)
+    competitive = competitive_batches(batches, game_duration_ms(game))
+    stats = BatchAggregator.aggregate(competitive, duration_ms: game_duration_ms(game))
     final_text = Map.get(player, :editor_text) || ""
     final_lang = Map.get(player, :editor_lang) || Map.get(player, :lang)
     code_analysis = CodeAnalyzer.analyze(final_text)
     template_length = LanguageTemplates.length_for(Map.get(game, :task), final_lang)
     final_length = String.length(final_text)
     effective = max(0, final_length - template_length)
+    stats = add_quality_limits(stats, effective, length(batches) - length(competitive))
 
-    %{score: score, level: level, signals: signals} =
+    %{score: score, level: level, signals: signals, evidence: evidence} =
       RiskScorer.score(%{
         stats: stats,
+        batches: competitive,
         code_analysis: code_analysis,
         editor_history: history,
         final_length: final_length,
@@ -109,9 +115,11 @@ defmodule Codebattle.Game.BotDetection do
       score: score,
       level: level,
       signals: signals,
+      evidence: evidence,
       stats: stats,
       code_analysis: code_analysis,
       editor_history: history,
+      telemetry_snapshot: snapshot_for_game(snapshot, game),
       final_length: final_length,
       template_length: template_length,
       effective_added_length: effective,
@@ -199,19 +207,39 @@ defmodule Codebattle.Game.BotDetection do
   @spec get_or_analyze(pos_integer() | String.t()) ::
           {:ok, [Analysis.t()]} | {:error, term()}
   def get_or_analyze(game_id) do
-    reports = list_reports(game_id)
-
-    if reports != [] and Enum.all?(reports, &(&1.version >= @report_version)) do
-      {:ok, Enum.map(reports, &report_to_analysis/1)}
-    else
-      with {:ok, analyses} <- analyze_game(game_id),
-           {:ok, _reports} <- persist_analyses(analyses) do
-        {:ok, analyses}
+    with {:ok, game} <- GameContext.fetch_game(game_id) do
+      players = game |> Helpers.get_players() |> Enum.reject(&ignored_player?/1)
+      reports = game_id |> list_reports() |> Map.new(&{&1.user_id, &1})
+      snapshots = EditorEventBatch.snapshots_by_user(game.id)
+
+      if game.state in ["game_over", "timeout"] and
+           Enum.all?(players, &fresh_report?(reports[&1.id], snapshots[&1.id], game)) do
+        {:ok, Enum.map(players, &report_to_analysis(reports[&1.id]))}
+      else
+        refresh_analyses(game_id)
       end
     end
   end
 
-  @doc "Inverse of `PlayerReport.from_analysis/1` (no `final_text`/`final_lang`)."
+  defp refresh_analyses(game_id) do
+    with {:ok, analyses} <- analyze_game(game_id),
+         {:ok, _reports} <- persist_analyses(analyses) do
+      {:ok, analyses}
+    end
+  end
+
+  defp fresh_report?(nil, _snapshot, _game), do: false
+
+  defp fresh_report?(report, snapshot, game) do
+    report.version >= @report_version and not is_nil(report.final_text) and
+      report.telemetry_snapshot == snapshot_for_game(snapshot || EditorEventBatch.snapshot([]), game)
+  end
+
+  defp snapshot_for_game(snapshot, game) do
+    Map.merge(snapshot, %{"game_state" => Map.get(game, :state), "duration_ms" => game_duration_ms(game)})
+  end
+
+  @doc "Inverse of `PlayerReport.from_analysis/1`."
   @spec report_to_analysis(PlayerReport.t()) :: Analysis.t()
   def report_to_analysis(%PlayerReport{} = r) do
     %Analysis{
@@ -220,10 +248,14 @@ defmodule Codebattle.Game.BotDetection do
       score: r.score,
       level: level_to_atom(r.level),
       signals: r.signals || [],
+      evidence: r.evidence || [],
       # No telemetry is stored as an empty map.
       stats: if(r.stats == %{}, do: nil, else: stringify_keys(r.stats)),
       code_analysis: stringify_keys(r.code_analysis),
       editor_history: if(r.editor_history == %{}, do: nil, else: r.editor_history),
+      telemetry_snapshot: r.telemetry_snapshot,
+      final_text: r.final_text,
+      final_lang: r.final_lang,
       final_length: r.final_length,
       template_length: r.template_length,
       effective_added_length: r.effective_added_length
@@ -279,6 +311,34 @@ defmodule Codebattle.Game.BotDetection do
 
   # ── helpers ──────────────────────────────────────────────────────────
 
+  defp competitive_player(player, {text, lang}), do: %{player | editor_text: text, editor_lang: lang}
+  defp competitive_player(player, _), do: player
+
+  defp competitive_batches(batches, nil), do: batches
+
+  defp competitive_batches(batches, duration) do
+    Enum.filter(batches, &(&1.window_end_offset_ms <= duration))
+  end
+
+  defp add_quality_limits(nil, _effective, _excluded), do: nil
+
+  defp add_quality_limits(stats, effective, excluded) do
+    issues = stats.quality_issues
+
+    issues =
+      if effective >= 60 and stats.total_chars_inserted < effective * 0.6,
+        do: ["incomplete_edit_coverage" | issues],
+        else: issues
+
+    issues = if excluded > 0, do: ["excluded_post_game_batches" | issues], else: issues
+    Map.merge(stats, %{quality_issues: issues, excluded_batch_count: excluded})
+  end
+
+  defp game_duration_ms(%{state: state, duration_sec: seconds})
+       when state in ["game_over", "timeout"] and is_integer(seconds) and seconds >= 0, do: seconds * 1000 + 999
+
+  defp game_duration_ms(_game), do: nil
+
   defp to_int(id) when is_integer(id), do: id
   defp to_int(id) when is_binary(id), do: String.to_integer(id)
 
diff --git a/lib/codebattle/game/bot_detection/analysis.ex b/lib/codebattle/game/bot_detection/analysis.ex
index fe9a9527b..311542881 100644
--- a/lib/codebattle/game/bot_detection/analysis.ex
+++ b/lib/codebattle/game/bot_detection/analysis.ex
@@ -13,9 +13,11 @@ defmodule Codebattle.Game.BotDetection.Analysis do
           score: non_neg_integer(),
           level: level(),
           signals: [String.t()],
+          evidence: [map()],
           stats: map() | nil,
           code_analysis: map() | nil,
           editor_history: map() | nil,
+          telemetry_snapshot: map(),
           final_length: non_neg_integer(),
           template_length: non_neg_integer(),
           effective_added_length: non_neg_integer(),
@@ -28,9 +30,11 @@ defmodule Codebattle.Game.BotDetection.Analysis do
             score: 0,
             level: :none,
             signals: [],
+            evidence: [],
             stats: nil,
             code_analysis: nil,
             editor_history: nil,
+            telemetry_snapshot: %{},
             final_length: 0,
             template_length: 0,
             effective_added_length: 0,
diff --git a/lib/codebattle/game/bot_detection/batch_aggregator.ex b/lib/codebattle/game/bot_detection/batch_aggregator.ex
index e95131f77..1d8b50d20 100644
--- a/lib/codebattle/game/bot_detection/batch_aggregator.ex
+++ b/lib/codebattle/game/bot_detection/batch_aggregator.ex
@@ -19,16 +19,24 @@ defmodule Codebattle.Game.BotDetection.BatchAggregator do
   every batch reports them, so the scorer needs no blanket paste discount.
   """
 
+  alias Codebattle.Game.BotDetection.TelemetryQuality
+
   @type batch :: map()
   @type stats :: map()
 
   @doc "Returns the aggregated stats map, or `nil` for an empty batch list."
-  @spec aggregate([batch()]) :: stats() | nil
-  def aggregate([]), do: nil
+  @spec aggregate([batch()], keyword()) :: stats() | nil
+  def aggregate(batches, opts \\ [])
+  def aggregate([], _opts), do: nil
+
+  def aggregate(batches, opts) when is_list(batches) do
+    batches = Enum.sort_by(batches, &num(summary(&1), "window_start_offset_ms"))
+    quality = batches |> Enum.map(&summary/1) |> TelemetryQuality.analyze(opts)
+    gaps = quality.boundary_deltas
+    initial = {Enum.sum(gaps), length(gaps), Enum.min(gaps, fn -> nil end), Enum.max(gaps, fn -> 0 end)}
 
-  def aggregate(batches) when is_list(batches) do
     {weighted_avg_numer, weighted_avg_denom, min_key_delta_acc, max_key_delta_acc} =
-      Enum.reduce(batches, {0, 0, nil, 0}, fn batch, {wa_n, wa_d, min_d, max_d} ->
+      Enum.reduce(batches, initial, fn batch, {wa_n, wa_d, min_d, max_d} ->
         s = summary(batch)
         samples = num(s, "key_delta_sample_count")
         avg = num(s, "avg_key_delta_ms")
@@ -74,13 +82,20 @@ defmodule Codebattle.Game.BotDetection.BatchAggregator do
       total_paste_attempts: sum(batches, "paste_shortcut_attempt_count"),
       total_assisted_chars: sum(batches, "assisted_chars"),
       total_completion_inserts: sum(batches, "completion_insert_count"),
+      total_command_inserts: sum(batches, "command_insert_count"),
       total_paste_chars: sum(batches, "paste_chars"),
       paste_tracked: Enum.all?(batches, &Map.has_key?(summary(&1), "paste_chars")),
+      focus_tracked:
+        Enum.all?(batches, &(Map.has_key?(summary(&1), "blur_count") and Map.has_key?(summary(&1), "away_ms"))),
       total_blurs: sum(batches, "blur_count"),
       total_away_ms: sum(batches, "away_ms"),
       total_copy_shortcuts: sum(batches, "copy_shortcut_count"),
       total_cut_shortcuts: sum(batches, "cut_shortcut_count"),
-      total_idle_pauses: sum(batches, "idle_pause_over_2s_count"),
+      total_idle_pauses: sum(batches, "idle_pause_over_2s_count") + Enum.count(gaps, &(&1 >= 2_000)),
+      timing_reliable: quality.timing_reliable,
+      idle_pauses_reliable: quality.idle_pauses_reliable,
+      quality_issues: quality.quality_issues,
+      collector_versions: quality.collector_versions,
       total_backspace: sum(batches, "backspace_count"),
       total_delete: sum(batches, "delete_count"),
       total_arrows: sum(batches, "arrow_key_count"),
@@ -100,7 +115,7 @@ defmodule Codebattle.Game.BotDetection.BatchAggregator do
     }
   end
 
-  def aggregate(_), do: nil
+  def aggregate(_, _opts), do: nil
 
   # ── internals ─────────────────────────────────────────────────────────
 
diff --git a/lib/codebattle/game/bot_detection/editor_history.ex b/lib/codebattle/game/bot_detection/editor_history.ex
index abe35564b..40f7b1a7f 100644
--- a/lib/codebattle/game/bot_detection/editor_history.ex
+++ b/lib/codebattle/game/bot_detection/editor_history.ex
@@ -2,9 +2,8 @@ defmodule Codebattle.Game.BotDetection.EditorHistory do
   @moduledoc """
   The server's own record of each player's editor: the text updates it received
   (`editor:data`, sent by the client at most every 250 ms), replayed from the
-  game's playbook. Unlike the client telemetry it can't be faked by sending
-  made-up summaries: code that shows up here without the keystrokes to match was
-  not typed in the editor.
+  game's playbook. This confirms what code reached the server, not how it was
+  entered: network gaps, undo and editor commands can also create large updates.
 
   Per player it reports how many updates came in and the largest jump: the most
   non-whitespace characters one update added. Language switches and resets to
@@ -25,25 +24,40 @@ defmodule Codebattle.Game.BotDetection.EditorHistory do
   @doc "A `summary` per player id, for players with editor records in the game."
   @spec summarize(map()) :: %{optional(integer()) => summary()}
   def summarize(game) do
-    game
-    |> records()
-    |> summarize_records(Map.get(game, :task))
+    snapshot(game).summaries
+  end
+
+  @doc "Read the replay once, keeping code and evidence at the same competitive boundary."
+  def snapshot(game) do
+    records = records(game)
+    completed = Map.get(game, :state) in ["game_over", "timeout"]
+
+    markers =
+      if completed and is_nil(Map.get(game, :tournament_id)),
+        do: ["game_over", "timeout", "give_up"],
+        else: ["game_over", "timeout"]
+
+    competitive = Enum.take_while(records, &(type(&1) not in markers))
+    {texts, summaries} = Enum.reduce(competitive, {%{}, %{}}, &replay(&1, &2, Map.get(game, :task)))
+    %{texts: texts, summaries: summaries}
   end
 
   @doc "Same, from records in playbook order (oldest first)."
   @spec summarize_records([map()], map() | nil) :: %{optional(integer()) => summary()}
   def summarize_records(records, task \\ nil) do
-    {_texts, summaries} = Enum.reduce(records, {%{}, %{}}, &replay(&1, &2, task))
+    {_texts, summaries} = Enum.reduce(competitive_records(records), {%{}, %{}}, &replay(&1, &2, task))
     summaries
   end
 
+  defp competitive_records(records), do: Enum.take_while(records, &(type(&1) not in ["game_over", "timeout"]))
+
   # `texts`: each player's editor text and language so far.
   defp replay(record, {texts, summaries}, task) do
     case {type(record), get(record, :id)} do
       {"init", id} when not is_nil(id) ->
         {Map.put(texts, id, {get(record, :editor_text) || "", get(record, :editor_lang)}), summaries}
 
-      {"update_editor_data", id} when not is_nil(id) ->
+      {kind, id} when kind in ["update_editor_data", "check_complete"] and not is_nil(id) ->
         {before, lang} = Map.get(texts, id, {"", nil})
         {next, next_lang} = next_text(record, before, lang)
         {Map.put(texts, id, {next, next_lang}), count_update(summaries, id, jump(before, next, lang, next_lang, task))}
@@ -103,28 +117,17 @@ defmodule Codebattle.Game.BotDetection.EditorHistory do
     IO.iodata_to_binary([Enum.reverse(out), rest])
   end
 
-  # Non-whitespace characters of the text that replaced the changed middle part.
+  # Inserted non-whitespace characters; unchanged text between separate edits is excluded.
   @doc false
   def added_chars(before, next) do
-    prefix = char_start(next, :binary.longest_common_prefix([before, next]), -1)
-    max_suffix = min(byte_size(before), byte_size(next)) - prefix
-    suffix = min(:binary.longest_common_suffix([before, next]), max_suffix)
-    # The common parts are byte runs: move both cuts to character starts.
-    suffix = byte_size(next) - char_start(next, byte_size(next) - suffix, 1)
-    middle = binary_part(next, prefix, byte_size(next) - prefix - suffix)
-
-    middle |> String.split() |> Enum.join() |> String.length()
-  end
-
-  # The nearest offset (stepping by `step`) that doesn't fall inside a UTF-8 character.
-  defp char_start(text, offset, step) do
-    if offset > 0 and offset < byte_size(text) and continuation?(:binary.at(text, offset)),
-      do: char_start(text, offset + step, step),
-      else: offset
+    before
+    |> String.myers_difference(next)
+    |> Enum.reduce(0, fn
+      {:ins, text}, count -> count + (text |> String.split() |> Enum.join() |> String.length())
+      _, count -> count
+    end)
   end
 
-  defp continuation?(byte), do: Bitwise.band(byte, 0xC0) == 0x80
-
   defp template?(_text, nil, _lang), do: false
   defp template?(_text, _task, nil), do: false
 
diff --git a/lib/codebattle/game/bot_detection/evaluation.ex b/lib/codebattle/game/bot_detection/evaluation.ex
new file mode 100644
index 000000000..6612f40e3
--- /dev/null
+++ b/lib/codebattle/game/bot_detection/evaluation.ex
@@ -0,0 +1,34 @@
+defmodule Codebattle.Game.BotDetection.Evaluation do
+  @moduledoc "Evaluate reviewed cases without interpreting complaints as ground truth."
+
+  def summarize(cases) do
+    labelled = Enum.filter(cases, &(&1.outcome in ["confirmed_assistance", "legitimate"]))
+
+    counts =
+      Enum.frequencies_by(labelled, fn row ->
+        {row.outcome, row.score >= 5}
+      end)
+
+    tp = Map.get(counts, {"confirmed_assistance", true}, 0)
+    fp = Map.get(counts, {"legitimate", true}, 0)
+    fn_count = Map.get(counts, {"confirmed_assistance", false}, 0)
+    tn = Map.get(counts, {"legitimate", false}, 0)
+
+    %{
+      reviewed: length(cases),
+      labelled: length(labelled),
+      inconclusive: length(cases) - length(labelled),
+      true_positive: tp,
+      false_positive: fp,
+      false_negative: fn_count,
+      true_negative: tn,
+      precision: ratio(tp, tp + fp),
+      recall: ratio(tp, tp + fn_count),
+      false_positive_rate: ratio(fp, fp + tn),
+      players: labelled |> Enum.map(& &1.user_id) |> Enum.uniq() |> length()
+    }
+  end
+
+  defp ratio(_numerator, 0), do: nil
+  defp ratio(numerator, denominator), do: numerator / denominator
+end
diff --git a/lib/codebattle/game/bot_detection/player_report.ex b/lib/codebattle/game/bot_detection/player_report.ex
index 1e8bbec39..ab02467cd 100644
--- a/lib/codebattle/game/bot_detection/player_report.ex
+++ b/lib/codebattle/game/bot_detection/player_report.ex
@@ -23,9 +23,13 @@ defmodule Codebattle.Game.BotDetection.PlayerReport do
              :score,
              :level,
              :signals,
+             :evidence,
              :stats,
              :code_analysis,
              :editor_history,
+             :telemetry_snapshot,
+             :final_text,
+             :final_lang,
              :final_length,
              :template_length,
              :effective_added_length,
@@ -40,11 +44,15 @@ defmodule Codebattle.Game.BotDetection.PlayerReport do
 
     field(:score, :integer, default: 0)
     field(:level, :string, default: "none")
+    field(:evidence, {:array, :map}, default: [])
     field(:signals, {:array, :string}, default: [])
     field(:stats, :map, default: %{})
     field(:code_analysis, :map, default: %{})
     # BotDetection.EditorHistory: the editor updates the server received.
     field(:editor_history, :map, default: %{})
+    field(:telemetry_snapshot, :map, default: %{})
+    field(:final_text, :string)
+    field(:final_lang, :string)
     field(:final_length, :integer, default: 0)
     field(:template_length, :integer, default: 0)
     field(:effective_added_length, :integer, default: 0)
@@ -62,9 +70,13 @@ defmodule Codebattle.Game.BotDetection.PlayerReport do
       :score,
       :level,
       :signals,
+      :evidence,
       :stats,
       :code_analysis,
       :editor_history,
+      :telemetry_snapshot,
+      :final_text,
+      :final_lang,
       :final_length,
       :template_length,
       :effective_added_length,
@@ -90,9 +102,13 @@ defmodule Codebattle.Game.BotDetection.PlayerReport do
       score: a.score,
       level: Atom.to_string(a.level),
       signals: a.signals,
+      evidence: a.evidence,
       stats: a.stats || %{},
       code_analysis: a.code_analysis || %{},
       editor_history: a.editor_history || %{},
+      telemetry_snapshot: a.telemetry_snapshot,
+      final_text: a.final_text,
+      final_lang: a.final_lang,
       final_length: a.final_length,
       template_length: a.template_length,
       effective_added_length: a.effective_added_length
diff --git a/lib/codebattle/game/bot_detection/review.ex b/lib/codebattle/game/bot_detection/review.ex
new file mode 100644
index 000000000..91f3b9c4b
--- /dev/null
+++ b/lib/codebattle/game/bot_detection/review.ex
@@ -0,0 +1,58 @@
+defmodule Codebattle.Game.BotDetection.Review do
+  @moduledoc "Append-only moderator decisions, separate from heuristic reports and complaints."
+  use Ecto.Schema
+
+  import Ecto.Changeset
+  import Ecto.Query
+
+  alias Codebattle.Game.BotDetection
+  alias Codebattle.Game.BotDetection.PlayerReport
+  alias Codebattle.Repo
+  alias Codebattle.User
+
+  @derive {Jason.Encoder,
+           only: [:id, :user_id, :reviewer_id, :outcome, :reason, :replay_offset_ms, :report_version, :inserted_at]}
+  schema "game_fair_play_reviews" do
+    belongs_to :game, Codebattle.Game
+    belongs_to :user, User
+    belongs_to :reviewer, User
+    field :outcome, :string
+    field :reason, :string
+    field :replay_offset_ms, :integer
+    field :report_version, :integer
+    field :report_snapshot, :map
+    timestamps(updated_at: false)
+  end
+
+  def record(reviewer, game_id, user_id, attrs) do
+    if User.admin_or_moderator?(reviewer) do
+      case BotDetection.get_report(game_id, user_id) do
+        %PlayerReport{} = report ->
+          %__MODULE__{}
+          |> cast(attrs, [:outcome, :reason, :replay_offset_ms])
+          |> put_change(:game_id, report.game_id)
+          |> put_change(:user_id, report.user_id)
+          |> put_change(:reviewer_id, reviewer.id)
+          |> put_change(:report_version, report.version)
+          |> put_change(:report_snapshot, Map.take(report, [:score, :level, :signals, :evidence, :telemetry_snapshot]))
+          |> validate_required([:outcome, :reason])
+          |> validate_inclusion(:outcome, ~w(confirmed_assistance legitimate inconclusive))
+          |> validate_length(:reason, min: 10, max: 5000)
+          |> validate_number(:replay_offset_ms, greater_than_or_equal_to: 0)
+          |> foreign_key_constraint(:game_id)
+          |> foreign_key_constraint(:user_id)
+          |> foreign_key_constraint(:reviewer_id)
+          |> Repo.insert()
+
+        nil ->
+          {:error, :report_not_found}
+      end
+    else
+      {:error, :forbidden}
+    end
+  end
+
+  def list(game_id) do
+    Repo.all(from r in __MODULE__, where: r.game_id == ^game_id, order_by: [desc: r.id])
+  end
+end
diff --git a/lib/codebattle/game/bot_detection/risk_scorer.ex b/lib/codebattle/game/bot_detection/risk_scorer.ex
index c20fe115a..479d59dfc 100644
--- a/lib/codebattle/game/bot_detection/risk_scorer.ex
+++ b/lib/codebattle/game/bot_detection/risk_scorer.ex
@@ -1,104 +1,174 @@
 defmodule Codebattle.Game.BotDetection.RiskScorer do
   @moduledoc """
-  Pure risk-scoring logic. Given pre-aggregated stats, code analysis and
-  the lengths of the final/template solution, returns a score, a level,
-  and a list of human-readable signals that contributed to the score.
-
-  Heuristics are organised in three tiers (highest weight first):
-
-    * **Tier 1 — programmatic injection signatures**: chars-inserted-vs-keys
-      gap, content-changes-without-keys, multi-char ops with no keys, bulk
-      single-event inserts, large/multi-line inserts. These are the
-      strongest signals and cover AI extensions (Perplexity, Copilot,
-      autotyper userscripts) and pure WebSocket injection bots.
-
-    * **Tier 2 — LLM-style content**: high comment-to-code ratio,
-      long pasted-explanation comments, GPT-tell phrases (English + Russian).
-
-    * **Tier 3 — typing rhythm anomalies**: zero idle pauses, no backspace
-      across substantial edits, very fast typing, suspiciously uniform
-      key-delta timings.
-
-  Self-paste (user copies their own code via Cmd+C / Cmd+V) is respected.
-  Newer telemetry counts pasted chars (`paste_tracked`) and keeps them out of
-  the injection counters, so those keep their full weight; for older batches,
-  a paste shortcut pressed anywhere *significantly* discounts Tier 1 weights.
-
-  Two signals don't come from the code or the keystrokes: time spent away from
-  the game (another tab or window) and, from the server's own copy of the
-  editor (`EditorHistory`), code that showed up between two editor updates.
+  Review priorities, not bot verdicts or probabilities. Modern collectors supply
+  individual edit evidence. Legacy counters are scored per collection window,
+  so a paste in another window cannot explain an unrelated insertion.
+  Overlapping edit rules use their maximum; rhythm and blocked-paste clues are
+  capped below the review threshold. Code style, focus loss, absent pauses,
+  missing deletions and incomplete telemetry never contribute suspicion.
   """
 
-  @no_telemetry_solution_min_chars 20
   @injection_min_inserted 8
   @bulk_insert_min 8
   @bulk_insert_large_threshold 50
-  @coverage_eval_min_added 60
-  @gpt_eval_min_added 60
-  @no_backspace_min_chars 150
   @fast_typing_max_avg_ms 30
   @fast_typing_min_keys 30
   @uniform_timing_max_diff_ms 10
   @uniform_timing_min_keys 30
-  @idle_pause_min_keys 50
-  @idle_pause_min_session_sec 30
-  @long_comment_min 3
-  @comment_ratio_high 0.6
-  @comment_ratio_high_min_lines 4
-  @comment_ratio_medium 0.3
-  @comment_ratio_medium_min_lines 3
-  @away_min_ms 30_000
-  @away_long_ms 120_000
   @jump_min_chars 80
 
   @type input :: %{
           required(:stats) => map() | nil,
-          required(:code_analysis) => map() | nil,
-          required(:final_length) => non_neg_integer(),
-          required(:template_length) => non_neg_integer(),
-          optional(:editor_history) => map() | nil
+          optional(:code_analysis) => map() | nil,
+          optional(:final_length) => non_neg_integer(),
+          optional(:template_length) => non_neg_integer(),
+          optional(:editor_history) => map() | nil,
+          optional(:batches) => [map()]
         }
 
   @type result :: %{
           score: non_neg_integer(),
           level: :none | :low | :medium | :high,
-          signals: [String.t()]
+          signals: [String.t()],
+          evidence: [map()]
         }
 
   @doc "Compute risk score, level and human-readable signals."
   @spec score(input()) :: result()
-  def score(%{stats: stats, code_analysis: code, final_length: fl, template_length: tl} = input) do
-    effective = max(0, fl - (tl || 0))
+  def score(%{batches: batches} = input) when batches != [] do
+    results = Enum.map(batches, &score_batch(&1, input))
+
+    supporting_stats = Map.get(input, :stats)
+
+    supporting =
+      []
+      |> apply_rule(paste_blocked(supporting_stats))
+      |> apply_rule(fast_typing(supporting_stats))
+      |> apply_rule(uniform_timing(supporting_stats))
+
+    supporting_result = %{
+      score: supporting |> Enum.map(& &1.weight) |> Enum.sum() |> min(4),
+      evidence:
+        Enum.map(supporting, fn item ->
+          %{
+            code: item.code,
+            category: "rhythm_or_policy",
+            weight: item.weight,
+            message: item.signal,
+            evidence: %{},
+            replay_offset_ms: nil
+          }
+        end)
+    }
+
+    evidence = Enum.flat_map(results, & &1.evidence) ++ supporting_result.evidence
+    value = Enum.max(Enum.map(results, & &1.score)) + supporting_result.score
+
+    %{
+      score: value,
+      level: classify(value),
+      signals: evidence |> Enum.map(& &1.message) |> Enum.uniq(),
+      evidence: evidence
+    }
+  end
+
+  def score(%{stats: stats} = input) do
     paste_attempted = paste_attempted?(stats)
     history = Map.get(input, :editor_history)
 
-    contributions =
+    # These rules describe overlapping aspects of the same edit. Counting all of
+    # them independently turns one pasted block into several pieces of evidence.
+    edits =
       []
-      |> apply_rule(no_telemetry_with_solution(stats, effective))
       |> apply_rule(programmatic_injection(stats, paste_attempted))
       |> apply_rule(fully_programmatic(stats))
       |> apply_rule(multi_char_with_few_keys(stats, paste_attempted))
       |> apply_rule(bulk_single_insert(stats, paste_attempted))
       |> apply_rule(large_insert(stats, paste_attempted))
       |> apply_rule(multi_line_insert(stats, paste_attempted))
-      |> apply_rule(coverage_mismatch(stats, effective))
-      |> apply_rule(paste_blocked(stats))
       |> apply_rule(editor_jump(history, stats, paste_attempted))
-      |> apply_rule(away_from_game(stats))
-      |> apply_rule(zero_idle_pauses(stats))
-      |> apply_rule(no_backspace(stats))
+      |> Enum.reverse()
+
+    # Rhythm and blocked pastes are supporting clues,
+    # not enough on their own to flag a player for moderator review.
+    supporting =
+      []
+      |> apply_rule(paste_blocked(stats))
       |> apply_rule(fast_typing(stats))
       |> apply_rule(uniform_timing(stats))
-      |> apply_rule(comment_ratio_high(code, effective))
-      |> apply_rule(comment_ratio_medium(code, effective))
-      |> apply_rule(long_comments(code, effective))
-      |> apply_rule(gpt_phrases(code, effective))
       |> Enum.reverse()
 
-    score = contributions |> Enum.map(& &1.weight) |> Enum.sum()
-    signals = Enum.map(contributions, & &1.signal)
+    edit_score = edits |> Enum.map(& &1.weight) |> Enum.max(fn -> 0 end)
+    supporting_score = supporting |> Enum.map(& &1.weight) |> Enum.sum() |> min(4)
+    score = edit_score + supporting_score
+    contributions = edits ++ supporting
+    signals = contributions |> Enum.map(& &1.signal) |> Enum.uniq()
+
+    evidence =
+      Enum.map(contributions, fn item ->
+        %{
+          code: item.code,
+          category: if(item in edits, do: "edit", else: "rhythm_or_policy"),
+          weight: item.weight,
+          message: item.signal,
+          evidence: %{},
+          replay_offset_ms: nil
+        }
+      end)
 
-    %{score: score, level: classify(score), signals: signals}
+    %{score: score, level: classify(score), signals: signals, evidence: evidence}
+  end
+
+  defp score_batch(batch, input) do
+    alias Codebattle.Game.BotDetection.BatchAggregator
+
+    summary = batch.summary
+    events = Map.get(summary, "edit_evidence", [])
+
+    if Map.get(summary, "collector_version", 0) >= 3 and events != [] do
+      evidence =
+        events
+        |> Enum.filter(fn e ->
+          e["inserted_chars"] - e["assisted_chars"] - e["paste_chars"] > max(7, e["printable_keys"] * 2)
+        end)
+        |> Enum.map(fn e ->
+          %{
+            code: "unexplained_edit",
+            category: "edit",
+            weight: 8,
+            message: "Bulk edit with no matching editor command or paste; review the replay",
+            evidence: e,
+            replay_offset_ms: e["offset_ms"]
+          }
+        end)
+
+      %{score: if(evidence == [], do: 0, else: 8), evidence: evidence}
+    else
+      result =
+        input
+        |> Map.delete(:batches)
+        |> Map.put(
+          :stats,
+          [batch]
+          |> BatchAggregator.aggregate()
+          |> Map.put(:timing_reliable, false)
+          |> Map.put(:total_paste_blocked, 0)
+        )
+        |> Map.put(:editor_history, nil)
+        |> score()
+
+      %{
+        score: result.score,
+        evidence:
+          Enum.map(
+            result.evidence,
+            &Map.merge(&1, %{
+              replay_offset_ms: batch.window_start_offset_ms,
+              evidence: %{batch_id: batch.id, legacy_window: true}
+            })
+          )
+      }
+    end
   end
 
   # ── orchestration ────────────────────────────────────────────────────
@@ -122,15 +192,6 @@ defmodule Codebattle.Game.BotDetection.RiskScorer do
 
   # ── Tier 1: programmatic injection ────────────────────────────────────
 
-  defp no_telemetry_with_solution(nil, effective) when effective > @no_telemetry_solution_min_chars do
-    contrib(
-      12,
-      "No keyboard telemetry recorded but #{effective} chars added on top of the language template — code pushed via WebSocket without typing"
-    )
-  end
-
-  defp no_telemetry_with_solution(_, _), do: nil
-
   defp programmatic_injection(nil, _), do: nil
 
   # Editor-assisted chars (auto-indent, closing brackets, completions) arrive without their own
@@ -150,17 +211,19 @@ defmodule Codebattle.Game.BotDetection.RiskScorer do
     gap_share = round((chars - keys) / max(1, chars) * 100)
 
     base =
-      "inserted #{chars} chars but only pressed #{keys} printable key(s) — #{gap_share}% of the content arrived without typing"
+      "inserted #{chars} chars but only pressed #{keys} printable key(s) — #{gap_share}% of the content is not matched to recorded keys"
 
     if paste_attempted do
       contrib(
+        "unexplained_insertions",
         3,
         base <> " (user did press Cmd+V/Cmd+C — could be self-paste)"
       )
     else
       contrib(
+        "unexplained_insertions",
         12,
-        base <> " — no paste shortcuts pressed, looks programmatic (AI/extension/autotyper)"
+        base <> " — unexplained edit window; review the replay and input method"
       )
     end
   end
@@ -168,10 +231,11 @@ defmodule Codebattle.Game.BotDetection.RiskScorer do
   defp fully_programmatic(nil), do: nil
 
   defp fully_programmatic(stats) do
-    if get(stats, :total_content_changes) > 0 and get(stats, :total_key_events) == 0 do
+    if typed_chars(stats) >= @injection_min_inserted and get(stats, :total_key_events) == 0 do
       contrib(
+        "edits_without_keys",
         8,
-        "#{get(stats, :total_content_changes)} content change(s) with zero keypresses — fully programmatic"
+        "#{get(stats, :total_content_changes)} content change(s) with zero recorded keypresses — origin is unknown"
       )
     end
   end
@@ -184,8 +248,9 @@ defmodule Codebattle.Game.BotDetection.RiskScorer do
     multi_deletes = get(stats, :total_multi_char_deletes)
     keys = get(stats, :total_key_events)
 
-    if (multi_inserts > 0 or multi_deletes > 0) and keys <= 3 do
+    if multi_inserts > 0 and keys <= 3 do
       contrib(
+        "multi_character_edit",
         5,
         "#{multi_inserts} multi-char insert(s) and #{multi_deletes} multi-char delete(s) with only #{keys} keypress(es)"
       )
@@ -206,10 +271,11 @@ defmodule Codebattle.Game.BotDetection.RiskScorer do
         nil
 
       paste_attempted ->
-        contrib(1, "bulk insert of #{max_single} chars in one content-change (paste shortcut used)")
+        contrib("bulk_insert", 1, "bulk insert of #{max_single} chars in one content-change (paste shortcut used)")
 
       true ->
         contrib(
+          "bulk_insert",
           4,
           "bulk insert of #{max_single} chars in one content-change with no paste shortcut"
         )
@@ -221,9 +287,9 @@ defmodule Codebattle.Game.BotDetection.RiskScorer do
   defp large_insert(stats, paste_attempted) do
     if get(stats, :total_large_inserts) > 0 do
       n = get(stats, :total_large_inserts)
-      weight = if paste_attempted, do: 2 + n, else: 5 + n
+      weight = if paste_attempted, do: min(2 + n, 4), else: min(5 + n, 8)
 
-      contrib(weight, "#{n} large insert(s) (≥#{@bulk_insert_large_threshold} chars in one event)")
+      contrib("large_insert", weight, "#{n} large insert(s) (≥#{@bulk_insert_large_threshold} chars in one event)")
     end
   end
 
@@ -232,115 +298,49 @@ defmodule Codebattle.Game.BotDetection.RiskScorer do
   defp multi_line_insert(stats, paste_attempted) do
     if get(stats, :total_multi_line_inserts) > 0 do
       n = get(stats, :total_multi_line_inserts)
-      weight = if paste_attempted, do: 1 + n, else: 3 + n
-      contrib(weight, "#{n} multi-line insert(s)")
+      weight = if paste_attempted, do: min(1 + n, 3), else: min(3 + n, 6)
+      contrib("multiline_insert", weight, "#{n} multi-line insert(s)")
     end
   end
 
-  defp coverage_mismatch(nil, _), do: nil
-
-  defp coverage_mismatch(stats, effective) when effective >= @coverage_eval_min_added do
-    chars = get(stats, :total_chars_inserted)
-    ratio = chars / effective
-    ratio_pct = round(ratio * 100)
-
-    cond do
-      ratio < 0.3 ->
-        contrib(
-          6,
-          "typed #{chars} chars but added #{effective} chars on top of template (#{ratio_pct}% typed)"
-        )
-
-      ratio < 0.6 ->
-        contrib(3, "typed only #{ratio_pct}% of the added code — possible large paste")
-
-      true ->
-        nil
-    end
-  end
-
-  defp coverage_mismatch(_, _), do: nil
-
   defp paste_blocked(nil), do: nil
 
   defp paste_blocked(stats) do
     n = get(stats, :total_paste_blocked)
 
     if n > 0 do
-      contrib(2 + n, "#{n} paste-blocked attempt(s) — tried to paste foreign content")
+      contrib("blocked_paste", 2 + n, "#{n} paste-blocked attempt(s) — tried to paste foreign content")
     end
   end
 
-  # The server got the code in a jump no typing explains: an `editor:data` update (the client
-  # sends them at most every 250 ms) added this many non-whitespace chars at once.
+  # A large editor update is a review clue; the 250 ms client throttle does not
+  # guarantee delivery intervals (network gaps and reconnects can coalesce edits).
   defp editor_jump(nil, _stats, _paste_attempted), do: nil
 
-  defp editor_jump(history, stats, paste_attempted) do
+  defp editor_jump(history, _stats, _paste_attempted) do
     jump = get(history, :max_jump)
 
-    cond do
-      jump < @jump_min_chars ->
-        nil
-
-      # Pastes only take the player's own code (the editor's paste guard).
-      stats && get(stats, :total_paste_chars) >= jump ->
-        contrib(1, "#{jump} chars arrived in one editor update — explained by pasting the player's own code")
-
-      stats && (paste_attempted or get(stats, :total_undo) + get(stats, :total_redo) > 0) ->
-        contrib(3, "#{jump} chars arrived in one editor update — maybe an undo or a paste of own code")
-
-      true ->
-        contrib(8, "#{jump} chars arrived in one editor update (≤250 ms) with no paste or undo — not typed in the editor")
-    end
-  end
-
-  # Another tab or window while playing: not proof (docs, a message), but where AI answers are.
-  defp away_from_game(nil), do: nil
-
-  defp away_from_game(stats) do
-    away = get(stats, :total_away_ms)
-    times = get(stats, :total_blurs)
-    seconds = round(away / 1000)
-
-    cond do
-      away >= @away_long_ms -> contrib(4, "left the game #{times} time(s), #{seconds} s away in total")
-      away >= @away_min_ms -> contrib(2, "left the game #{times} time(s), #{seconds} s away in total")
-      true -> nil
+    if jump < @jump_min_chars do
+      nil
+    else
+      contrib(
+        "server_editor_jump",
+        8,
+        "#{jump} chars arrived in one editor update — review the replay and connection gaps; origin is unknown"
+      )
     end
   end
 
   # ── Tier 3: typing rhythm anomalies ──────────────────────────────────
 
-  defp zero_idle_pauses(nil), do: nil
-
-  defp zero_idle_pauses(stats) do
-    if get(stats, :total_idle_pauses) == 0 and
-         get(stats, :elapsed_ms) > @idle_pause_min_session_sec * 1000 and
-         get(stats, :total_key_events) > @idle_pause_min_keys do
-      contrib(2, "zero idle pauses >2s in a long active session")
-    end
-  end
-
-  defp no_backspace(nil), do: nil
-
-  # Replacing a selection deletes too, so a human who never presses Backspace still has
-  # deleted chars.
-  defp no_backspace(stats) do
-    if get(stats, :total_backspace) + get(stats, :total_delete) == 0 and
-         get(stats, :total_chars_deleted) == 0 and
-         typed_chars(stats) > @no_backspace_min_chars do
-      contrib(2, "no backspace/delete across a substantial edit")
-    end
-  end
-
   defp fast_typing(nil), do: nil
 
   defp fast_typing(stats) do
     avg = get(stats, :avg_key_delta_ms)
     keys = get(stats, :total_key_events)
 
-    if avg > 0 and avg < @fast_typing_max_avg_ms and keys > @fast_typing_min_keys do
-      contrib(3, "very fast typing — avg key delta #{round(avg)} ms")
+    if timing_reliable?(stats) and avg > 0 and avg < @fast_typing_max_avg_ms and keys > @fast_typing_min_keys do
+      contrib("fast_typing", 3, "very fast typing — avg key delta #{round(avg)} ms")
     end
   end
 
@@ -351,87 +351,16 @@ defmodule Codebattle.Game.BotDetection.RiskScorer do
     max_d = get(stats, :max_key_delta_ms)
     keys = get(stats, :total_key_events)
 
-    if avg > 0 and max_d > 0 and abs(avg - max_d) < @uniform_timing_max_diff_ms and
+    if timing_reliable?(stats) and avg > 0 and max_d > 0 and abs(avg - max_d) < @uniform_timing_max_diff_ms and
          keys > @uniform_timing_min_keys do
-      contrib(2, "key timing is suspiciously uniform")
-    end
-  end
-
-  # ── Tier 2: LLM-style content ────────────────────────────────────────
-
-  defp comment_ratio_high(nil, _), do: nil
-  defp comment_ratio_high(_, eff) when eff < @gpt_eval_min_added, do: nil
-
-  defp comment_ratio_high(code, _eff) do
-    ratio = get(code, :comment_to_code_ratio)
-    lines = get(code, :comment_lines)
-
-    if ratio >= @comment_ratio_high and lines >= @comment_ratio_high_min_lines do
-      contrib(
-        6,
-        "comment-to-code ratio #{format_ratio(ratio)} with #{lines} comment lines — looks like an AI explanation dump"
-      )
-    end
-  end
-
-  defp comment_ratio_medium(nil, _), do: nil
-  defp comment_ratio_medium(_, eff) when eff < @gpt_eval_min_added, do: nil
-
-  defp comment_ratio_medium(code, _eff) do
-    ratio = get(code, :comment_to_code_ratio)
-    lines = get(code, :comment_lines)
-
-    cond do
-      ratio >= @comment_ratio_high and lines >= @comment_ratio_high_min_lines ->
-        # already handled by comment_ratio_high
-        nil
-
-      ratio >= @comment_ratio_medium and lines >= @comment_ratio_medium_min_lines ->
-        contrib(3, "high comment ratio #{format_ratio(ratio)} (#{lines} comment lines)")
-
-      true ->
-        nil
-    end
-  end
-
-  defp long_comments(nil, _), do: nil
-  defp long_comments(_, eff) when eff < @gpt_eval_min_added, do: nil
-
-  defp long_comments(code, _eff) do
-    n = get(code, :long_comment_lines)
-
-    if n >= @long_comment_min do
-      contrib(
-        2,
-        "#{n} long comment line(s) (>40 chars) — typical of pasted LLM explanations"
-      )
-    end
-  end
-
-  defp gpt_phrases(nil, _), do: nil
-  defp gpt_phrases(_, eff) when eff < @gpt_eval_min_added, do: nil
-
-  defp gpt_phrases(code, _eff) do
-    hits = get(code, :gpt_phrase_hits)
-
-    cond do
-      hits >= 2 ->
-        contrib(
-          4 + hits,
-          "#{hits} GPT-style phrase(s) in the code"
-        )
-
-      hits == 1 ->
-        contrib(3, "1 GPT-style phrase in the code")
-
-      true ->
-        nil
+      contrib("uniform_timing", 2, "key timing is suspiciously uniform")
     end
   end
 
   # ── helpers ──────────────────────────────────────────────────────────
 
-  defp contrib(weight, signal), do: %{weight: weight, signal: signal}
+  defp contrib(code, weight, signal), do: %{code: code, weight: weight, signal: signal}
+  defp timing_reliable?(stats), do: get(stats, :timing_reliable) == true
 
   # Inserted chars a keypress of their own should explain: not editor-assisted, not a self-paste.
   defp typed_chars(stats),
@@ -443,8 +372,4 @@ defmodule Codebattle.Game.BotDetection.RiskScorer do
       v -> v
     end || 0
   end
-
-  defp format_ratio(ratio) when is_number(ratio) do
-    :erlang.float_to_binary(ratio * 1.0, decimals: 2)
-  end
 end
diff --git a/lib/codebattle/game/bot_detection/telemetry_quality.ex b/lib/codebattle/game/bot_detection/telemetry_quality.ex
new file mode 100644
index 000000000..01a651bf6
--- /dev/null
+++ b/lib/codebattle/game/bot_detection/telemetry_quality.ex
@@ -0,0 +1,112 @@
+defmodule Codebattle.Game.BotDetection.TelemetryQuality do
+  @moduledoc "Checks collection capabilities and internal consistency, not whether a player is fair."
+
+  @doc "Summaries use string keys, as stored in editor batches."
+  def analyze(summaries, opts \\ []) do
+    key_windows =
+      summaries |> Enum.filter(&(num(&1, "key_event_count") > 0)) |> Enum.sort_by(&num(&1, "window_start_offset_ms"))
+
+    versions = summaries |> Enum.map(&num(&1, "collector_version")) |> Enum.uniq() |> Enum.sort()
+    boundaries_complete = key_windows != [] and Enum.all?(key_windows, &complete_boundaries?/1)
+    boundaries = if boundaries_complete, do: boundary_deltas(key_windows), else: []
+
+    issues =
+      []
+      |> issue(Enum.any?(summaries, &missing_identity?/1), "missing_batch_identity")
+      |> issue(sequence_gap?(summaries), "missing_batch_sequence")
+      |> issue(
+        summaries |> Enum.map(& &1["collector_session"]) |> Enum.reject(&is_nil/1) |> Enum.uniq() |> length() > 1,
+        "multiple_collector_sessions"
+      )
+      |> issue(Enum.any?(versions, &(&1 < 2)), "legacy_collector")
+      |> issue(Enum.any?(summaries, &(not consistent_timing?(&1))), "inconsistent_key_timing")
+      |> issue(outside_game?(summaries, opts[:duration_ms]), "outside_game_window")
+      |> issue(Enum.any?(boundaries, &(&1 < 0)), "overlapping_key_windows")
+      |> issue(
+        Enum.any?(key_windows, &(num(&1, "collector_version") >= 2 and not complete_boundaries?(&1))),
+        "incomplete_key_boundaries"
+      )
+      |> Enum.reverse()
+
+    timing_reliable = Enum.all?(issues, &(&1 in ["legacy_collector", "incomplete_key_boundaries"]))
+
+    %{
+      collector_versions: versions,
+      quality_issues: issues,
+      timing_reliable: timing_reliable,
+      idle_pauses_reliable: timing_reliable and boundaries_complete,
+      boundary_deltas: if(timing_reliable and boundaries_complete, do: boundaries, else: [])
+    }
+  end
+
+  defp missing_identity?(summary) do
+    num(summary, "collector_version") >= 3 and
+      (not is_binary(summary["collector_session"]) or summary["collector_session"] == "" or
+         not is_integer(summary["batch_sequence"]))
+  end
+
+  defp sequence_gap?(summaries) do
+    summaries
+    |> Enum.filter(&is_binary(&1["collector_session"]))
+    |> Enum.group_by(& &1["collector_session"])
+    |> Enum.any?(fn {_session, windows} ->
+      sequences = windows |> Enum.map(&num(&1, "batch_sequence")) |> Enum.sort()
+
+      hd(sequences) != 0 or length(Enum.uniq(sequences)) != length(sequences) or
+        List.last(sequences) != length(sequences) - 1
+    end)
+  end
+
+  defp complete_boundaries?(s) do
+    first = s["first_key_offset_ms"]
+    last = s["last_key_offset_ms"]
+
+    num(s, "collector_version") >= 2 and is_number(first) and is_number(last) and
+      first >= num(s, "window_start_offset_ms") and first <= last and last <= num(s, "window_end_offset_ms") and
+      num(s, "key_delta_sample_count") == num(s, "key_event_count") - 1
+  end
+
+  defp consistent_timing?(s) do
+    keys = num(s, "key_event_count")
+    samples = num(s, "key_delta_sample_count")
+    min = num(s, "min_key_delta_ms")
+    avg = num(s, "avg_key_delta_ms")
+    max = num(s, "max_key_delta_ms")
+    pauses = num(s, "idle_pause_over_2s_count")
+
+    consistent_samples?(keys, samples) and ordered_intervals?(min, avg, max) and
+      consistent_pauses?(pauses, samples, max)
+  end
+
+  defp consistent_samples?(keys, samples) do
+    samples >= 0 and samples <= max(keys - 1, 0) and (keys <= 1 or samples > 0)
+  end
+
+  defp ordered_intervals?(min, avg, max), do: min >= 0 and min <= avg and avg <= max
+
+  defp consistent_pauses?(pauses, samples, max) do
+    pauses >= 0 and pauses <= samples and ((max >= 2_000 and pauses > 0) or (max < 2_000 and pauses == 0))
+  end
+
+  defp boundary_deltas(windows) do
+    windows
+    |> Enum.chunk_every(2, 1, :discard)
+    |> Enum.map(fn [before, next] -> next["first_key_offset_ms"] - before["last_key_offset_ms"] end)
+  end
+
+  defp outside_game?(_summaries, nil), do: false
+
+  defp outside_game?(summaries, duration_ms) do
+    Enum.any?(summaries, &(num(&1, "window_end_offset_ms") > duration_ms + 5_000))
+  end
+
+  defp issue(issues, true, issue), do: [issue | issues]
+  defp issue(issues, false, _issue), do: issues
+
+  defp num(s, key) do
+    case s[key] do
+      value when is_number(value) -> value
+      _ -> 0
+    end
+  end
+end
diff --git a/lib/codebattle/game/context.ex b/lib/codebattle/game/context.ex
index 17cbddc93..0916c0516 100644
--- a/lib/codebattle/game/context.ex
+++ b/lib/codebattle/game/context.ex
@@ -29,6 +29,10 @@ defmodule Codebattle.Game.Context do
   @active_game_candidates_limit 20
 
   @allowed_summary_integer_fields ~w(
+    batch_sequence collector_version
+    first_key_offset_ms
+    last_key_offset_ms
+    command_insert_count
     key_event_count
     printable_key_count
     modifier_shortcut_count
@@ -426,15 +430,33 @@ defmodule Codebattle.Game.Context do
             "window_end_offset_ms" => end_offset
           },
           fn key, acc ->
-            Map.put(acc, key, summary |> map_get(key) |> normalize_non_negative_integer())
+            maybe_put_summary_integer(acc, key, map_get(summary, key))
           end
         )
         # Deleting more than inserting makes it negative.
         |> Map.put("net_text_delta", summary |> map_get("net_text_delta") |> normalize_integer())
+        |> maybe_put_string("collector_session", map_get(summary, "collector_session"), 64)
+        |> Map.put("edit_evidence", sanitize_edit_evidence(map_get(summary, "edit_evidence")))
         |> maybe_put_string("lang_slug", map_get(summary, "lang_slug"), 32)
     end
   end
 
+  defp sanitize_edit_evidence(events) when is_list(events) do
+    events
+    |> Enum.take(100)
+    |> Enum.filter(&is_map/1)
+    |> Enum.map(fn event ->
+      Map.new(~w(offset_ms inserted_chars assisted_chars paste_chars printable_keys), fn key ->
+        {key, normalize_non_negative_integer(map_get(event, key))}
+      end)
+    end)
+  end
+
+  defp sanitize_edit_evidence(_), do: []
+
+  defp maybe_put_summary_integer(acc, _key, nil), do: acc
+  defp maybe_put_summary_integer(acc, key, value), do: Map.put(acc, key, normalize_non_negative_integer(value))
+
   defp get_editor_batch_bounds(game, start_offset_ms, end_offset_ms) do
     anchor = get_editor_batch_anchor(game)
 
diff --git a/lib/codebattle/game/editor_event_batch.ex b/lib/codebattle/game/editor_event_batch.ex
index b0d3b1dcb..f9c2a35de 100644
--- a/lib/codebattle/game/editor_event_batch.ex
+++ b/lib/codebattle/game/editor_event_batch.ex
@@ -82,7 +82,7 @@ defmodule Codebattle.Game.EditorEventBatch do
   def create(attrs) do
     %__MODULE__{}
     |> changeset(attrs)
-    |> Repo.insert()
+    |> Repo.insert(on_conflict: :nothing)
   end
 
   def list_by_game(game_id) do
@@ -92,6 +92,24 @@ defmodule Codebattle.Game.EditorEventBatch do
     |> Repo.all()
   end
 
+  @doc "The immutable batches included in an analysis (including the empty case)."
+  def snapshot(batches) do
+    %{
+      "count" => length(batches),
+      "last_id" => batches |> Enum.map(&(Map.get(&1, :id) || 0)) |> Enum.max(fn -> 0 end)
+    }
+  end
+
+  @doc "Current batch snapshots per player without loading the JSON payloads."
+  def snapshots_by_user(game_id) do
+    __MODULE__
+    |> where([b], b.game_id == ^game_id)
+    |> group_by([b], b.user_id)
+    |> select([b], {b.user_id, count(b.id), max(b.id)})
+    |> Repo.all()
+    |> Map.new(fn {user_id, count, last_id} -> {user_id, %{"count" => count, "last_id" => last_id}} end)
+  end
+
   defp validate_window_offsets(changeset) do
     start_offset = get_field(changeset, :window_start_offset_ms)
     end_offset = get_field(changeset, :window_end_offset_ms)
diff --git a/lib/codebattle_web/controllers/game_controller.ex b/lib/codebattle_web/controllers/game_controller.ex
index e9af92130..371b5cde3 100644
--- a/lib/codebattle_web/controllers/game_controller.ex
+++ b/lib/codebattle_web/controllers/game_controller.ex
@@ -96,6 +96,23 @@ defmodule CodebattleWeb.GameController do
     end
   end
 
+  def review(conn, %{"id" => id} = params) do
+    if User.admin_or_moderator?(conn.assigns.current_user) do
+      with {game_id, ""} when game_id > 0 <- Integer.parse(id),
+           {user_id, ""} when user_id > 0 <- Integer.parse(to_string(params["user_id"])),
+           {:ok, _review} <- BotDetection.Review.record(conn.assigns.current_user, game_id, user_id, params) do
+        redirect(conn, to: Routes.game_path(conn, :ml, id))
+      else
+        _ ->
+          conn
+          |> put_status(:unprocessable_entity)
+          |> text("A report, outcome and reason of at least 10 characters are required")
+      end
+    else
+      conn |> put_status(:forbidden) |> text("Forbidden")
+    end
+  end
+
   defp render_ml_for_game(conn, game, user, params) do
     can_manage = User.admin_or_moderator?(user)
 
@@ -114,6 +131,7 @@ defmodule CodebattleWeb.GameController do
     |> render_inertia("GameMl", %{
       "game_id" => game.id,
       "can_manage" => can_manage,
+      "reviews" => if(can_manage, do: BotDetection.Review.list(game.id), else: []),
       "players" => Enum.map(players, &serialize_ml_player(&1, analyses_by_user)),
       "batches" => Enum.map(batches, &serialize_batch/1)
     })
@@ -136,8 +154,8 @@ defmodule CodebattleWeb.GameController do
       rank: Map.get(player, :rank),
       lang: Map.get(player, :editor_lang) || Map.get(player, :lang),
       is_bot: Map.get(player, :is_bot, false),
-      editor_text: Map.get(player, :editor_text),
-      editor_lang: Map.get(player, :editor_lang),
+      editor_text: if(analysis, do: analysis.final_text, else: Map.get(player, :editor_text)),
+      editor_lang: if(analysis, do: analysis.final_lang, else: Map.get(player, :editor_lang)),
       report: serialize_analysis(analysis)
     }
   end
@@ -149,6 +167,7 @@ defmodule CodebattleWeb.GameController do
       score: a.score,
       level: Atom.to_string(a.level),
       signals: a.signals,
+      evidence: a.evidence,
       stats: a.stats,
       code_analysis: a.code_analysis,
       editor_history: a.editor_history,
diff --git a/lib/codebattle_web/router.ex b/lib/codebattle_web/router.ex
index 33469269b..3a3ae1efc 100644
--- a/lib/codebattle_web/router.ex
+++ b/lib/codebattle_web/router.ex
@@ -494,6 +494,7 @@ defmodule CodebattleWeb.Router do
 
     get("/games/:id/stream", GameController, :stream)
     get("/games/:id/ml", GameController, :ml)
+    post("/games/:id/ml/reviews", GameController, :review)
 
     scope "/games" do
       post("/training", GameController, :create_training)
diff --git a/lib/mix/tasks/codebattle.antibot.evaluate.ex b/lib/mix/tasks/codebattle.antibot.evaluate.ex
new file mode 100644
index 000000000..a9f2082ba
--- /dev/null
+++ b/lib/mix/tasks/codebattle.antibot.evaluate.ex
@@ -0,0 +1,88 @@
+defmodule Mix.Tasks.Codebattle.Antibot.Evaluate do
+  @shortdoc "Evaluate current reports against latest moderator decisions (read only)"
+  @moduledoc "Run with ./bin/dev mix codebattle.antibot.evaluate. No reports or decisions are changed."
+  use Mix.Task
+
+  import Ecto.Query
+
+  alias Codebattle.Game.BotDetection
+  alias Codebattle.Game.BotDetection.Evaluation
+  alias Codebattle.Game.BotDetection.Review
+  alias Codebattle.Repo
+
+  def run(_args) do
+    Mix.Task.run("app.config")
+    {:ok, _} = Application.ensure_all_started(:ecto_sql)
+    {:ok, _} = Application.ensure_all_started(:postgrex)
+    start_reader(Repo, fn -> Repo.start_link() end)
+    start_reader(Codebattle.Registry, fn -> Registry.start_link(keys: :unique, name: Codebattle.Registry) end)
+
+    {:ok, result} =
+      Repo.transaction(
+        fn ->
+          Repo.query!("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ ONLY")
+          evaluate()
+        end,
+        timeout: to_timeout(minute: 30)
+      )
+
+    Mix.shell().info(Jason.encode!(result, pretty: true))
+  end
+
+  defp start_reader(name, start) do
+    if is_nil(Process.whereis(name)), do: {:ok, _} = start.()
+  end
+
+  defp evaluate do
+    reviews =
+      from(r in Review, join: g in assoc(r, :game), where: g.state in ["game_over", "timeout"], order_by: [desc: r.id])
+      |> Repo.all()
+      |> Enum.uniq_by(&{&1.game_id, &1.user_id})
+
+    analyses =
+      reviews
+      |> Enum.map(& &1.game_id)
+      |> Enum.uniq()
+      |> Map.new(fn id ->
+        {:ok, rows} = BotDetection.analyze_game(id)
+        {id, Map.new(rows, &{&1.user_id, &1})}
+      end)
+
+    cases =
+      Enum.flat_map(reviews, fn r ->
+        case analyses[r.game_id][r.user_id] do
+          nil ->
+            []
+
+          analysis ->
+            [
+              %{
+                user_id: r.user_id,
+                outcome: r.outcome,
+                score: analysis.score,
+                lang: analysis.final_lang || "unknown",
+                collectors: collector_cohort(analysis.stats)
+              }
+            ]
+        end
+      end)
+
+    result =
+      cases
+      |> Evaluation.summarize()
+      |> Map.merge(%{
+        missing_analysis: length(reviews) - length(cases),
+        by_language: breakdown(cases, :lang),
+        by_collector_version: breakdown(cases, :collectors)
+      })
+
+    result
+  end
+
+  defp collector_cohort(nil), do: "missing"
+  defp collector_cohort(stats), do: Enum.join(stats.collector_versions, ",")
+
+  defp breakdown(cases, field) do
+    cases |> Enum.group_by(&Map.fetch!(&1, field)) |> Map.new(fn {key, rows} -> {key, Evaluation.summarize(rows)} end)
+  end
+end
diff --git a/mix.lock b/mix.lock
index 75fa09192..f665d038e 100644
--- a/mix.lock
+++ b/mix.lock
@@ -1,5 +1,5 @@
 %{
-  "bandit": {:hex, :bandit, "1.13.1", "1ce25a7beb750ed3fa2e905962f1f9a679cb585f1da0ae45637d06e385ce2eae", [:mix], [{:hpax, "~> 1.1", [hex: :hpax, repo: "hexpm", optional: false]}, {:plug, "~> 1.18", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:thousand_island, "~> 1.6", [hex: :thousand_island, repo: "hexpm", optional: false]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "39028f0b5a21404661410a6c19275060a9822c9dcca70b7c3e4e4fa50b11da58"},
+  "bandit": {:hex, :bandit, "1.14.0", "555af34f126edb98d8b6b95bbeba4d5f4c3af21e37535d791f32db2365c532fb", [:mix], [{:hpax, "~> 1.1", [hex: :hpax, repo: "hexpm", optional: false]}, {:plug, "~> 1.18", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:thousand_island, "~> 1.6", [hex: :thousand_island, repo: "hexpm", optional: false]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "2d07630e4bf77b55240881386f7629bcc2f87426a299860b2d31c4ad77a48746"},
   "bcrypt_elixir": {:hex, :bcrypt_elixir, "3.3.2", "d50091e3c9492d73e17fc1e1619a9b09d6a5ef99160eb4d736926fd475a16ca3", [:make, :mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.6", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "471be5151874ae7931911057d1467d908955f93554f7a6cd1b7d804cac8cef53"},
   "bunt": {:hex, :bunt, "1.0.0", "081c2c665f086849e6d57900292b3a161727ab40431219529f13c4ddcf3e7a44", [:mix], [], "hexpm", "dc5f86aa08a5f6fa6b8096f0735c4e76d54ae5c9fa2c143e5a1fc7c1cd9bb6b5"},
   "cachex": {:hex, :cachex, "4.1.1", "574c5cd28473db313a0a76aac8c945fe44191659538ca6a1e8946ec300b1a19f", [:mix], [{:eternal, "~> 1.2", [hex: :eternal, repo: "hexpm", optional: false]}, {:ex_hash_ring, "~> 6.0", [hex: :ex_hash_ring, repo: "hexpm", optional: false]}, {:jumper, "~> 1.0", [hex: :jumper, repo: "hexpm", optional: false]}, {:sleeplocks, "~> 1.1", [hex: :sleeplocks, repo: "hexpm", optional: false]}, {:unsafe, "~> 1.0", [hex: :unsafe, repo: "hexpm", optional: false]}], "hexpm", "d6b7449ff98d6bb92dda58bd4fc3189cae9f99e7042054d669596f56dc503cd8"},
@@ -17,7 +17,7 @@
   "ecto": {:hex, :ecto, "3.14.2", "99db28a864293a789c970651de711e3cae184291e0e7ea1166c54055ac41c1f3", [:mix], [{:decimal, "~> 3.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "25d60b8c816a07d19d85b80bdf60978bd8b102209dda198d768cd7c6745339a6"},
   "ecto_psql_extras": {:hex, :ecto_psql_extras, "0.8.8", "aa02529c97f69aed5722899f5dc6360128735a92dd169f23c5d50b1f7fdede08", [:mix], [{:ecto_sql, "~> 3.7", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:postgrex, "> 0.16.0", [hex: :postgrex, repo: "hexpm", optional: false]}, {:table_rex, "~> 3.1.1 or ~> 4.0", [hex: :table_rex, repo: "hexpm", optional: false]}], "hexpm", "04c63d92b141723ad6fed2e60a4b461ca00b3594d16df47bbc48f1f4534f2c49"},
   "ecto_sql": {:hex, :ecto_sql, "3.14.0", "06446ab8410d2f85bfbb80857ee224ab3b693700cbb38f6535d507449a627b2e", [:mix], [{:db_connection, "~> 2.9", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 3.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:ecto, "~> 3.14.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.8", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.19 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.1 or ~> 2.2", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "f4d8d36faf294c9417b5a37ec7ac8217ee2abdef5fcf197ba690f361548d3949"},
-  "elixir_make": {:hex, :elixir_make, "0.10.0", "16577e2583a79bb79237bbff349619ef5d80afffc07eac6e4faf0d00e2ddaf7d", [:mix], [], "hexpm", "dc1f09fb7fa68866b886abd5f0f3c83553b1a19a52359a899e92af1bb3b31982"},
+  "elixir_make": {:hex, :elixir_make, "0.10.1", "f5a44ab6b48421de1c4fd33c147e22cd2f82fd86e8a9a4d24809d466cad63c5e", [:mix], [], "hexpm", "ce1eaa234bc87f0279718e793fd6f8ad35b4e8ee8d412329e3879eee8d40adba"},
   "envy": {:hex, :envy, "1.1.1", "0bc9bd654dec24fcdf203f7c5aa1b8f30620f12cfb28c589d5e9c38fe1b07475", [:mix], [], "hexpm", "7061eb1a47415fd757145d8dec10dc0b1e48344960265cb108f194c4252c3a89"},
   "erlex": {:hex, :erlex, "0.2.9", "7debbbaa9f4f368b8cd648983e0f1d7963028508e9c59e9d4ed504e94ef52a55", [:mix], [], "hexpm", "8cfffc0ec7159e6d73de2ab28a588064de80f88b2798d5cbe4482cbbc200178b"},
   "eternal": {:hex, :eternal, "1.2.2", "d1641c86368de99375b98d183042dd6c2b234262b8d08dfd72b9eeaafc2a1abd", [:mix], [], "hexpm", "2c9fe32b9c3726703ba5e1d43a1d255a4f3f2d8f8f9bc19f094c7cb1a7a9e782"},
@@ -38,8 +38,8 @@
   "jason": {:hex, :jason, "1.4.5", "2e3a008590b0b8d7388c20293e9dcc9cf3e5d642fd2a114e4cbbb52e595d940a", [:mix], [{:decimal, "~> 1.0 or ~> 2.0 or ~> 3.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "b0c823996102bcd0239b3c2444eb00409b72f6a140c1950bc8b457d836b30684"},
   "jumper": {:hex, :jumper, "1.0.2", "68cdcd84472a00ac596b4e6459a41b3062d4427cbd4f1e8c8793c5b54f1406a7", [:mix], [], "hexpm", "9b7782409021e01ab3c08270e26f36eb62976a38c1aa64b2eaf6348422f165e1"},
   "lazy_html": {:hex, :lazy_html, "0.1.13", "860ea816f5bc7936d1ab5ccebc388f9d1031ba9c35ed81a4db9a1c3a50737704", [:make, :mix], [{:cc_precompiler, "~> 0.1", [hex: :cc_precompiler, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.9", [hex: :elixir_make, repo: "hexpm", optional: false]}, {:fine, "~> 0.1.0", [hex: :fine, repo: "hexpm", optional: false]}], "hexpm", "9a8405d6785fe6f8423b86e0ec5f21806ef79941fe853eac3d14fbbb173c34e9"},
-  "mdex": {:hex, :mdex, "0.14.2", "8d2b376f3de8f9f03a2ba0992eeb4f76d58fa790b0ed78dc90bcb5422ce7ff5d", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:lumis, "~> 0.10", [hex: :lumis, repo: "hexpm", optional: true]}, {:mdex_native, ">= 0.2.11", [hex: :mdex_native, repo: "hexpm", optional: false]}, {:nimble_options, "~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_parsec, "~> 1.0", [hex: :nimble_parsec, repo: "hexpm", optional: false]}, {:phoenix_live_view, "~> 0.20.0 or ~> 1.0", [hex: :phoenix_live_view, repo: "hexpm", optional: true]}], "hexpm", "7003e60b8621ab1c9b3671221a8dcc27dee9f9086026c25ea7aed4057d07978f"},
-  "mdex_native": {:hex, :mdex_native, "0.2.12", "867912ab5675e0a315e44ea5eb9ec22ac09c12559cc89fc1ba71afd7d95bf96a", [:mix], [{:rustler, "~> 0.32", [hex: :rustler, repo: "hexpm", optional: true]}, {:rustler_precompiled, "~> 0.8", [hex: :rustler_precompiled, repo: "hexpm", optional: false]}], "hexpm", "c9557b4e576515b01edc5bc48f6ac0a6e13c25a0bd3bf4a6e0a2ccd2199d747b"},
+  "mdex": {:hex, :mdex, "0.14.3", "13541cc1fdbccd8604b0cc65ce3cb204aeb9fffe903be5813a055c4ab5555666", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mdex_native, ">= 0.2.13", [hex: :mdex_native, repo: "hexpm", optional: false]}, {:nimble_options, "~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_parsec, "~> 1.0", [hex: :nimble_parsec, repo: "hexpm", optional: false]}, {:phoenix_live_view, "~> 0.20.0 or ~> 1.0", [hex: :phoenix_live_view, repo: "hexpm", optional: true]}], "hexpm", "e49f7973ba47de5f5bf6d6178d7b92222f35d26e14f1833942d7a7d64825b9ea"},
+  "mdex_native": {:hex, :mdex_native, "0.2.13", "baeed89300457bcd5ff37a81b7c5dbcc16bf2716311b20b67567a8510f23be22", [:mix], [{:rustler, "~> 0.32", [hex: :rustler, repo: "hexpm", optional: true]}, {:rustler_precompiled, "~> 0.8", [hex: :rustler_precompiled, repo: "hexpm", optional: false]}], "hexpm", "7baa4dbe426bae4bb420616c87ba3757b1c7e138e200ac19c7b3a1dfee5c3a8e"},
   "mime": {:hex, :mime, "2.0.7", "b8d739037be7cd402aee1ba0306edfdef982687ee7e9859bee6198c1e7e2f128", [:mix], [], "hexpm", "6171188e399ee16023ffc5b76ce445eb6d9672e2e241d2df6050f3c771e80ccd"},
   "mimic": {:hex, :mimic, "2.4.2", "7ae12cb77be8dc359588c2b8e47afb4dd985a9b63221a914485f2a393d5a907f", [:mix], [{:ham, "~> 0.3", [hex: :ham, repo: "hexpm", optional: false]}], "hexpm", "9a557e18666c4af124132004098e004b383682e3ea44ae66b740b99c7d66e8d4"},
   "mint": {:hex, :mint, "1.11.0", "a713551624815c0435237b93d90ea8b9b14254690c66f732d0ef8930f76ff1d9", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:hpax, "~> 1.1", [hex: :hpax, repo: "hexpm", optional: false]}], "hexpm", "c6279ba2d6aa3a383a1d4cfbe7b59f42e6efd400f58d8e2acfeac48a438693ab"},
@@ -64,13 +64,13 @@
   "phoenix_template": {:hex, :phoenix_template, "1.1.0", "b329582281b1e00e4dc664afd60ef5b489cbb356923caa3b1e00abe8651b9a18", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "eba70070de79b2c3501ef205a74a69f98ab352f3785aa15da9ed161f9fe0fd5d"},
   "phoenix_view": {:hex, :phoenix_view, "2.0.4", "b45c9d9cf15b3a1af5fb555c674b525391b6a1fe975f040fb4d913397b31abf4", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}], "hexpm", "4e992022ce14f31fe57335db27a28154afcc94e9983266835bb3040243eb620b"},
   "plug": {:hex, :plug, "1.20.3", "56c480c633ec2ce10140e236e15233bf576e1d323887d7c96711bd02ab5160db", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "be266aee1b8536ef6409d58cf39a3121319f0ec47cfa1b24024485aa0e76ad76"},
-  "plug_crypto": {:hex, :plug_crypto, "2.2.0", "144014737daaf485407f5ed77daeaad74d651b216a28c87543f8cc7043f8efc8", [:mix], [], "hexpm", "83a95744ab1c75876542b6fab135fcc176280e0f301a111c1f757fddcec95d2c"},
+  "plug_crypto": {:hex, :plug_crypto, "2.2.1", "bd1d0358a2e2f5ffb818217e64c394f9d24ed191d862b7fa1bcce264ace2b8ea", [:mix], [], "hexpm", "4417ccbd8f85e627321cd07d2ab9c4b621f1fd883b9905af241f9b4b780b94b6"},
   "porcelain": {:hex, :porcelain, "2.0.3", "2d77b17d1f21fed875b8c5ecba72a01533db2013bd2e5e62c6d286c029150fdc", [:mix], [], "hexpm", "dc996ab8fadbc09912c787c7ab8673065e50ea1a6245177b0c24569013d23620"},
   "postgrex": {:hex, :postgrex, "0.22.4", "d271f595dfd25230b6398354e19d17bb5e2d20130fd2d9bdca7e15f125d43552", [:mix], [{:db_connection, "~> 2.9", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0 or ~> 3.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "4aae45a2d60e35b04eea2602440be152fae332901f1fc7a60fc7cb7f0f9a9c5a"},
   "proper": {:hex, :proper, "1.2.0", "1466492385959412a02871505434e72e92765958c60dba144b43863554b505a4", [:make, :mix, :rebar3], [], "hexpm", "cbc3766c08337806741343d330bf4bcb826155d2141be8514c4b02858aa19fd3"},
   "recon": {:hex, :recon, "2.5.6", "9052588e83bfedfd9b72e1034532aee2a5369d9d9343b61aeb7fbce761010741", [:mix, :rebar3], [], "hexpm", "96c6799792d735cc0f0fd0f86267e9d351e63339cbe03df9d162010cefc26bb0"},
   "req": {:hex, :req, "0.7.5", "0c3293cbf7717aba20b1b1b3ea13fe8d3fdf6f1557490f390c3f1ef6dd9db955", [:mix], [{:brotli, "~> 0.3.1", [hex: :brotli, repo: "hexpm", optional: true]}, {:finch, "~> 0.21", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mime, "~> 2.0.6 or ~> 2.1", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_csv, "~> 1.0", [hex: :nimble_csv, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "576853c4bf403faa3c1fa5d093e0759227083b78f8a6864c67d62c0a9c45514d"},
-  "rustler_precompiled": {:hex, :rustler_precompiled, "0.10.0", "8f07ff0865cb09a6a0f75e11701e9a46e331e05f737da4e5b01374dcd25b68c0", [:mix], [{:rustler, "~> 0.28", [hex: :rustler, repo: "hexpm", optional: true]}], "hexpm", "c68c9dc732c12acfdf4a7fa06f4e6f48a641179e6be49a474c8a60809929c430"},
+  "rustler_precompiled": {:hex, :rustler_precompiled, "0.10.1", "2895d3a3239d612c13c18945c0a693e07de4e8f9bc2b6b2297cba3d6576f9eea", [:mix], [{:rustler, "~> 0.28", [hex: :rustler, repo: "hexpm", optional: true]}], "hexpm", "0efa66bc2a4206aec64a2c422ca0b1d69bdc411c7b359ec928feb889357b4abb"},
   "sentry": {:hex, :sentry, "14.0.0", "604da2da8f57797c6e44afab749cda3398244b5738ac1355dcc46f8bf89862d1", [:mix], [{:finch, "~> 0.21", [hex: :finch, repo: "hexpm", optional: true]}, {:hackney, ">= 1.8.0 and < 5.0.0", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: true]}, {:nimble_options, "~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_ownership, "~> 1.0", [hex: :nimble_ownership, repo: "hexpm", optional: false]}, {:opentelemetry, ">= 0.0.0", [hex: :opentelemetry, repo: "hexpm", optional: true]}, {:opentelemetry_api, ">= 0.0.0", [hex: :opentelemetry_api, repo: "hexpm", optional: true]}, {:opentelemetry_exporter, ">= 0.0.0", [hex: :opentelemetry_exporter, repo: "hexpm", optional: true]}, {:opentelemetry_semantic_conventions, ">= 0.0.0", [hex: :opentelemetry_semantic_conventions, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6", [hex: :phoenix, repo: "hexpm", optional: true]}, {:phoenix_live_view, "~> 0.20 or ~> 1.0", [hex: :phoenix_live_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.6", [hex: :plug, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: true]}], "hexpm", "cb4b59adb414a17263e51bdad9deb8e95de4c93e67f8c021dcfabee62e6ee1ac"},
   "sleeplocks": {:hex, :sleeplocks, "1.1.4", "be657d2326fad313a9cbc45374dcd861416f2f2097bc71c4de1538b65c7ccc8e", [:rebar3], [], "hexpm", "bc12752ab0693ea4e4a3bcf4e063cef408d71197a3c0fad75497fabd475f5481"},
   "statistics": {:hex, :statistics, "0.6.3", "7fb182e7c1cab2980e392c7efef7ce326539f081f9defda4099550e9c2c7cb0f", [:mix], [], "hexpm", "a43d87726d240205e9ef47f29650a6e3132b4e4061e05512f32fa8120784a8e0"},
@@ -81,12 +81,12 @@
   "telemetry_poller": {:hex, :telemetry_poller, "1.3.0", "d5c46420126b5ac2d72bc6580fb4f537d35e851cc0f8dbd571acf6d6e10f5ec7", [:rebar3], [{:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "51f18bed7128544a50f75897db9974436ea9bfba560420b646af27a9a9b35211"},
   "temp": {:hex, :temp, "0.4.9", "eb6355bfa7925a568b3d9eb3bb57e89aa6d2b78bfe8dfb6b698e090631b7f41f", [:mix], [], "hexpm", "bc8bf7b27d9105bef933ef4bf4ba37ac6b899dbeba329deaa88c60b62d6b4b6d"},
   "thousand_island": {:hex, :thousand_island, "1.6.0", "d6ad7c2220c96a270cc8ca1586ec4d8bde648a4a3a53f003ce093f41beec0288", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "4d4720470f091fc21a1311777c2ac66916c43621bffc068590c9f9bb3cd057a3"},
-  "tidewave": {:hex, :tidewave, "0.9.1", "28bc14d3af0169f07c88ffd97004f344180a9cd2316d345f472bd22092cccd22", [:mix], [{:circular_buffer, "~> 0.4 or ~> 1.0", [hex: :circular_buffer, repo: "hexpm", optional: false]}, {:igniter, "~> 0.6", [hex: :igniter, repo: "hexpm", optional: true]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: false]}, {:phoenix_live_reload, ">= 1.6.1", [hex: :phoenix_live_reload, repo: "hexpm", optional: true]}, {:plug, "~> 1.18", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.9", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock_adapter, "~> 0.5", [hex: :websock_adapter, repo: "hexpm", optional: false]}], "hexpm", "dc8db03332b35084fd5b5fbe4fcb196c077bbe9cfdf883dcf6a5750a9bc19bb2"},
+  "tidewave": {:hex, :tidewave, "0.9.2", "a523b6af9a11a06807dbe09f645187dfdb2873603a169fb2274da46db54dbc1d", [:mix], [{:circular_buffer, "~> 0.4 or ~> 1.0", [hex: :circular_buffer, repo: "hexpm", optional: false]}, {:igniter, "~> 0.6", [hex: :igniter, repo: "hexpm", optional: true]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: false]}, {:phoenix_live_reload, ">= 1.6.1", [hex: :phoenix_live_reload, repo: "hexpm", optional: true]}, {:plug, "~> 1.18", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.9", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock_adapter, "~> 0.5", [hex: :websock_adapter, repo: "hexpm", optional: false]}], "hexpm", "66cba92861fa17cef3920caa9419bb001b81474dba0df3567f5b782675459879"},
   "typed_struct": {:hex, :typed_struct, "0.3.0", "939789e3c1dca39d7170c87f729127469d1315dcf99fee8e152bb774b17e7ff7", [:mix], [], "hexpm", "c50bd5c3a61fe4e198a8504f939be3d3c85903b382bde4865579bc23111d1b6d"},
   "tzdata": {:hex, :tzdata, "1.2.2", "0e9a50d84e0734038e2e37ed027a7dc5962597b79a7ead9d5f9bce7365aedc02", [:mix], [{:hackney, "~> 1.17 or ~> 4.0", [hex: :hackney, repo: "hexpm", optional: true]}], "hexpm", "4a2435eb3614711b220a9f9f9b56204d14518c6a84e94278cc8b697ca62221a7"},
   "unsafe": {:hex, :unsafe, "1.0.2", "23c6be12f6c1605364801f4b47007c0c159497d0446ad378b5cf05f1855c0581", [:mix], [], "hexpm", "b485231683c3ab01a9cd44cb4a79f152c6f3bb87358439c6f68791b85c2df675"},
   "websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"},
-  "websock_adapter": {:hex, :websock_adapter, "0.6.0", "73db5ab8aaefd1a876a97ce3e6afc96562625de69ef17a4e04426e034849d0b8", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "50021a85bce8f203b086705d9e0c5415e2c7eb05d319111b0428fe71f9934617"},
+  "websock_adapter": {:hex, :websock_adapter, "0.7.0", "4f9c0a6048dea3f3c6146f3f004b32c5916bc95b4b3644badae88556d9e2007f", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:roadrunner_plug, "~> 0.1", [hex: :roadrunner_plug, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "a7243f803540425d4890e4c7bc0af9b2519e3935b6c01d9a924ba63527549d65"},
   "yamerl": {:hex, :yamerl, "0.10.0", "4ff81fee2f1f6a46f1700c0d880b24d193ddb74bd14ef42cb0bcf46e81ef2f8e", [:rebar3], [], "hexpm", "346adb2963f1051dc837a2364e4acf6eb7d80097c0f53cbdc3046ec8ec4b4e6e"},
   "yaml_elixir": {:hex, :yaml_elixir, "2.12.2", "9dd1330fb4cd9a36a7b0f502e5b12486eff632792ee4a5f0eba52a4d4ec32c9c", [:mix], [{:yamerl, "~> 0.10", [hex: :yamerl, repo: "hexpm", optional: false]}], "hexpm", "e7c1b10122f973e6558462d51c39026ba0e14afbc6745318e990ea82cfe9e159"},
   "zotonic_stdlib": {:hex, :zotonic_stdlib, "1.2.3", "4a33b60c82379169c9934ccd1fc9e512ca16b922e131ad6b6d26e562f66df9cc", [:rebar3], [], "hexpm", "4712dd7a0c0c600afedafda738d40febf10cfc2485e62d109361fcc190f7381a"},
diff --git a/priv/gettext/en/LC_MESSAGES/default.po b/priv/gettext/en/LC_MESSAGES/default.po
index 2c7d26dcb..8d250cace 100644
--- a/priv/gettext/en/LC_MESSAGES/default.po
+++ b/priv/gettext/en/LC_MESSAGES/default.po
@@ -5058,3 +5058,12 @@ msgstr "Hardest level"
 
 msgid "Rounds get harder: elementary first, then easy and medium. With Hard, the last round is hard."
 msgstr "Rounds get harder: elementary first, then easy and medium. With Hard, the last round is hard."
+
+msgid "Season tournaments"
+msgstr "Season tournaments"
+
+msgid "Custom tournaments"
+msgstr "Custom tournaments"
+
+msgid "No open custom tournaments right now."
+msgstr "No open custom tournaments right now."
diff --git a/priv/gettext/es/LC_MESSAGES/default.po b/priv/gettext/es/LC_MESSAGES/default.po
index 1ee4e916d..d8850578e 100644
--- a/priv/gettext/es/LC_MESSAGES/default.po
+++ b/priv/gettext/es/LC_MESSAGES/default.po
@@ -7217,8 +7217,8 @@ msgstr ""
 "Obtenga una vista previa de una tarea accesible antes de comenzar. Tu "
 "oponente de práctica es un robot."
 
-msgid "Write it. Run it."
-msgstr "Escríbelo. Ejecútalo."
+msgid "Write code and run tests"
+msgstr "Escribe código y ejecuta las pruebas"
 
 msgid ""
 "Fill in the solution and run the tests. Use the results to improve your "
@@ -7552,3 +7552,132 @@ msgstr "Nivel máximo"
 
 msgid "Rounds get harder: elementary first, then easy and medium. With Hard, the last round is hard."
 msgstr "Las rondas se vuelven más difíciles: primero elementales, luego fáciles y medias. Con Duro, la última ronda es difícil."
+
+msgid "No suspicious signals"
+msgstr "Sin señales sospechosas"
+
+msgid "Weak signals"
+msgstr "Señales débiles"
+
+msgid "Review suggested"
+msgstr "Se recomienda revisar"
+
+msgid "Strong signals"
+msgstr "Señales fuertes"
+
+msgid "Insufficient telemetry"
+msgstr "Telemetría insuficiente"
+
+msgid "Heuristic score, not a probability. 5+ suggests review; 10+ indicates stronger signals."
+msgstr "Puntuación heurística, no una probabilidad. Desde 5 se recomienda revisar; desde 10 hay señales más fuertes."
+
+msgid "Missing telemetry does not establish automation. Check the replay for connection gaps and editor activity."
+msgstr "La falta de telemetría no demuestra automatización. Revisa la repetición para comprobar cortes de conexión y actividad en el editor."
+
+msgid "Bulk edit; review its origin"
+msgstr "Edición en bloque; revisa su origen"
+
+msgid "Page focus loss / time unfocused"
+msgstr "Pérdidas de foco / tiempo sin foco"
+
+msgid "Browser focus or visibility changes, including other windows and dialogs. Context only; does not affect the score."
+msgstr "Cambios de foco o visibilidad del navegador, incluidas otras ventanas y diálogos. Solo contexto; no afectan a la puntuación."
+
+msgid "Most inserted characters (excluding spaces) in one received update. Connection gaps, undo and editor commands can also produce large updates."
+msgstr "Máximo de caracteres insertados, sin espacios, en una actualización recibida. Los cortes de conexión, deshacer y los comandos del editor también pueden producir actualizaciones grandes."
+
+msgid "Large update; check the replay"
+msgstr "Actualización grande; revisa la repetición"
+
+msgid "Review aid, not a bot verdict. Missing signals do not prove fair play. Confirm against the replay before taking action."
+msgstr "Ayuda para la revisión, no un veredicto de bot. La ausencia de señales no demuestra juego limpio. Comprueba la repetición antes de tomar medidas."
+
+msgid "Fair play review"
+msgstr "Revisión de juego limpio"
+
+msgid "Season tournaments"
+msgstr "Torneos de temporada"
+
+msgid "Custom tournaments"
+msgstr "Torneos personalizados"
+
+msgid "No open custom tournaments right now."
+msgstr "No hay torneos personalizados abiertos en este momento."
+
+msgid "Legacy telemetry"
+msgstr "Telemetría antigua"
+
+msgid "Conflicting timing counters"
+msgstr "Contadores de tiempo contradictorios"
+
+msgid "Timing exceeds game duration"
+msgstr "El tiempo registrado supera la duración de la partida"
+
+msgid "Overlapping telemetry windows"
+msgstr "Ventanas de telemetría superpuestas"
+
+msgid "Missing key timing boundaries"
+msgstr "Faltan los límites de tiempo de las pulsaciones"
+
+msgid "Telemetry limitations"
+msgstr "Limitaciones de la telemetría"
+
+msgid "Unreliable timing features are excluded from scoring."
+msgstr "Los indicadores de tiempo poco fiables se excluyen de la puntuación."
+
+msgid "Incomplete telemetry"
+msgstr "Telemetría incompleta"
+
+msgid "Recorded edit coverage"
+msgstr "Cobertura de ediciones registradas"
+
+msgid "Gross inserted characters compared with final added length. Includes editor assistance and repeated replacements."
+msgstr "Total de caracteres insertados frente a la longitud final añadida. Incluye ayuda del editor y sustituciones repetidas."
+
+msgid "Incomplete telemetry or unrecorded edits"
+msgstr "Telemetría incompleta o ediciones no registradas"
+
+msgid "Editor command inserts"
+msgstr "Inserciones de comandos del editor"
+
+msgid "Edits attributed to editor commands, including Vim. An origin hint, not proof of fair play."
+msgstr "Ediciones atribuidas a comandos del editor, incluido Vim. Una pista de origen, no una prueba de juego limpio."
+
+msgid "Missing telemetry batch identity"
+msgstr "Falta la identidad del lote de telemetría"
+
+msgid "Missing telemetry batches"
+msgstr "Faltan lotes de telemetría"
+
+msgid "Multiple editor sessions"
+msgstr "Varias sesiones del editor"
+
+msgid "Incomplete edit coverage"
+msgstr "Registro de cambios incompleto"
+
+msgid "Batches outside competitive play excluded"
+msgstr "Se excluyeron lotes fuera de la partida"
+
+msgid "Moderator review"
+msgstr "Revisión del moderador"
+
+msgid "Outcome"
+msgstr "Resultado de la revisión"
+
+msgid "Inconclusive"
+msgstr "No concluyente"
+
+msgid "Legitimate"
+msgstr "Juego legítimo"
+
+msgid "Confirmed unauthorized assistance"
+msgstr "Asistencia no autorizada confirmada"
+
+msgid "Replay position (ms)"
+msgstr "Posición de la repetición (ms)"
+
+msgid "Save review"
+msgstr "Guardar revisión"
+
+msgid "Reviewer"
+msgstr "Revisor"
diff --git a/priv/gettext/ru/LC_MESSAGES/default.po b/priv/gettext/ru/LC_MESSAGES/default.po
index fde36a0c0..33a4fba17 100644
--- a/priv/gettext/ru/LC_MESSAGES/default.po
+++ b/priv/gettext/ru/LC_MESSAGES/default.po
@@ -6707,8 +6707,8 @@ msgstr "Выберите язык, прочитайте задачу и начн
 msgid "Preview an approachable task before starting. Your practice opponent is a bot."
 msgstr "Прочитайте несложную задачу перед началом. Ваш тренировочный соперник — бот."
 
-msgid "Write it. Run it."
-msgstr "Напишите код. Запустите тесты."
+msgid "Write code and run tests"
+msgstr "Напишите код и запустите тесты"
 
 msgid "Fill in the solution and run the tests. Use the results to improve your code."
 msgstr "Допишите решение и запустите тесты. Используйте результаты, чтобы улучшить код."
@@ -6946,3 +6946,132 @@ msgstr "Максимальный уровень"
 
 msgid "Rounds get harder: elementary first, then easy and medium. With Hard, the last round is hard."
 msgstr "Раунды усложняются: сначала элементарные задачи, потом лёгкие и средние. С уровнем «Сложный» последний раунд — сложная задача."
+
+msgid "No suspicious signals"
+msgstr "Подозрительных признаков нет"
+
+msgid "Weak signals"
+msgstr "Слабые признаки"
+
+msgid "Review suggested"
+msgstr "Рекомендуется проверка"
+
+msgid "Strong signals"
+msgstr "Сильные признаки"
+
+msgid "Insufficient telemetry"
+msgstr "Недостаточно телеметрии"
+
+msgid "Heuristic score, not a probability. 5+ suggests review; 10+ indicates stronger signals."
+msgstr "Эвристический балл, а не вероятность. От 5 — рекомендуется проверка; от 10 — более сильные признаки."
+
+msgid "Missing telemetry does not establish automation. Check the replay for connection gaps and editor activity."
+msgstr "Отсутствие телеметрии не доказывает автоматизацию. Проверьте запись игры: разрывы соединения и работу в редакторе."
+
+msgid "Bulk edit; review its origin"
+msgstr "Массовая правка: проверьте источник"
+
+msgid "Page focus loss / time unfocused"
+msgstr "Потери фокуса страницы / время без фокуса"
+
+msgid "Browser focus or visibility changes, including other windows and dialogs. Context only; does not affect the score."
+msgstr "Изменения фокуса или видимости браузера, включая другие окна и диалоги. Только для контекста: не влияют на балл."
+
+msgid "Most inserted characters (excluding spaces) in one received update. Connection gaps, undo and editor commands can also produce large updates."
+msgstr "Максимум вставленных символов без пробелов в одном полученном обновлении. Крупные обновления возможны при разрыве связи, отмене правок и командах редактора."
+
+msgid "Large update; check the replay"
+msgstr "Крупное обновление: проверьте запись"
+
+msgid "Review aid, not a bot verdict. Missing signals do not prove fair play. Confirm against the replay before taking action."
+msgstr "Помощь в проверке, а не вердикт о боте. Отсутствие признаков не доказывает честную игру. Перед принятием мер проверьте запись игры."
+
+msgid "Fair play review"
+msgstr "Проверка честной игры"
+
+msgid "Season tournaments"
+msgstr "Турниры сезона"
+
+msgid "Custom tournaments"
+msgstr "Пользовательские турниры"
+
+msgid "No open custom tournaments right now."
+msgstr "Сейчас нет открытых пользовательских турниров."
+
+msgid "Legacy telemetry"
+msgstr "Устаревшая телеметрия"
+
+msgid "Conflicting timing counters"
+msgstr "Противоречивые счётчики времени"
+
+msgid "Timing exceeds game duration"
+msgstr "Время телеметрии превышает длительность игры"
+
+msgid "Overlapping telemetry windows"
+msgstr "Пересекающиеся интервалы телеметрии"
+
+msgid "Missing key timing boundaries"
+msgstr "Нет границ интервалов нажатий"
+
+msgid "Telemetry limitations"
+msgstr "Ограничения телеметрии"
+
+msgid "Unreliable timing features are excluded from scoring."
+msgstr "Ненадёжные временные показатели исключены из оценки."
+
+msgid "Incomplete telemetry"
+msgstr "Неполная телеметрия"
+
+msgid "Recorded edit coverage"
+msgstr "Покрытие записанными правками"
+
+msgid "Gross inserted characters compared with final added length. Includes editor assistance and repeated replacements."
+msgstr "Все вставленные символы в сравнении с итоговым добавленным кодом. Включает помощь редактора и повторные замены."
+
+msgid "Incomplete telemetry or unrecorded edits"
+msgstr "Неполная телеметрия или незаписанные правки"
+
+msgid "Editor command inserts"
+msgstr "Вставки командами редактора"
+
+msgid "Edits attributed to editor commands, including Vim. An origin hint, not proof of fair play."
+msgstr "Правки, отнесённые к командам редактора, включая Vim. Подсказка об источнике, а не доказательство честной игры."
+
+msgid "Missing telemetry batch identity"
+msgstr "Нет идентификатора пакета телеметрии"
+
+msgid "Missing telemetry batches"
+msgstr "Пропущены пакеты телеметрии"
+
+msgid "Multiple editor sessions"
+msgstr "Несколько сессий редактора"
+
+msgid "Incomplete edit coverage"
+msgstr "Неполная запись изменений"
+
+msgid "Batches outside competitive play excluded"
+msgstr "Пакеты за пределами боя исключены"
+
+msgid "Moderator review"
+msgstr "Проверка модератора"
+
+msgid "Outcome"
+msgstr "Результат проверки"
+
+msgid "Inconclusive"
+msgstr "Недостаточно данных"
+
+msgid "Legitimate"
+msgstr "Честная игра"
+
+msgid "Confirmed unauthorized assistance"
+msgstr "Подтверждена запрещённая помощь"
+
+msgid "Replay position (ms)"
+msgstr "Позиция в записи (мс)"
+
+msgid "Save review"
+msgstr "Сохранить проверку"
+
+msgid "Reviewer"
+msgstr "Модератор"
diff --git a/priv/gettext/zh/LC_MESSAGES/default.po b/priv/gettext/zh/LC_MESSAGES/default.po
index 649a4a22e..4596f20e5 100644
--- a/priv/gettext/zh/LC_MESSAGES/default.po
+++ b/priv/gettext/zh/LC_MESSAGES/default.po
@@ -6894,8 +6894,8 @@ msgid ""
 "bot."
 msgstr "在开始之前预览一项容易完成的题目。你的练习对手是一个机器人。"
 
-msgid "Write it. Run it."
-msgstr "编写代码，运行测试。"
+msgid "Write code and run tests"
+msgstr "编写代码并运行测试"
 
 msgid ""
 "Fill in the solution and run the tests. Use the results to improve your "
@@ -7196,3 +7196,132 @@ msgstr "最高难度"
 
 msgid "Rounds get harder: elementary first, then easy and medium. With Hard, the last round is hard."
 msgstr "每轮难度递增：先是入门题，然后是简单和中等题。选择困难时，最后一轮为困难题。"
+
+msgid "No suspicious signals"
+msgstr "未发现可疑信号"
+
+msgid "Weak signals"
+msgstr "弱信号"
+
+msgid "Review suggested"
+msgstr "建议复核"
+
+msgid "Strong signals"
+msgstr "强信号"
+
+msgid "Insufficient telemetry"
+msgstr "遥测数据不足"
+
+msgid "Heuristic score, not a probability. 5+ suggests review; 10+ indicates stronger signals."
+msgstr "启发式评分，并非概率。5分以上建议复核；10分以上表示信号较强。"
+
+msgid "Missing telemetry does not establish automation. Check the replay for connection gaps and editor activity."
+msgstr "缺少遥测数据不能证明自动化。请检查回放中的连接中断和编辑器活动。"
+
+msgid "Bulk edit; review its origin"
+msgstr "批量编辑；请核查来源"
+
+msgid "Page focus loss / time unfocused"
+msgstr "页面失焦次数 / 失焦时长"
+
+msgid "Browser focus or visibility changes, including other windows and dialogs. Context only; does not affect the score."
+msgstr "浏览器焦点或可见性变化，包括其他窗口和对话框。仅供参考，不影响评分。"
+
+msgid "Most inserted characters (excluding spaces) in one received update. Connection gaps, undo and editor commands can also produce large updates."
+msgstr "单次收到的更新中插入的最多非空白字符数。连接中断、撤销和编辑器命令也可能产生大幅更新。"
+
+msgid "Large update; check the replay"
+msgstr "大幅更新；请检查回放"
+
+msgid "Review aid, not a bot verdict. Missing signals do not prove fair play. Confirm against the replay before taking action."
+msgstr "这是复核辅助工具，并非机器人判定。没有信号不能证明公平游戏。采取措施前请核对回放。"
+
+msgid "Fair play review"
+msgstr "公平游戏复核"
+
+msgid "Season tournaments"
+msgstr "赛季锦标赛"
+
+msgid "Custom tournaments"
+msgstr "自定义锦标赛"
+
+msgid "No open custom tournaments right now."
+msgstr "目前没有开放的自定义锦标赛。"
+
+msgid "Legacy telemetry"
+msgstr "旧版遥测"
+
+msgid "Conflicting timing counters"
+msgstr "计时计数相互矛盾"
+
+msgid "Timing exceeds game duration"
+msgstr "遥测时间超出对局时长"
+
+msgid "Overlapping telemetry windows"
+msgstr "遥测时间窗口重叠"
+
+msgid "Missing key timing boundaries"
+msgstr "缺少按键计时边界"
+
+msgid "Telemetry limitations"
+msgstr "遥测局限"
+
+msgid "Unreliable timing features are excluded from scoring."
+msgstr "不可靠的计时特征不参与评分。"
+
+msgid "Incomplete telemetry"
+msgstr "遥测数据不完整"
+
+msgid "Recorded edit coverage"
+msgstr "已记录编辑的覆盖率"
+
+msgid "Gross inserted characters compared with final added length. Includes editor assistance and repeated replacements."
+msgstr "累计插入字符数与最终新增代码长度之比，包含编辑器辅助和重复替换。"
+
+msgid "Incomplete telemetry or unrecorded edits"
+msgstr "遥测不完整或存在未记录的编辑"
+
+msgid "Editor command inserts"
+msgstr "编辑器命令插入"
+
+msgid "Edits attributed to editor commands, including Vim. An origin hint, not proof of fair play."
+msgstr "归因于编辑器命令的编辑，包括 Vim。仅提示来源，不能证明公平游戏。"
+
+msgid "Missing telemetry batch identity"
+msgstr "遥测批次标识缺失"
+
+msgid "Missing telemetry batches"
+msgstr "遥测批次缺失"
+
+msgid "Multiple editor sessions"
+msgstr "多个编辑器会话"
+
+msgid "Incomplete edit coverage"
+msgstr "编辑记录不完整"
+
+msgid "Batches outside competitive play excluded"
+msgstr "已排除对局之外的批次"
+
+msgid "Moderator review"
+msgstr "版主审核"
+
+msgid "Outcome"
+msgstr "审核结果"
+
+msgid "Inconclusive"
+msgstr "无法确定"
+
+msgid "Legitimate"
+msgstr "正常游戏"
+
+msgid "Confirmed unauthorized assistance"
+msgstr "已确认使用未经允许的辅助"
+
+msgid "Replay position (ms)"
+msgstr "回放位置（毫秒）"
+
+msgid "Save review"
+msgstr "保存审核"
+
+msgid "Reviewer"
+msgstr "审核人"
diff --git a/priv/repo/migrations/20261027150000_add_telemetry_snapshot_to_bot_reports.exs b/priv/repo/migrations/20261027150000_add_telemetry_snapshot_to_bot_reports.exs
new file mode 100644
index 000000000..8f2531101
--- /dev/null
+++ b/priv/repo/migrations/20261027150000_add_telemetry_snapshot_to_bot_reports.exs
@@ -0,0 +1,10 @@
+defmodule Codebattle.Repo.Migrations.AddTelemetrySnapshotToBotReports do
+  @moduledoc false
+  use Ecto.Migration
+
+  def change do
+    alter table(:game_bot_detection_reports) do
+      add(:telemetry_snapshot, :map, null: false, default: %{})
+    end
+  end
+end
diff --git a/priv/repo/migrations/20261028120000_add_fair_play_reviews.exs b/priv/repo/migrations/20261028120000_add_fair_play_reviews.exs
new file mode 100644
index 000000000..4024a2fb3
--- /dev/null
+++ b/priv/repo/migrations/20261028120000_add_fair_play_reviews.exs
@@ -0,0 +1,30 @@
+defmodule Codebattle.Repo.Migrations.AddFairPlayReviews do
+  @moduledoc false
+  use Ecto.Migration
+
+  def change do
+    alter table(:game_bot_detection_reports) do
+      add :evidence, {:array, :map}, null: false, default: []
+    end
+
+    create table(:game_fair_play_reviews) do
+      add :game_id, references(:games), null: false
+      add :user_id, references(:users), null: false
+      add :reviewer_id, references(:users), null: false
+      add :outcome, :string, null: false
+      add :reason, :text, null: false
+      add :replay_offset_ms, :bigint
+      add :report_version, :integer, null: false
+      add :report_snapshot, :map, null: false
+      timestamps(updated_at: false)
+    end
+
+    create index(:game_fair_play_reviews, [:game_id, :user_id])
+
+    create unique_index(
+             :game_editor_event_batches,
+             [:game_id, :user_id, "(summary->>'collector_session')", "(summary->>'batch_sequence')"],
+             name: :editor_batch_session_sequence
+           )
+  end
+end
diff --git a/priv/repo/migrations/20261028130000_store_competitive_report_code.exs b/priv/repo/migrations/20261028130000_store_competitive_report_code.exs
new file mode 100644
index 000000000..f75c5216e
--- /dev/null
+++ b/priv/repo/migrations/20261028130000_store_competitive_report_code.exs
@@ -0,0 +1,11 @@
+defmodule Codebattle.Repo.Migrations.StoreCompetitiveReportCode do
+  @moduledoc false
+  use Ecto.Migration
+
+  def change do
+    alter table(:game_bot_detection_reports) do
+      add :final_text, :text
+      add :final_lang, :string
+    end
+  end
+end
diff --git a/test/codebattle/game/bot_detection/batch_aggregator_test.exs b/test/codebattle/game/bot_detection/batch_aggregator_test.exs
index dc2fe91e1..d9a1a5e83 100644
--- a/test/codebattle/game/bot_detection/batch_aggregator_test.exs
+++ b/test/codebattle/game/bot_detection/batch_aggregator_test.exs
@@ -16,6 +16,15 @@ defmodule Codebattle.Game.BotDetection.BatchAggregatorTest do
     end
   end
 
+  describe "focus telemetry availability" do
+    test "old or mixed batches are unknown rather than evidence of zero focus loss" do
+      tracked = batch(%{"blur_count" => 0, "away_ms" => 0})
+      assert BatchAggregator.aggregate([tracked]).focus_tracked
+      refute BatchAggregator.aggregate([batch()]).focus_tracked
+      refute BatchAggregator.aggregate([batch(), tracked]).focus_tracked
+    end
+  end
+
   describe "aggregate/1 — single batch" do
     test "propagates fields from one batch" do
       stats = BatchAggregator.aggregate([batch()])
@@ -26,7 +35,7 @@ defmodule Codebattle.Game.BotDetection.BatchAggregatorTest do
       assert stats.total_printable_keys == 7
       assert stats.total_chars_inserted == 7
       assert stats.total_chars_deleted == 1
-      assert stats.total_idle_pauses == 1
+      assert stats.total_idle_pauses == 0
       assert stats.max_single_insert_len == 1
       assert stats.max_single_delete_len == 1
       assert stats.elapsed_ms == 10_000
diff --git a/test/codebattle/game/bot_detection/editor_history_test.exs b/test/codebattle/game/bot_detection/editor_history_test.exs
index 9e8cfe67b..a7253faab 100644
--- a/test/codebattle/game/bot_detection/editor_history_test.exs
+++ b/test/codebattle/game/bot_detection/editor_history_test.exs
@@ -7,6 +7,17 @@ defmodule Codebattle.Game.BotDetection.EditorHistoryTest do
   defp update(id, text, lang \\ "js"), do: %{type: :update_editor_data, id: id, editor_text: text, editor_lang: lang}
 
   describe "summarize_records/2 — live (raw) records" do
+    test "post-game practice updates are excluded at the first completion marker" do
+      records = [
+        %{type: :init, id: 1, editor_text: "", editor_lang: "js"},
+        %{type: :update_editor_data, id: 1, editor_text: "abc", editor_lang: "js"},
+        %{type: :game_over},
+        %{type: :update_editor_data, id: 1, editor_text: String.duplicate("x", 500), editor_lang: "js"}
+      ]
+
+      assert %{1 => %{updates: 1, max_jump: 3}} = EditorHistory.summarize_records(records)
+    end
+
     test "typing adds a few chars per update" do
       records = [
         init(1, "const solution = () => {\n};"),
@@ -63,6 +74,15 @@ defmodule Codebattle.Game.BotDetection.EditorHistoryTest do
       assert EditorHistory.added_chars("same", "same") == 0
     end
 
+    test "separate small edits do not count the unchanged code between them" do
+      middle = String.duplicate("unchanged_code();\n", 50)
+      before = "let first = 1;\n" <> middle <> "let last = 2;"
+      next = "let first = 3;\n" <> middle <> "let last = 4;"
+
+      assert EditorHistory.added_chars(before, next) == 2
+      assert %{1 => %{max_jump: 2}} = EditorHistory.summarize_records([init(1, before), update(1, next)])
+    end
+
     test "added_chars keeps multi-byte characters whole" do
       assert EditorHistory.added_chars("# привет", "# приветик") == 2
       assert EditorHistory.added_chars("ая", "аюя") == 1
diff --git a/test/codebattle/game/bot_detection/evaluation_test.exs b/test/codebattle/game/bot_detection/evaluation_test.exs
new file mode 100644
index 000000000..db5989fd5
--- /dev/null
+++ b/test/codebattle/game/bot_detection/evaluation_test.exs
@@ -0,0 +1,30 @@
+defmodule Codebattle.Game.BotDetection.EvaluationTest do
+  use ExUnit.Case, async: true
+
+  alias Codebattle.Game.BotDetection.Evaluation
+
+  test "counts reviewed outcomes and leaves undefined rates empty" do
+    assert %{precision: nil, recall: nil, false_positive_rate: nil} = Evaluation.summarize([])
+
+    rows = [
+      %{user_id: 1, outcome: "confirmed_assistance", score: 8},
+      %{user_id: 2, outcome: "confirmed_assistance", score: 0},
+      %{user_id: 3, outcome: "legitimate", score: 8},
+      %{user_id: 3, outcome: "legitimate", score: 0},
+      %{user_id: 4, outcome: "inconclusive", score: 12}
+    ]
+
+    assert %{
+             labelled: 4,
+             inconclusive: 1,
+             true_positive: 1,
+             false_positive: 1,
+             false_negative: 1,
+             true_negative: 1,
+             precision: 0.5,
+             recall: 0.5,
+             false_positive_rate: 0.5,
+             players: 3
+           } = Evaluation.summarize(rows)
+  end
+end
diff --git a/test/codebattle/game/bot_detection/review_test.exs b/test/codebattle/game/bot_detection/review_test.exs
new file mode 100644
index 000000000..75ef556de
--- /dev/null
+++ b/test/codebattle/game/bot_detection/review_test.exs
@@ -0,0 +1,26 @@
+defmodule Codebattle.Game.BotDetection.ReviewTest do
+  use Codebattle.DataCase, async: true
+
+  alias Codebattle.Game.BotDetection
+  alias Codebattle.Game.BotDetection.Analysis
+  alias Codebattle.Game.BotDetection.Review
+
+  test "only moderators can append validated decisions; rescoring preserves decisions" do
+    user = insert(:user)
+    moderator = insert(:user, subscription_type: :moderator)
+    game = insert(:game)
+    analysis = %Analysis{game_id: game.id, user_id: user.id, score: 8, level: :medium}
+    assert {:ok, _} = BotDetection.persist_analyses([analysis])
+    attrs = %{"outcome" => "legitimate", "reason" => "Vim command verified in replay", "replay_offset_ms" => 1000}
+    assert {:error, :forbidden} = Review.record(user, game.id, user.id, attrs)
+    assert {:error, _} = Review.record(moderator, game.id, user.id, Map.put(attrs, "reason", ""))
+    assert {:ok, review} = Review.record(moderator, game.id, user.id, attrs)
+    assert review.reviewer_id == moderator.id
+    assert review.report_snapshot.score == 8
+    assert {:ok, _} = BotDetection.persist_analyses([%{analysis | score: 0, level: :none}])
+    assert [stored] = Review.list(game.id)
+    assert stored.report_snapshot["score"] == 8
+    assert {:ok, _} = Review.record(moderator, game.id, user.id, Map.put(attrs, "outcome", "inconclusive"))
+    assert length(Review.list(game.id)) == 2
+  end
+end
diff --git a/test/codebattle/game/bot_detection/risk_scorer_test.exs b/test/codebattle/game/bot_detection/risk_scorer_test.exs
index a8b23bf42..07e2a3a23 100644
--- a/test/codebattle/game/bot_detection/risk_scorer_test.exs
+++ b/test/codebattle/game/bot_detection/risk_scorer_test.exs
@@ -33,6 +33,34 @@ defmodule Codebattle.Game.BotDetection.RiskScorerTest do
     Enum.any?(result.signals, &String.contains?(&1, substring))
   end
 
+  test "a paste in a separate window cannot discount an unexplained edit" do
+    paste = batch(%{"chars_inserted" => 200, "paste_chars" => 200, "paste_shortcut_attempt_count" => 1})
+    injected = batch(%{"chars_inserted" => 100, "printable_key_count" => 0, "key_event_count" => 0})
+    result = RiskScorer.score(%{stats: aggregate([paste, injected]), batches: [paste, injected]})
+    assert result.level == :high
+    assert Enum.any?(result.evidence, &(&1.code == "unexplained_insertions"))
+  end
+
+  test "modern evidence explains only the matching edit and preserves its replay offset" do
+    explained = %{
+      "offset_ms" => 1000,
+      "inserted_chars" => 200,
+      "assisted_chars" => 200,
+      "paste_chars" => 0,
+      "printable_keys" => 1
+    }
+
+    unexplained = %{explained | "offset_ms" => 5000, "assisted_chars" => 0}
+    b = batch(%{"collector_version" => 3, "edit_evidence" => [explained, unexplained]})
+    result = RiskScorer.score(%{stats: aggregate([b]), batches: [b], editor_history: %{max_jump: 200}})
+    assert [evidence] = result.evidence
+    assert evidence.code == "unexplained_edit"
+    assert evidence.replay_offset_ms == 5000
+    assert result.score == 8
+    b = batch(%{"collector_version" => 3, "edit_evidence" => [explained]})
+    assert RiskScorer.score(%{stats: aggregate([b]), batches: [b], editor_history: %{max_jump: 200}}).score == 0
+  end
+
   # ──────────────────────────────────────────────────────────────────────
   # Genuine humans — must NOT be flagged
   # ──────────────────────────────────────────────────────────────────────
@@ -65,13 +93,12 @@ defmodule Codebattle.Game.BotDetection.RiskScorerTest do
   # ──────────────────────────────────────────────────────────────────────
   # Tier 1 — programmatic injection
   # ──────────────────────────────────────────────────────────────────────
-  describe "WebSocket-only bot (no telemetry batches at all)" do
-    test "flagged as :high when no telemetry but solution > template" do
+  describe "Missing telemetry" do
+    test "missing batches cannot distinguish injection from a collection failure" do
       result = score(nil, final_length: 300, template_length: 170)
-      assert result.level == :high
-      assert result.score >= 10
-      assert signal_present?(result, "No keyboard telemetry recorded")
-      assert signal_present?(result, "via WebSocket without typing")
+      assert result.level == :none
+      assert result.score == 0
+      assert result.signals == []
     end
 
     test "not flagged when no telemetry and no real solution either" do
@@ -89,8 +116,8 @@ defmodule Codebattle.Game.BotDetection.RiskScorerTest do
 
       assert result.level == :high
       assert result.score >= 12
-      assert signal_present?(result, "looks programmatic")
-      assert signal_present?(result, "AI/extension/autotyper")
+      assert signal_present?(result, "unexplained edit window")
+      assert signal_present?(result, "review the replay and input method")
     end
   end
 
@@ -114,7 +141,7 @@ defmodule Codebattle.Game.BotDetection.RiskScorerTest do
       result = score(stats, final_length: 250, template_length: 170)
 
       assert result.level in [:medium, :high]
-      assert signal_present?(result, "fully programmatic")
+      assert signal_present?(result, "zero recorded keypresses")
     end
   end
 
@@ -246,7 +273,7 @@ defmodule Codebattle.Game.BotDetection.RiskScorerTest do
 
       # Effective = 100 - 20 = 80; typed = 20 → 25% coverage
       result = score(stats, final_length: 100, template_length: 20)
-      assert signal_present?(result, "typed 20 chars but added 80 chars")
+      refute signal_present?(result, "recorded edits cover 20 of 80 added chars")
     end
 
     test "moderate coverage (30–59%) emits a softer signal" do
@@ -261,7 +288,7 @@ defmodule Codebattle.Game.BotDetection.RiskScorerTest do
         ])
 
       result = score(stats, final_length: 120, template_length: 20)
-      assert signal_present?(result, "possible large paste")
+      refute signal_present?(result, "telemetry may be incomplete")
     end
 
     test "no signal when effective length < 60 (template ≈ final)" do
@@ -271,7 +298,7 @@ defmodule Codebattle.Game.BotDetection.RiskScorerTest do
         ])
 
       result = score(stats, final_length: 175, template_length: 170)
-      refute signal_present?(result, "possible large paste")
+      refute signal_present?(result, "telemetry may be incomplete")
       refute signal_present?(result, "typed")
     end
   end
@@ -293,15 +320,16 @@ defmodule Codebattle.Game.BotDetection.RiskScorerTest do
   # Tier 2 — LLM-style content
   # ──────────────────────────────────────────────────────────────────────
   describe "GPT-style code (English)" do
-    test "high comment ratio + many GPT phrases → flagged" do
+    test "comment style alone cannot reach the review threshold" do
       code = CodeAnalyzer.analyze(gpt_style_code())
       stats = aggregate(human_batches(count: 4, chars_per_batch: 40, keys_per_batch: 40))
 
       result = score(stats, code: code, final_length: 800, template_length: 170)
 
-      assert result.score >= 10
-      assert signal_present?(result, "GPT-style phrase")
-      assert signal_present?(result, "comment")
+      assert result.score == 0
+      assert result.level == :none
+      refute signal_present?(result, "GPT-style phrase")
+      refute signal_present?(result, "comment")
     end
   end
 
@@ -312,8 +340,9 @@ defmodule Codebattle.Game.BotDetection.RiskScorerTest do
 
       result = score(stats, code: code, final_length: 800, template_length: 170)
 
-      assert signal_present?(result, "GPT-style phrase")
-      assert result.score >= 5
+      refute signal_present?(result, "GPT-style phrase")
+      assert result.score <= 4
+      assert result.level == :none
     end
   end
 
@@ -339,8 +368,8 @@ defmodule Codebattle.Game.BotDetection.RiskScorerTest do
 
       result = score(%{}, code: code, final_length: 200, template_length: 100)
 
-      assert signal_present?(result, "high comment ratio")
-      assert signal_present?(result, "1 GPT-style phrase")
+      refute signal_present?(result, "high comment ratio")
+      refute signal_present?(result, "1 GPT-style phrase")
     end
 
     test "low comment ratios and no GPT phrases add no content signals" do
@@ -419,7 +448,7 @@ defmodule Codebattle.Game.BotDetection.RiskScorerTest do
         ])
 
       result = score(stats)
-      assert signal_present?(result, "zero idle pauses")
+      refute signal_present?(result, "zero idle pauses")
     end
   end
 
@@ -438,7 +467,7 @@ defmodule Codebattle.Game.BotDetection.RiskScorerTest do
         ])
 
       result = score(stats)
-      assert signal_present?(result, "no backspace/delete")
+      refute signal_present?(result, "no backspace/delete")
     end
 
     test "a short solution typed without mistakes → not flagged" do
@@ -501,7 +530,7 @@ defmodule Codebattle.Game.BotDetection.RiskScorerTest do
         ])
 
       result = score(stats)
-      assert signal_present?(result, "looks programmatic")
+      assert signal_present?(result, "unexplained edit window")
       refute signal_present?(result, "could be self-paste")
     end
 
@@ -513,18 +542,13 @@ defmodule Codebattle.Game.BotDetection.RiskScorerTest do
     end
   end
 
-  describe "Leaving the game" do
-    test "a short look away is fine" do
-      stats = aggregate([batch(%{"blur_count" => 2, "away_ms" => 10_000})])
-      refute signal_present?(score(stats), "left the game")
-    end
-
-    test "half a minute away is a weak signal, minutes a stronger one" do
-      short = score(aggregate([batch(%{"blur_count" => 1, "away_ms" => 40_000})]))
-      long = score(aggregate([batch(%{"blur_count" => 3, "away_ms" => 180_000})]))
-
-      assert signal_present?(short, "left the game 1 time(s), 40 s away")
-      assert long.score > short.score
+  describe "Browser focus is context only" do
+    test "neither brief nor long focus loss adds suspicion" do
+      for away <- [10_000, 40_000, 180_000] do
+        result = score(aggregate([batch(%{"blur_count" => 3, "away_ms" => away})]))
+        assert result.score == 0
+        assert result.signals == []
+      end
     end
   end
 
@@ -533,13 +557,13 @@ defmodule Codebattle.Game.BotDetection.RiskScorerTest do
       result = score(aggregate([batch(%{"paste_chars" => 0})]), history: %{updates: 10, max_jump: 150})
 
       assert signal_present?(result, "150 chars arrived in one editor update")
-      assert signal_present?(result, "not typed in the editor")
+      assert signal_present?(result, "review the replay and connection gaps")
       assert result.level in [:medium, :high]
     end
 
     test "flagged even without any telemetry" do
       result = score(nil, history: %{"updates" => 3, "max_jump" => 120})
-      assert signal_present?(result, "not typed in the editor")
+      assert signal_present?(result, "review the replay and connection gaps")
     end
 
     test "a paste of own code that big explains it" do
@@ -548,8 +572,8 @@ defmodule Codebattle.Game.BotDetection.RiskScorerTest do
           history: %{updates: 10, max_jump: 150}
         )
 
-      assert signal_present?(result, "explained by pasting")
-      refute signal_present?(result, "not typed in the editor")
+      assert signal_present?(result, "editor update")
+      assert result.score == 8
     end
 
     test "an undo makes it only a maybe" do
@@ -558,7 +582,7 @@ defmodule Codebattle.Game.BotDetection.RiskScorerTest do
           history: %{updates: 10, max_jump: 150}
         )
 
-      assert signal_present?(result, "maybe an undo")
+      assert signal_present?(result, "editor update")
     end
 
     test "small jumps (typing, completions) are ignored" do
@@ -600,6 +624,58 @@ defmodule Codebattle.Game.BotDetection.RiskScorerTest do
     end
   end
 
+  describe "Independent evidence and false-positive regressions" do
+    test "one large multiline edit is not counted as multiple independent signals" do
+      stats = aggregate(human_batches(count: 3, chars_per_batch: 100, keys_per_batch: 100))
+      stats = Map.merge(stats, %{total_large_inserts: 1, total_multi_line_inserts: 1, max_single_insert_len: 80})
+
+      result = score(stats, history: %{updates: 30, max_jump: 80})
+
+      assert result.score == 8
+      assert result.level == :medium
+      assert signal_present?(result, "large insert")
+      assert signal_present?(result, "multi-line insert")
+    end
+
+    test "many bulk counters alone cannot become high risk by repetition" do
+      stats = aggregate(human_batches(count: 3, chars_per_batch: 100, keys_per_batch: 100))
+      stats = Map.merge(stats, %{total_large_inserts: 100, total_multi_line_inserts: 100})
+      assert score(stats).score == 8
+    end
+
+    test "tracked self-paste with no keydowns is not programmatic injection" do
+      stats =
+        aggregate([
+          batch(%{
+            "key_event_count" => 0,
+            "printable_key_count" => 0,
+            "chars_inserted" => 200,
+            "paste_chars" => 200,
+            "content_change_count" => 1,
+            "multi_char_delete_count" => 1
+          })
+        ])
+
+      assert score(stats, history: %{updates: 4, max_jump: 200}).score == 8
+    end
+
+    test "editor-assisted edits explain an editor jump even with no keydowns" do
+      stats =
+        aggregate([
+          batch(%{
+            "key_event_count" => 0,
+            "printable_key_count" => 0,
+            "chars_inserted" => 200,
+            "assisted_chars" => 200,
+            "content_change_count" => 1,
+            "multi_char_delete_count" => 1
+          })
+        ])
+
+      assert score(stats, history: %{updates: 4, max_jump: 200}).score == 8
+    end
+  end
+
   # ──────────────────────────────────────────────────────────────────────
   # Score classification
   # ──────────────────────────────────────────────────────────────────────
diff --git a/test/codebattle/game/bot_detection/telemetry_quality_test.exs b/test/codebattle/game/bot_detection/telemetry_quality_test.exs
new file mode 100644
index 000000000..3a42d1d6b
--- /dev/null
+++ b/test/codebattle/game/bot_detection/telemetry_quality_test.exs
@@ -0,0 +1,129 @@
+defmodule Codebattle.Game.BotDetection.TelemetryQualityTest do
+  use ExUnit.Case, async: true
+
+  alias Codebattle.Game.BotDetection.BatchAggregator
+  alias Codebattle.Game.BotDetection.RiskScorer
+
+  defp window(overrides \\ %{}) do
+    %{
+      summary:
+        Map.merge(
+          %{
+            "collector_version" => 2,
+            "event_count" => 4,
+            "key_event_count" => 2,
+            "key_delta_sample_count" => 1,
+            "avg_key_delta_ms" => 100,
+            "min_key_delta_ms" => 100,
+            "max_key_delta_ms" => 100,
+            "idle_pause_over_2s_count" => 0,
+            "window_start_offset_ms" => 0,
+            "window_end_offset_ms" => 100,
+            "first_key_offset_ms" => 0,
+            "last_key_offset_ms" => 100
+          },
+          overrides
+        )
+    }
+  end
+
+  defp signals(stats) do
+    RiskScorer.score(%{stats: stats, code_analysis: nil, final_length: 0, template_length: 0}).signals
+  end
+
+  test "lost windows and collector changes disable rhythm rules" do
+    first = window(%{"collector_version" => 3, "collector_session" => "one", "batch_sequence" => 0})
+
+    third =
+      window(%{
+        "collector_version" => 3,
+        "collector_session" => "one",
+        "batch_sequence" => 2,
+        "window_start_offset_ms" => 200,
+        "window_end_offset_ms" => 300,
+        "first_key_offset_ms" => 200,
+        "last_key_offset_ms" => 300
+      })
+
+    stats = BatchAggregator.aggregate([third, first])
+    assert "missing_batch_sequence" in stats.quality_issues
+    refute stats.timing_reliable
+    other = window(%{"collector_version" => 3, "collector_session" => "two", "batch_sequence" => 0})
+    assert "multiple_collector_sessions" in BatchAggregator.aggregate([first, other]).quality_issues
+    assert "missing_batch_identity" in BatchAggregator.aggregate([window(%{"collector_version" => 3})]).quality_issues
+  end
+
+  test "a pause spanning two telemetry windows is retained in timing and idle totals" do
+    next =
+      window(%{
+        "window_start_offset_ms" => 5000,
+        "window_end_offset_ms" => 5100,
+        "first_key_offset_ms" => 5000,
+        "last_key_offset_ms" => 5100
+      })
+
+    stats = BatchAggregator.aggregate([window(), next])
+
+    assert stats.timing_reliable
+    assert stats.idle_pauses_reliable
+    assert stats.total_idle_pauses == 1
+    assert stats.max_key_delta_ms == 4900
+    assert stats.avg_key_delta_ms == 1700
+  end
+
+  test "current complete telemetry can still identify continuous uniform typing" do
+    stats =
+      BatchAggregator.aggregate([
+        window(%{
+          "key_event_count" => 80,
+          "key_delta_sample_count" => 79,
+          "window_end_offset_ms" => 39_500,
+          "last_key_offset_ms" => 39_500,
+          "min_key_delta_ms" => 500,
+          "avg_key_delta_ms" => 500,
+          "max_key_delta_ms" => 500
+        })
+      ])
+
+    assert stats.idle_pauses_reliable
+    refute Enum.any?(signals(stats), &String.contains?(&1, "zero idle"))
+    assert Enum.any?(signals(stats), &String.contains?(&1, "uniform"))
+  end
+
+  test "legacy missing key boundaries cannot establish a continuous session with zero pauses" do
+    legacy = window(%{"collector_version" => 0, "window_end_offset_ms" => 60_000})
+    stats = BatchAggregator.aggregate([legacy])
+    refute stats.idle_pauses_reliable
+    assert "legacy_collector" in stats.quality_issues
+    refute Enum.any?(signals(stats), &String.contains?(&1, "zero idle"))
+  end
+
+  test "a recorded long key interval contradicts zero idle pauses" do
+    stats = BatchAggregator.aggregate([window(%{"max_key_delta_ms" => 3000})])
+    refute stats.timing_reliable
+    refute stats.idle_pauses_reliable
+    assert "inconsistent_key_timing" in stats.quality_issues
+  end
+
+  test "three-hour offsets in a short game disable timing-based suspicion" do
+    stats = BatchAggregator.aggregate([window(%{"window_end_offset_ms" => 10_800_100})], duration_ms: 45_000)
+    assert "outside_game_window" in stats.quality_issues
+    refute stats.timing_reliable
+  end
+
+  test "overlapping keyboard windows are unknown rather than uniform zero-latency typing" do
+    stats = BatchAggregator.aggregate([window(), window()])
+    assert "overlapping_key_windows" in stats.quality_issues
+    refute stats.timing_reliable
+  end
+
+  test "invalid min/average/max ordering disables fast and uniform typing rules" do
+    stats =
+      BatchAggregator.aggregate([
+        window(%{"key_event_count" => 80, "avg_key_delta_ms" => 15, "min_key_delta_ms" => 100, "max_key_delta_ms" => 20})
+      ])
+
+    refute stats.timing_reliable
+    assert signals(stats) == []
+  end
+end
diff --git a/test/codebattle/game/bot_detection_test.exs b/test/codebattle/game/bot_detection_test.exs
index c6d705a34..19fcc2408 100644
--- a/test/codebattle/game/bot_detection_test.exs
+++ b/test/codebattle/game/bot_detection_test.exs
@@ -74,7 +74,7 @@ defmodule Codebattle.Game.BotDetectionTest do
 
       assert Enum.any?(
                a.signals,
-               &String.contains?(&1, "looks programmatic")
+               &String.contains?(&1, "unexplained edit window")
              )
     end
 
@@ -164,7 +164,42 @@ defmodule Codebattle.Game.BotDetectionTest do
   end
 
   describe "get_or_analyze/1" do
-    test "first call computes + persists; second call reads from DB", %{game: game} do
+    test "finished reports retain competitive code after practice edits and cache reuse", %{game: game, user1: user} do
+      lang = Enum.find(game.players, &(&1.id == user.id)).editor_lang
+      {:ok, _} = Context.update_editor_data(game.id, user, "competitive_solution", lang)
+      {:ok, _} = Context.trigger_timeout(game.id)
+      {:ok, _} = Context.update_editor_data(game.id, user, "post_game_practice", lang)
+      assert {:ok, analyses} = BotDetection.get_or_analyze(game.id)
+      assert Enum.find(analyses, &(&1.user_id == user.id)).final_text == "competitive_solution"
+      report = BotDetection.get_report(game.id, user.id)
+      assert report.final_text == "competitive_solution"
+      assert {:ok, cached} = BotDetection.get_or_analyze(game.id)
+      assert Enum.find(cached, &(&1.user_id == user.id)).final_text == "competitive_solution"
+    end
+
+    test "post-game telemetry windows do not contribute suspicion", %{game: game, user1: user} do
+      {:ok, _} = Context.store_editor_summary(game.id, user, late_summary(), "js")
+      {:ok, _} = Context.trigger_timeout(game.id)
+
+      later =
+        Map.merge(late_summary(), %{
+          "window_start_offset_ms" => 100_000,
+          "window_end_offset_ms" => 101_000,
+          "chars_inserted" => 500,
+          "printable_key_count" => 0
+        })
+
+      {:ok, _} = Context.store_editor_summary(game.id, user, later, "js")
+      assert {:ok, analyses} = BotDetection.get_or_analyze(game.id)
+      analysis = Enum.find(analyses, &(&1.user_id == user.id))
+      assert analysis.score == 0
+      assert analysis.stats.batch_count == 1
+      assert analysis.stats.excluded_batch_count == 1
+      assert "excluded_post_game_batches" in analysis.stats.quality_issues
+      assert analysis.telemetry_snapshot["count"] == 2
+    end
+
+    test "first call computes + persists; repeated calls return analyses", %{game: game} do
       assert BotDetection.list_reports(game.id) == []
 
       assert {:ok, analyses1} = BotDetection.get_or_analyze(game.id)
@@ -175,6 +210,70 @@ defmodule Codebattle.Game.BotDetectionTest do
       assert length(analyses2) == 2
     end
 
+    test "finished reports are reused until a late batch arrives", %{game: game, user1: user} do
+      {:ok, _} = Context.trigger_timeout(game.id)
+      {:ok, _} = BotDetection.get_or_analyze(game.id)
+      report = BotDetection.get_report(game.id, user.id)
+      assert %{"count" => 0, "last_id" => 0, "game_state" => "timeout"} = report.telemetry_snapshot
+
+      # A marker proves that an unchanged finished report is read, not recomputed.
+      report |> Ecto.Changeset.change(score: 99) |> Codebattle.Repo.update!()
+      {:ok, cached} = BotDetection.get_or_analyze(game.id)
+      assert Enum.find(cached, &(&1.user_id == user.id)).score == 99
+
+      {:ok, batch} = Context.store_editor_summary(game.id, user, late_summary(), "js")
+      {:ok, fresh} = BotDetection.get_or_analyze(game.id)
+      assert Enum.find(fresh, &(&1.user_id == user.id)).score != 99
+      assert %{"count" => 1, "last_id" => last_id} = BotDetection.get_report(game.id, user.id).telemetry_snapshot
+      assert last_id == batch.id
+    end
+
+    test "a batch arriving between analysis and persistence invalidates the snapshot", %{game: game, user1: user} do
+      {:ok, _} = Context.trigger_timeout(game.id)
+      {:ok, old} = BotDetection.analyze_game(game.id)
+      {:ok, batch} = Context.store_editor_summary(game.id, user, late_summary(), "js")
+      {:ok, _} = BotDetection.persist_analyses(old)
+
+      {:ok, fresh} = BotDetection.get_or_analyze(game.id)
+      assert Enum.find(fresh, &(&1.user_id == user.id)).stats.batch_count == 1
+      assert BotDetection.get_report(game.id, user.id).telemetry_snapshot["last_id"] == batch.id
+    end
+
+    test "missing player reports are recomputed even when other reports are current", %{game: game, user1: user} do
+      {:ok, _} = Context.trigger_timeout(game.id)
+      {:ok, _} = BotDetection.analyze_and_persist(game.id)
+      Codebattle.Repo.delete!(BotDetection.get_report(game.id, user.id))
+      {:ok, analyses} = BotDetection.get_or_analyze(game.id)
+      assert length(analyses) == 2
+      assert BotDetection.get_report(game.id, user.id)
+    end
+
+    test "live editor history is refreshed even without new telemetry", %{game: game, user1: user} do
+      {:ok, _} = BotDetection.get_or_analyze(game.id)
+      lang = Enum.find(game.players, &(&1.id == user.id)).editor_lang
+      {:ok, _} = Context.update_editor_data(game.id, user, "x", lang)
+      {:ok, _} = Context.update_editor_data(game.id, user, "x" <> String.duplicate("a", 120), lang)
+
+      {:ok, analyses} = BotDetection.get_or_analyze(game.id)
+      assert Enum.find(analyses, &(&1.user_id == user.id)).editor_history.max_jump == 120
+    end
+
+    test "finishing the game invalidates reports computed while it was playing", %{game: game, user1: user} do
+      {:ok, _} = BotDetection.analyze_and_persist(game.id)
+      old = BotDetection.get_report(game.id, user.id)
+      assert old.telemetry_snapshot["game_state"] == "playing"
+      {:ok, _} = Context.trigger_timeout(game.id)
+      # Simulate a slow live analysis completing after the game-finished worker.
+      old
+      |> Ecto.Changeset.change(score: 99)
+      |> Ecto.Changeset.force_change(:telemetry_snapshot, old.telemetry_snapshot)
+      |> Codebattle.Repo.update!()
+
+      {:ok, analyses} = BotDetection.get_or_analyze(game.id)
+      assert Enum.find(analyses, &(&1.user_id == user.id)).score != 99
+      assert BotDetection.get_report(game.id, user.id).telemetry_snapshot["game_state"] == "timeout"
+    end
+
     test "a player without telemetry reads back with no stats", %{game: game, user1: user} do
       {:ok, _} = BotDetection.analyze_and_persist(game.id)
       assert BotDetection.get_report(game.id, user.id).stats == %{}
@@ -247,6 +346,17 @@ defmodule Codebattle.Game.BotDetectionTest do
     end
   end
 
+  defp late_summary do
+    %{
+      "event_count" => 4,
+      "key_event_count" => 2,
+      "printable_key_count" => 2,
+      "chars_inserted" => 2,
+      "window_start_offset_ms" => 100,
+      "window_end_offset_ms" => 200
+    }
+  end
+
   describe "schedule_analysis/2 + Worker" do
     test "Oban inline mode runs the worker and persists reports", %{game: game} do
       assert BotDetection.list_reports(game.id) == []
diff --git a/test/codebattle/game/context_test.exs b/test/codebattle/game/context_test.exs
index 0554e4453..32cd9f626 100644
--- a/test/codebattle/game/context_test.exs
+++ b/test/codebattle/game/context_test.exs
@@ -106,6 +106,35 @@ defmodule Codebattle.Game.ContextTest do
       assert batch.summary["printable_key_count"] == 3
       assert batch.summary["chars_inserted"] == 7
       refute Map.has_key?(batch.summary, "lang_slug")
+      refute Map.has_key?(batch.summary, "assisted_chars")
+      refute Map.has_key?(batch.summary, "paste_chars")
+      refute Map.has_key?(batch.summary, "blur_count")
+      refute Map.has_key?(batch.summary, "collector_version")
+    end
+
+    test "preserves explicit zero-valued capabilities and collector key boundaries", %{user: user, game: game} do
+      summary = %{
+        "eventCount" => 1,
+        "windowStartOffsetMs" => 0,
+        "windowEndOffsetMs" => 100,
+        "collectorVersion" => 2,
+        "firstKeyOffsetMs" => 0,
+        "lastKeyOffsetMs" => 100,
+        "assistedChars" => 0,
+        "pasteChars" => 0,
+        "blurCount" => 0,
+        "awayMs" => 0,
+        "commandInsertCount" => 1
+      }
+
+      assert {:ok, batch} = Game.Context.store_editor_summary(game.id, user, summary, "js")
+      assert batch.summary["collector_version"] == 2
+      assert batch.summary["first_key_offset_ms"] == 0
+      assert batch.summary["last_key_offset_ms"] == 100
+      assert batch.summary["assisted_chars"] == 0
+      assert batch.summary["paste_chars"] == 0
+      assert batch.summary["blur_count"] == 0
+      assert batch.summary["command_insert_count"] == 1
     end
 
     test "persists batch when summary uses snake_case keys", %{user: user, game: game} do
diff --git a/test/codebattle/game/editor_event_batch_test.exs b/test/codebattle/game/editor_event_batch_test.exs
new file mode 100644
index 000000000..29760f965
--- /dev/null
+++ b/test/codebattle/game/editor_event_batch_test.exs
@@ -0,0 +1,35 @@
+defmodule Codebattle.Game.EditorEventBatchTest do
+  use Codebattle.DataCase, async: true
+
+  alias Codebattle.Game.EditorEventBatch
+
+  test "retrying a sequence is idempotent; a new collector session remains distinct" do
+    user = insert(:user)
+    game = insert(:game)
+
+    attrs = %{
+      user_id: user.id,
+      game_id: game.id,
+      lang: "js",
+      event_count: 1,
+      window_start_offset_ms: 0,
+      window_end_offset_ms: 100,
+      batch_started_at: ~U[2026-10-28 00:00:00.000000Z],
+      batch_ended_at: ~U[2026-10-28 00:00:00.100000Z],
+      summary: %{"collector_session" => "session-one", "batch_sequence" => 0}
+    }
+
+    assert {:ok, _} = EditorEventBatch.create(attrs)
+    assert {:ok, _} = EditorEventBatch.create(attrs)
+    assert length(EditorEventBatch.list_by_game(game.id)) == 1
+
+    assert {:ok, _} =
+             EditorEventBatch.create(%{attrs | summary: %{"collector_session" => "session-two", "batch_sequence" => 0}})
+
+    assert length(EditorEventBatch.list_by_game(game.id)) == 2
+    # Legacy batches have no stable identity; never silently deduplicate them.
+    assert {:ok, _} = EditorEventBatch.create(%{attrs | summary: %{"event_count" => 1}})
+    assert {:ok, _} = EditorEventBatch.create(%{attrs | summary: %{"event_count" => 1}})
+    assert length(EditorEventBatch.list_by_game(game.id)) == 4
+  end
+end
diff --git a/test/codebattle_web/controllers/game_controller_test.exs b/test/codebattle_web/controllers/game_controller_test.exs
index 305778e28..e81e1aea0 100644
--- a/test/codebattle_web/controllers/game_controller_test.exs
+++ b/test/codebattle_web/controllers/game_controller_test.exs
@@ -273,6 +273,26 @@ defmodule CodebattleWeb.GameControllerTest do
     end
   end
 
+  describe "POST games/:id/ml/reviews" do
+    test "only moderators can record a decision; it is hidden from ordinary viewers", %{conn: conn} do
+      [first, second] = insert_list(2, :user)
+      admin = insert(:admin)
+      {:ok, game} = Game.Context.create_game(%{state: "game_over", players: [first, second], task: insert(:task)})
+      assert {:ok, _} = Game.BotDetection.analyze_and_persist(game.id)
+      attrs = %{user_id: first.id, outcome: "legitimate", reason: "Checked the replay and Vim commands"}
+      forbidden = conn |> log_in_user(first.id) |> post("/games/#{game.id}/ml/reviews", attrs)
+      assert response(forbidden, 403)
+      saved = conn |> log_in_user(admin.id) |> post("/games/#{game.id}/ml/reviews", attrs)
+      assert redirected_to(saved) == "/games/#{game.id}/ml"
+      public = conn |> log_in_user(first.id) |> get("/games/#{game.id}/ml")
+      assert inertia_props(public)["reviews"] == []
+      private = conn |> log_in_user(admin.id) |> get("/games/#{game.id}/ml")
+      assert [%{outcome: "legitimate"}] = inertia_props(private)["reviews"]
+      invalid = conn |> log_in_user(admin.id) |> post("/games/#{game.id}/ml/reviews", %{user_id: "invalid"})
+      assert response(invalid, 422)
+    end
+  end
+
   describe "GET games/:id/ml" do
     test "opens the report for any user once the game is over, without Re-analyze", %{conn: conn} do
       [first, second] = insert_list(2, :user)
diff --git a/test/support/bot_detection_fixtures.ex b/test/support/bot_detection_fixtures.ex
index 3582c0d69..f01dcee0f 100644
--- a/test/support/bot_detection_fixtures.ex
+++ b/test/support/bot_detection_fixtures.ex
@@ -49,7 +49,7 @@ defmodule Codebattle.BotDetectionFixtures do
       "paste_shortcut_attempt_count" => 0,
       "copy_shortcut_count" => 0,
       "cut_shortcut_count" => 0,
-      "idle_pause_over_2s_count" => 1,
+      "idle_pause_over_2s_count" => 0,
       "backspace_count" => 1,
       "delete_count" => 0,
       "arrow_key_count" => 0,
@@ -87,7 +87,7 @@ defmodule Codebattle.BotDetectionFixtures do
           "idle_pause_over_2s_count" => 2,
           "avg_key_delta_ms" => 250,
           "min_key_delta_ms" => 80,
-          "max_key_delta_ms" => 1500,
+          "max_key_delta_ms" => 2500,
           "key_delta_sample_count" => keys_per - 1,
           "max_single_insert_len" => 1,
           "max_single_delete_len" => 1,