From fbc0c7611946f233a988038471ec69033eddd586 Mon Sep 17 00:00:00 2001
From: Maseeek <maseeekyt@gmail.com>
Date: Mon, 12 Oct 2026 03:12:02 +0100
Subject: [PATCH 01/10] perf(sync): coalesce Duel reloads and preserve local
 writes

Serialize Duel refreshes and collapse realtime bursts into one bounded
reload plus one follow-up when events arrive during a load. Reject reads
that overlap queued local writes so stale data cannot undo optimistic UI.

Request exact pagination counts once when available and retain complete
history under lower server page caps. Remove polling of the retired
Apple Health endpoint, which already returns HTTP 410.

Refs #63.
---
 src/lib/coalesced-reload.test.ts | 149 +++++++++++++++++++++++
 src/lib/coalesced-reload.ts      |  71 +++++++++++
 src/lib/duel-sync.test.ts        | 131 +++++++++++++++++++++
 src/lib/duel-sync.ts             |  17 ++-
 src/lib/store.tsx                | 196 +++++++++++++------------------
 5 files changed, 443 insertions(+), 121 deletions(-)
 create mode 100644 src/lib/coalesced-reload.test.ts
 create mode 100644 src/lib/coalesced-reload.ts
 create mode 100644 src/lib/duel-sync.test.ts

diff --git a/src/lib/coalesced-reload.test.ts b/src/lib/coalesced-reload.test.ts
new file mode 100644
index 0000000..7814b40
--- /dev/null
+++ b/src/lib/coalesced-reload.test.ts
@@ -0,0 +1,149 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createCoalescedReloader } from './coalesced-reload';
+
+const settle = () => new Promise<void>(resolve => setImmediate(resolve));
+const fail = (error: unknown) => { throw error; };
+
+function deferred() {
+  let release: (() => void) | undefined;
+  const promise = new Promise<void>(resolve => { release = resolve; });
+  return { promise, resolve: () => { assert.ok(release); release(); } };
+}
+
+test('rapid realtime events share one trailing reload', async t => {
+  t.mock.timers.enable({ apis: ['setTimeout', 'Date'], now: 0 });
+  let executions = 0;
+  const reloader = createCoalescedReloader(async () => { executions++; }, { onError: fail });
+  for (let event = 0; event < 5; event++) {
+    reloader.schedule();
+    t.mock.timers.tick(5);
+  }
+  t.mock.timers.tick(44);
+  assert.equal(executions, 0);
+  t.mock.timers.tick(1);
+  assert.equal(executions, 1);
+  await settle();
+  t.mock.timers.tick(1000);
+  assert.equal(executions, 1);
+});
+
+test('continuous realtime events cannot postpone a reload beyond the maximum wait', async t => {
+  t.mock.timers.enable({ apis: ['setTimeout', 'Date'], now: 0 });
+  let executions = 0;
+  const reloader = createCoalescedReloader(async () => { executions++; }, { onError: fail });
+  reloader.schedule();
+  for (let event = 0; event < 3; event++) {
+    t.mock.timers.tick(40);
+    reloader.schedule();
+  }
+  t.mock.timers.tick(29);
+  assert.equal(executions, 0);
+  t.mock.timers.tick(1);
+  assert.equal(executions, 1);
+  await settle();
+});
+
+test('an immediate reload replaces a pending debounce timer', async t => {
+  t.mock.timers.enable({ apis: ['setTimeout', 'Date'], now: 0 });
+  let executions = 0;
+  const reloader = createCoalescedReloader(async () => { executions++; }, { onError: fail });
+  reloader.schedule();
+  t.mock.timers.tick(20);
+  reloader.schedule({ immediate: true });
+  assert.equal(executions, 1);
+  await settle();
+  t.mock.timers.tick(1000);
+  assert.equal(executions, 1);
+});
+
+test('events during a reload request one serialized follow-up', async () => {
+  const first = deferred();
+  const second = deferred();
+  let executions = 0;
+  const reloader = createCoalescedReloader(async () => {
+    executions++;
+    await (executions === 1 ? first.promise : second.promise);
+  }, { onError: fail });
+  reloader.schedule({ immediate: true });
+  reloader.schedule();
+  reloader.schedule();
+  reloader.schedule({ immediate: true });
+  assert.equal(executions, 1);
+  first.resolve();
+  await settle();
+  assert.equal(executions, 2);
+  second.resolve();
+  await settle();
+  assert.equal(executions, 2);
+});
+
+test('reload failures surface and a queued follow-up still runs', async () => {
+  const first = deferred();
+  const expected = new Error('Database connection failed');
+  const errors: unknown[] = [];
+  let executions = 0;
+  const reloader = createCoalescedReloader(async () => {
+    executions++;
+    if (executions === 1) {
+      await first.promise;
+      throw expected;
+    }
+  }, { onError: error => { errors.push(error); } });
+  reloader.schedule({ immediate: true });
+  reloader.schedule();
+  first.resolve();
+  await settle();
+  assert.deepEqual(errors, [expected]);
+  assert.equal(executions, 2);
+  reloader.schedule({ immediate: true });
+  await settle();
+  assert.equal(executions, 3);
+});
+
+test('cleanup stops timers and all later requests', t => {
+  t.mock.timers.enable({ apis: ['setTimeout', 'Date'], now: 0 });
+  let executions = 0;
+  const reloader = createCoalescedReloader(async () => { executions++; }, { onError: fail });
+  reloader.schedule();
+  reloader.cancel();
+  assert.equal(reloader.isCancelled, true);
+  t.mock.timers.tick(1000);
+  reloader.schedule({ immediate: true });
+  reloader.schedule();
+  t.mock.timers.tick(1000);
+  assert.equal(executions, 0);
+});
+
+test('cleanup during a reload stops follow-ups and late error callbacks', async () => {
+  const first = deferred();
+  let executions = 0;
+  const errors: unknown[] = [];
+  const reloader = createCoalescedReloader(async () => {
+    executions++;
+    await first.promise;
+    throw new Error('Late network error');
+  }, { onError: error => { errors.push(error); } });
+  reloader.schedule({ immediate: true });
+  reloader.schedule();
+  reloader.cancel();
+  first.resolve();
+  await settle();
+  assert.equal(executions, 1);
+  assert.deepEqual(errors, []);
+});
+
+test('successive Duel effects do not share pending reloads', async t => {
+  t.mock.timers.enable({ apis: ['setTimeout', 'Date'], now: 0 });
+  let executionsA = 0;
+  let executionsB = 0;
+  const duelA = createCoalescedReloader(async () => { executionsA++; }, { onError: fail });
+  const duelB = createCoalescedReloader(async () => { executionsB++; }, { onError: fail });
+  duelA.schedule();
+  duelB.schedule();
+  duelA.cancel();
+  t.mock.timers.tick(50);
+  await settle();
+  assert.equal(executionsA, 0);
+  assert.equal(executionsB, 1);
+});
diff --git a/src/lib/coalesced-reload.ts b/src/lib/coalesced-reload.ts
new file mode 100644
index 0000000..e95cf8f
--- /dev/null
+++ b/src/lib/coalesced-reload.ts
@@ -0,0 +1,71 @@
+interface CoalescedReloaderOptions {
+  onError: (error: unknown) => void;
+  debounceMs?: number;
+  maxWaitMs?: number;
+}
+
+// Realtime bursts share one reload. Events during a reload request one follow-up.
+export function createCoalescedReloader(
+  action: () => Promise<void>,
+  options: CoalescedReloaderOptions,
+) {
+  const debounceMs = options.debounceMs ?? 50;
+  const maxWaitMs = options.maxWaitMs ?? debounceMs * 3;
+  let cancelled = false;
+  let running = false;
+  let followUp = false;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let burstStartedAt: number | undefined;
+
+  function clearTimer() {
+    clearTimeout(timer);
+    timer = undefined;
+    burstStartedAt = undefined;
+  }
+
+  async function execute() {
+    if (cancelled) return;
+    running = true;
+    try {
+      await action();
+    } catch (error) {
+      if (!cancelled) options.onError(error);
+    } finally {
+      running = false;
+      if (followUp && !cancelled) {
+        followUp = false;
+        void execute();
+      }
+    }
+  }
+
+  return {
+    schedule({ immediate = false }: { immediate?: boolean } = {}) {
+      if (cancelled) return;
+      if (running) {
+        followUp = true;
+        return;
+      }
+      if (immediate) {
+        clearTimer();
+        void execute();
+        return;
+      }
+
+      const now = Date.now();
+      burstStartedAt ??= now;
+      clearTimeout(timer);
+      const delay = Math.min(debounceMs, Math.max(0, maxWaitMs - (now - burstStartedAt)));
+      timer = setTimeout(() => {
+        clearTimer();
+        void execute();
+      }, delay);
+    },
+    cancel() {
+      cancelled = true;
+      followUp = false;
+      clearTimer();
+    },
+    get isCancelled() { return cancelled; },
+  };
+}
diff --git a/src/lib/duel-sync.test.ts b/src/lib/duel-sync.test.ts
new file mode 100644
index 0000000..796c872
--- /dev/null
+++ b/src/lib/duel-sync.test.ts
@@ -0,0 +1,131 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { fetchDuelRows } from './duel-sync';
+import type { SupabaseClient } from '@supabase/supabase-js';
+
+describe('Duel Rows Pagination and Count Elimination Safety', () => {
+  interface MockRow {
+    id: string;
+    duel_id: string;
+    data: { id: string; name: string };
+  }
+
+  function createMockSupabaseClient(options: {
+    totalRows: number;
+    backendPageCap?: number;
+    onQuery?: (params: { offset: number; pageSize: number; selectCountOption?: { count?: string } }) => void;
+  }): { client: SupabaseClient; getQueries: () => Array<{ offset: number; selectCountOption?: { count?: string } }> } {
+    const allData: MockRow[] = Array.from({ length: options.totalRows }, (_, i) => ({
+      id: `row-${String(i).padStart(6, '0')}`,
+      duel_id: 'duel-test',
+      data: { id: `item-${i}`, name: `Item ${i}` },
+    }));
+
+    const queries: Array<{ offset: number; selectCountOption?: { count?: string } }> = [];
+
+    const mockClient = {
+      from(table: string) {
+        assert.ok(table === 'duel_habits' || table === 'duel_check_ins');
+        return {
+          select(columns: string, selectOptions?: { count?: 'exact' }) {
+            assert.equal(columns, 'data');
+            return {
+              eq(column: string, value: string) {
+                assert.equal(column, 'duel_id');
+                assert.equal(value, 'duel-test');
+                return {
+                  order(orderColumn: string) {
+                    assert.equal(orderColumn, 'id');
+                    return {
+                      range(start: number, end: number) {
+                        queries.push({ offset: start, selectCountOption: selectOptions });
+                        options.onQuery?.({ offset: start, pageSize: end - start + 1, selectCountOption: selectOptions });
+
+                        // Apply server-side max-rows cap if specified
+                        const requestedCount = end - start + 1;
+                        const effectiveLimit = options.backendPageCap
+                          ? Math.min(requestedCount, options.backendPageCap)
+                          : requestedCount;
+
+                        const pageRows = allData.slice(start, start + effectiveLimit);
+                        return Promise.resolve({
+                          data: pageRows,
+                          count: selectOptions?.count === 'exact' ? allData.length : null,
+                          error: null,
+                        });
+                      },
+                    };
+                  },
+                };
+              },
+            };
+          },
+        };
+      },
+    } as unknown as SupabaseClient;
+
+    return { client: mockClient, getQueries: () => queries };
+  }
+
+  it('pagination returns complete history for 0 rows', async () => {
+    const { client, getQueries } = createMockSupabaseClient({ totalRows: 0 });
+    const rows = await fetchDuelRows<{ id: string; name: string }>(client, 'duel_habits', 'duel-test');
+
+    assert.deepStrictEqual(rows, []);
+    assert.strictEqual(getQueries().length, 1);
+    assert.strictEqual(getQueries()[0].selectCountOption?.count, 'exact');
+  });
+
+  it('pagination returns complete history for exactly 1000 rows in single query with count', async () => {
+    const { client, getQueries } = createMockSupabaseClient({ totalRows: 1000 });
+    const rows = await fetchDuelRows<{ id: string; name: string }>(client, 'duel_habits', 'duel-test');
+
+    assert.strictEqual(rows.length, 1000);
+    assert.strictEqual(rows[0].id, 'item-0');
+    assert.strictEqual(rows[999].id, 'item-999');
+    assert.strictEqual(getQueries().length, 1, 'Should complete in 1 page when count matches total rows');
+    assert.strictEqual(getQueries()[0].selectCountOption?.count, 'exact');
+  });
+
+  it('pagination returns complete history for >1000 rows without repeated count queries', async () => {
+    const total = 2500;
+    const { client, getQueries } = createMockSupabaseClient({ totalRows: total });
+    const rows = await fetchDuelRows<{ id: string; name: string }>(client, 'duel_check_ins', 'duel-test');
+
+    assert.strictEqual(rows.length, 2500);
+    assert.strictEqual(rows[0].id, 'item-0');
+    assert.strictEqual(rows[2499].id, 'item-2499');
+
+    const queries = getQueries();
+    assert.strictEqual(queries.length, 3, '2500 rows should take 3 pages (1000, 1000, 500)');
+    // First query requests count exact
+    assert.strictEqual(queries[0].selectCountOption?.count, 'exact', 'First query requests count exact');
+    // Subsequent queries must NOT request count exact (safely eliminated!)
+    assert.strictEqual(queries[1].selectCountOption?.count, undefined, 'Second query eliminates count exact');
+    assert.strictEqual(queries[2].selectCountOption?.count, undefined, 'Third query eliminates count exact');
+  });
+
+  it('pagination handles PostgREST backend capping page below 1000 without dropping records', async () => {
+    // PostgREST max-rows configured to 400, but table has 1250 rows
+    const total = 1250;
+    const { client, getQueries } = createMockSupabaseClient({
+      totalRows: total,
+      backendPageCap: 400,
+    });
+
+    const rows = await fetchDuelRows<{ id: string; name: string }>(client, 'duel_check_ins', 'duel-test');
+
+    // Must return all 1250 rows without dropping any records!
+    assert.strictEqual(rows.length, 1250, 'All 1250 records must be present');
+    assert.strictEqual(rows[0].id, 'item-0');
+    assert.strictEqual(rows[1249].id, 'item-1249');
+
+    const queries = getQueries();
+    // 400 + 400 + 400 + 50 = 1250 (4 queries)
+    assert.strictEqual(queries.length, 4);
+    assert.strictEqual(queries[0].selectCountOption?.count, 'exact', 'Count requested on page 0');
+    assert.strictEqual(queries[1].selectCountOption?.count, undefined, 'Subsequent pages omit count');
+    assert.strictEqual(queries[2].selectCountOption?.count, undefined);
+    assert.strictEqual(queries[3].selectCountOption?.count, undefined);
+  });
+});
diff --git a/src/lib/duel-sync.ts b/src/lib/duel-sync.ts
index 701986f..d28ec76 100644
--- a/src/lib/duel-sync.ts
+++ b/src/lib/duel-sync.ts
@@ -1,15 +1,24 @@
 import type { SupabaseClient } from '@supabase/supabase-js';
 import type { CheckIn, CouplesReaction, Habit, RestDay, Stake } from './types';
 
-async function fetchDuelRows<T>(client: SupabaseClient, table: string, duelId: string): Promise<T[]> {
+export async function fetchDuelRows<T>(client: SupabaseClient, table: string, duelId: string): Promise<T[]> {
   const rows: T[] = [];
   const pageSize = 1000;
+  let totalCount: number | null = null;
   for (let offset = 0; ;) {
-    const { data, count, error } = await client.from(table).select('data', { count: 'exact' }).eq('duel_id', duelId)
-      .order('id').range(offset, offset + pageSize - 1);
+    const selectOptions: { count?: 'exact' } = totalCount === null ? { count: 'exact' } : {};
+    const { data, count, error } = await client
+      .from(table)
+      .select('data', selectOptions)
+      .eq('duel_id', duelId)
+      .order('id')
+      .range(offset, offset + pageSize - 1);
     if (error) throw error;
+    if (totalCount === null && typeof count === 'number') {
+      totalCount = count;
+    }
     rows.push(...(data || []).map(row => row.data as T));
-    if (!data?.length || (count !== null && rows.length >= count) || (count === null && data.length < pageSize)) return rows;
+    if (!data?.length || (totalCount !== null && rows.length >= totalCount) || (totalCount === null && data.length < pageSize)) return rows;
     offset += data.length;
   }
 }
diff --git a/src/lib/store.tsx b/src/lib/store.tsx
index 648059a..214cd70 100644
--- a/src/lib/store.tsx
+++ b/src/lib/store.tsx
@@ -41,6 +41,7 @@ import { soundEngine } from './sound-utils';
 import { hapticCelebration, hapticLight, hapticMedium, hapticSuccess } from './haptic-utils';
 import { getSupabaseClient } from './supabase';
 import { useMultiplayer } from './multiplayer';
+import { createCoalescedReloader } from './coalesced-reload';
 import { loadDuelData, saveDuelHabit, deleteDuelHabit, saveDuelCheckIn, deleteDuelCheckIn, saveDuelStake, deleteDuelStake, saveDuelReaction, saveDuelRestDay, deleteDuelRestDay } from './duel-sync';
 import {
   habitToRow,
@@ -460,87 +461,99 @@ export function StoreProvider({ children }: { children: React.ReactNode }) {
       setSyncStatus('local_only');
       return;
     }
-    let cancelled = false;
     if (stateDuelRef.current !== duelId) {
       setLoadedDuelId(null);
       setSyncStatus('syncing');
     }
-    const reload = async () => {
+    const reloader = createCoalescedReloader(async () => {
       const sequence = ++reloadSequenceRef.current;
-      try {
-        await duelQueueRef.current;
-        let data = await loadDuelData(client, duelId);
-        const restoreKey = `${duelId}:${multiplayer.slot}`;
-        if (
-          multiplayer.slot &&
-          canImportLegacyDatabase(multiplayer.slot, multiplayer.user?.email) &&
-          needsLegacyReplacement(multiplayer.slot, data.habits) &&
-          !restorationInProgressRef.current[restoreKey]
-        ) {
-          restorationInProgressRef.current[restoreKey] = true;
-          const slot = multiplayer.slot;
-          const restoration = duelQueueRef.current
-            .then(() => restoreLegacyDuelProgress(client, duelId, slot, data.habits, data.checkIns))
-            .finally(() => {
-              delete restorationInProgressRef.current[restoreKey];
-            });
-          duelQueueRef.current = restoration.then(() => {}, () => {});
-          if (await restoration) data = await loadDuelData(client, duelId);
-        }
-        if (cancelled) return;
-        if (sequence < latestAppliedSequenceRef.current) return;
-        latestAppliedSequenceRef.current = sequence;
-        const initial = getInitialState();
-        const sameDuel = stateDuelRef.current === duelId && stateSlotRef.current === multiplayer.slot;
-        stateDuelRef.current = duelId;
-        stateSlotRef.current = multiplayer.slot;
-        const partnerPaired = multiplayer.hasPairedPartner;
-        const visibleHabits = partnerPaired ? data.habits : data.habits.filter(h => h.playerId === multiplayer.slot);
-        const visibleCheckIns = partnerPaired ? data.checkIns : data.checkIns.filter(c => c.playerId === multiplayer.slot);
-        const visibleReactions = partnerPaired ? data.reactions : data.reactions.filter(r => r.fromPlayerId === multiplayer.slot && r.toPlayerId === multiplayer.slot);
-        const visibleRestDays = partnerPaired ? data.restDays : data.restDays.filter(r => r.playerId === multiplayer.slot);
-        const ownerColor = PLAYER_COLORS.find(color => color.id === duelOwnerColor) || PLAYER_COLORS[0];
-        const guestColor = PLAYER_COLORS.find(color => color.id === duelGuestColor) || PLAYER_COLORS[1];
-        setState(prev => ({
-          ...(sameDuel ? prev : initial),
-          activePlayerId: multiplayer.slot,
-          habits: visibleHabits,
-          checkIns: visibleCheckIns,
-          stakes: data.stakes,
-          reactions: visibleReactions,
-          restDays: visibleRestDays,
-          players: {
-            maciek: { ...initial.players.maciek, name: duelOwnerName || initial.players.maciek.name, color: ownerColor.color, accentBg: ownerColor.accentBg, accentBorder: ownerColor.accentBorder, inviteCount: multiplayer.duel?.owner_invites ?? 0 },
-            myrna: { ...initial.players.myrna, name: partnerPaired ? (duelGuestName || 'Invited player') : 'Waiting for opponent', color: guestColor.color, accentBg: guestColor.accentBg, accentBorder: guestColor.accentBorder, inviteCount: multiplayer.duel?.guest_invites ?? 0 },
-          },
-        }));
-        setLoadedDuelId(duelId);
-        setSyncStatus('connected');
-        setStorageError(null);
-      } catch (error) {
-        if (!cancelled) {
-          setSyncStatus('offline');
-          setStorageError(error instanceof Error ? error.message : 'Could not load duel data.');
-        }
+      let pendingWrites = duelQueueRef.current;
+      await pendingWrites;
+      if (reloader.isCancelled) return;
+      let data = await loadDuelData(client, duelId);
+      if (reloader.isCancelled) return;
+      // A read started before a local mutation must not replace its optimistic state.
+      if (pendingWrites !== duelQueueRef.current) {
+        reloader.schedule();
+        return;
       }
-    };
-    void reload();
+      const restoreKey = `${duelId}:${multiplayer.slot}`;
+      if (
+        multiplayer.slot &&
+        canImportLegacyDatabase(multiplayer.slot, multiplayer.user?.email) &&
+        needsLegacyReplacement(multiplayer.slot, data.habits) &&
+        !restorationInProgressRef.current[restoreKey]
+      ) {
+        restorationInProgressRef.current[restoreKey] = true;
+        const slot = multiplayer.slot;
+        const restoration = duelQueueRef.current
+          .then(() => restoreLegacyDuelProgress(client, duelId, slot, data.habits, data.checkIns))
+          .finally(() => {
+            delete restorationInProgressRef.current[restoreKey];
+          });
+        duelQueueRef.current = restoration.then(() => {}, () => {});
+        pendingWrites = duelQueueRef.current;
+        if (await restoration) data = await loadDuelData(client, duelId);
+      }
+      if (reloader.isCancelled) return;
+      if (pendingWrites !== duelQueueRef.current) {
+        reloader.schedule();
+        return;
+      }
+      if (sequence < latestAppliedSequenceRef.current) return;
+      latestAppliedSequenceRef.current = sequence;
+      const initial = getInitialState();
+      const sameDuel = stateDuelRef.current === duelId && stateSlotRef.current === multiplayer.slot;
+      stateDuelRef.current = duelId;
+      stateSlotRef.current = multiplayer.slot;
+      const partnerPaired = multiplayer.hasPairedPartner;
+      const visibleHabits = partnerPaired ? data.habits : data.habits.filter(h => h.playerId === multiplayer.slot);
+      const visibleCheckIns = partnerPaired ? data.checkIns : data.checkIns.filter(c => c.playerId === multiplayer.slot);
+      const visibleReactions = partnerPaired ? data.reactions : data.reactions.filter(r => r.fromPlayerId === multiplayer.slot && r.toPlayerId === multiplayer.slot);
+      const visibleRestDays = partnerPaired ? data.restDays : data.restDays.filter(r => r.playerId === multiplayer.slot);
+      const ownerColor = PLAYER_COLORS.find(color => color.id === duelOwnerColor) || PLAYER_COLORS[0];
+      const guestColor = PLAYER_COLORS.find(color => color.id === duelGuestColor) || PLAYER_COLORS[1];
+      setState(prev => ({
+        ...(sameDuel ? prev : initial),
+        activePlayerId: multiplayer.slot,
+        habits: visibleHabits,
+        checkIns: visibleCheckIns,
+        stakes: data.stakes,
+        reactions: visibleReactions,
+        restDays: visibleRestDays,
+        players: {
+          maciek: { ...initial.players.maciek, name: duelOwnerName || initial.players.maciek.name, color: ownerColor.color, accentBg: ownerColor.accentBg, accentBorder: ownerColor.accentBorder, inviteCount: multiplayer.duel?.owner_invites ?? 0 },
+          myrna: { ...initial.players.myrna, name: partnerPaired ? (duelGuestName || 'Invited player') : 'Waiting for opponent', color: guestColor.color, accentBg: guestColor.accentBg, accentBorder: guestColor.accentBorder, inviteCount: multiplayer.duel?.guest_invites ?? 0 },
+        },
+      }));
+      setLoadedDuelId(duelId);
+      setSyncStatus('connected');
+      setStorageError(null);
+    }, {
+      debounceMs: 50,
+      onError: (error) => {
+        setSyncStatus('offline');
+        setStorageError(error instanceof Error ? error.message : 'Could not load duel data.');
+      },
+    });
+
+    reloader.schedule({ immediate: true });
     let isSubscribed = false;
     const channel = client.channel(`duel-${duelId}`)
-      .on('postgres_changes', { event: '*', schema: 'public', table: 'duel_habits', filter: `duel_id=eq.${duelId}` }, () => void reload())
-      .on('postgres_changes', { event: '*', schema: 'public', table: 'duel_check_ins', filter: `duel_id=eq.${duelId}` }, () => void reload())
-      .on('postgres_changes', { event: '*', schema: 'public', table: 'duel_stakes', filter: `duel_id=eq.${duelId}` }, () => void reload())
-      .on('postgres_changes', { event: '*', schema: 'public', table: 'duel_reactions', filter: `duel_id=eq.${duelId}` }, () => void reload())
-      .on('postgres_changes', { event: '*', schema: 'public', table: 'duel_rest_days', filter: `duel_id=eq.${duelId}` }, () => void reload())
+      .on('postgres_changes', { event: '*', schema: 'public', table: 'duel_habits', filter: `duel_id=eq.${duelId}` }, () => reloader.schedule())
+      .on('postgres_changes', { event: '*', schema: 'public', table: 'duel_check_ins', filter: `duel_id=eq.${duelId}` }, () => reloader.schedule())
+      .on('postgres_changes', { event: '*', schema: 'public', table: 'duel_stakes', filter: `duel_id=eq.${duelId}` }, () => reloader.schedule())
+      .on('postgres_changes', { event: '*', schema: 'public', table: 'duel_reactions', filter: `duel_id=eq.${duelId}` }, () => reloader.schedule())
+      .on('postgres_changes', { event: '*', schema: 'public', table: 'duel_rest_days', filter: `duel_id=eq.${duelId}` }, () => reloader.schedule())
       .subscribe((status) => {
         isSubscribed = status === 'SUBSCRIBED';
       });
     const poll = setInterval(() => {
       if (!isSubscribed) {
-        void reload();
+        reloader.schedule({ immediate: true });
       }
     }, 30000);
-    return () => { cancelled = true; clearInterval(poll); void client.removeChannel(channel); };
+    return () => { reloader.cancel(); clearInterval(poll); void client.removeChannel(channel); };
   }, [isHydrated, multiplayer.configured, duelId, multiplayer.slot, multiplayer.hasPairedPartner, multiplayer.user?.email, duelOwnerName, duelGuestName, duelOwnerColor, duelGuestColor]);
 
   const syncDuel = (operation: (client: NonNullable<ReturnType<typeof getSupabaseClient>>, id: string) => Promise<void>) => {
@@ -1269,57 +1282,6 @@ export function StoreProvider({ children }: { children: React.ReactNode }) {
   );
 
 
-  // Automatically pull Apple Health check-ins queued by background iOS Shortcuts
-  useEffect(() => {
-    if (!isHydrated || multiplayer.configured) return;
-
-    const pullAppleHealthPending = async () => {
-      try {
-        const res = await fetch('/api/sync/apple-health?pending=true&consume=true');
-        if (!res.ok) return;
-        const data = await res.json();
-        if (data.pendingCheckIns && Array.isArray(data.pendingCheckIns) && data.pendingCheckIns.length > 0) {
-          setState((prev) => {
-            let nextCheckIns = [...prev.checkIns];
-            for (const incoming of data.pendingCheckIns) {
-              if (!incoming || !incoming.habitId) continue;
-              const idx = nextCheckIns.findIndex(
-                (c) => c.habitId === incoming.habitId && c.date === incoming.date
-              );
-              if (idx >= 0) {
-                nextCheckIns[idx] = incoming;
-              } else {
-                nextCheckIns.push(incoming);
-              }
-            }
-            nextCheckIns = rebalanceAllWeeklyCheckIns(nextCheckIns, prev.habits);
-            return {
-              ...prev,
-              checkIns: nextCheckIns,
-              wearableConfig: {
-                ...prev.wearableConfig,
-                appleConnected: true,
-                appleLastSync: new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }),
-              },
-            };
-          });
-          soundEngine.playFanfare();
-          hapticSuccess();
-        }
-      } catch {
-        // Silent failure in offline/local
-      }
-    };
-
-    pullAppleHealthPending();
-    const handleFocus = () => {
-      pullAppleHealthPending();
-    };
-    window.addEventListener('focus', handleFocus);
-    return () => window.removeEventListener('focus', handleFocus);
-  }, [isHydrated, multiplayer.configured]);
-
-
   const disconnectGoogleHealth = useStableCallback(() => { if (typeof document !== 'undefined') {
     document.cookie = 'g_fit_connected=; Path=/; Expires=Thu, 01 Jan 1970 00:00:01 GMT;';
     document.cookie = 'g_fit_access_token=; Path=/; Expires=Thu, 01 Jan 1970 00:00:01 GMT;';

From f8d783729b2eace15d656892526c339ba3ca451e Mon Sep 17 00:00:00 2001
From: Maseeek <maseeekyt@gmail.com>
Date: Mon, 12 Oct 2026 03:13:04 +0100
Subject: [PATCH 02/10] perf(views): remove deferred-view fallback delays

Load optional views through stable external-store snapshots so ready
chunks render without the measured Suspense fallback delay. Preserve
deployment checks on actual activation, failed-preload retries, and
server rendering without importing inactive views.

Warm tab and Settings imports on pointer entry or keyboard focus. Keep
proof and shortcut dialogs deferred with their existing loaded behavior.

Refs #63.
---
 src/app/page.tsx                  |  20 ++++--
 src/components/BottomNav.tsx      |   5 +-
 src/components/DeferredView.tsx   |  20 ++++++
 src/components/DesktopSidebar.tsx |   8 ++-
 src/components/HabitCard.tsx      |   7 +-
 src/components/Header.tsx         |   4 +-
 src/components/TodayView.tsx      |   7 +-
 src/lib/deferred-resource.test.ts | 103 ++++++++++++++++++++++++++++++
 src/lib/deferred-resource.ts      |  48 ++++++++++++++
 src/lib/load-current-page.test.ts |  77 +++++++++++++++++++++-
 10 files changed, 280 insertions(+), 19 deletions(-)
 create mode 100644 src/components/DeferredView.tsx
 create mode 100644 src/lib/deferred-resource.test.ts
 create mode 100644 src/lib/deferred-resource.ts

diff --git a/src/app/page.tsx b/src/app/page.tsx
index d6d828f..a574015 100644
--- a/src/app/page.tsx
+++ b/src/app/page.tsx
@@ -2,6 +2,7 @@
 
 import React, { Suspense, useCallback, useEffect, useRef, useState } from 'react';
 import dynamic from 'next/dynamic';
+import { createDeferredView } from '@/components/DeferredView';
 import { loadCurrentPage } from '@/lib/load-current-page';
 import { useSearchParams } from 'next/navigation';
 import { useStore } from '@/lib/store';
@@ -25,13 +26,18 @@ function ViewLoading() {
   return <p role="status" className="py-8 text-center text-sm text-zinc-500">Loading...</p>;
 }
 
-const DuelView = dynamic(() => loadCurrentPage(() => import('@/components/DuelView')).then(module => module.DuelView), { loading: ViewLoading });
-const ProgressView = dynamic(() => loadCurrentPage(() => import('@/components/ProgressView')).then(module => module.ProgressView), { loading: ViewLoading });
-const SettingsView = dynamic(() => loadCurrentPage(() => import('@/components/SettingsView')).then(module => module.SettingsView), { loading: ViewLoading });
+const { View: DuelView, preload: preloadDuel } = createDeferredView(() => import('@/components/DuelView').then(module => module.DuelView));
+const { View: ProgressView, preload: preloadProgress } = createDeferredView(() => import('@/components/ProgressView').then(module => module.ProgressView));
+const { View: SettingsView, preload: preloadSettings } = createDeferredView(() => import('@/components/SettingsView').then(module => module.SettingsView));
+
+function preloadTab(tab: TabType) {
+  if (tab === 'duel') preloadDuel();
+  if (tab === 'progress') preloadProgress();
+}
 const MultiplayerGate = dynamic(() => loadCurrentPage(() => import('@/components/MultiplayerGate')).then(module => module.MultiplayerGate), { loading: ViewLoading });
 const ExistingDuelInviteGate = dynamic(() => loadCurrentPage(() => import('@/components/ExistingDuelInviteGate')).then(module => module.ExistingDuelInviteGate), { loading: ViewLoading });
 const HabitOnboarding = dynamic(() => loadCurrentPage(() => import('@/components/HabitOnboarding')).then(module => module.HabitOnboarding), { loading: ViewLoading });
-const KeyboardShortcutsModal = dynamic(() => loadCurrentPage(() => import('@/components/KeyboardShortcutsModal')).then(module => module.KeyboardShortcutsModal), { loading: ViewLoading });
+const { View: KeyboardShortcutsModal } = createDeferredView(() => import('@/components/KeyboardShortcutsModal').then(module => module.KeyboardShortcutsModal), null);
 
 function AppContent() {
   const {
@@ -245,8 +251,8 @@ function AppContent() {
       {/* App frame */}
       <div className="relative z-10 flex flex-col flex-1 lg:pl-60">
         <a href="#main-content" className="skip-link">Skip to content</a>
-        <DesktopSidebar activeTab={activeTab} onChangeTab={(tab) => { setShowSettings(false); changeTab(tab); }} />
-        <Header onOpenSettings={() => setShowSettings(true)} />
+        <DesktopSidebar activeTab={activeTab} onWarmTab={preloadTab} onChangeTab={(tab) => { setShowSettings(false); changeTab(tab); }} />
+        <Header onOpenSettings={() => setShowSettings(true)} onWarmSettings={preloadSettings} />
         {/* Floating Quick Action Toast */}
         {toastMessage && (
           <div
@@ -283,7 +289,7 @@ function AppContent() {
           </>}
         </main>
 
-        <BottomNav activeTab={activeTab} onChangeTab={(tab) => { setShowSettings(false); setOpenPlanner(false); changeTab(tab); }} />
+        <BottomNav activeTab={activeTab} onWarmTab={preloadTab} onChangeTab={(tab) => { setShowSettings(false); setOpenPlanner(false); changeTab(tab); }} />
 
         {isShortcutsModalOpen && <KeyboardShortcutsModal
           isOpen={isShortcutsModalOpen}
diff --git a/src/components/BottomNav.tsx b/src/components/BottomNav.tsx
index 43647b6..9f81910 100644
--- a/src/components/BottomNav.tsx
+++ b/src/components/BottomNav.tsx
@@ -11,9 +11,10 @@ export type TabType = 'today' | 'duel' | 'progress';
 interface BottomNavProps {
   activeTab: TabType;
   onChangeTab: (tab: TabType) => void;
+  onWarmTab?: (tab: TabType) => void;
 }
 
-export function BottomNav({ activeTab, onChangeTab }: BottomNavProps) {
+export function BottomNav({ activeTab, onChangeTab, onWarmTab }: BottomNavProps) {
   const tabs = [
     { id: 'today' as TabType, label: 'Today', icon: CheckCircle2 },
     { id: 'duel' as TabType, label: 'Duel', icon: Flame },
@@ -42,6 +43,8 @@ export function BottomNav({ activeTab, onChangeTab }: BottomNavProps) {
             <button
               key={tab.id}
               onClick={() => handleTabClick(tab.id)}
+              onPointerEnter={() => onWarmTab?.(tab.id)}
+              onFocus={() => onWarmTab?.(tab.id)}
               aria-label={tab.label}
               aria-current={isActive ? 'page' : undefined}
               className={`flex min-h-11 min-w-16 flex-col items-center justify-center gap-1 py-1 px-3 rounded-lg transition-all active:scale-95 ${
diff --git a/src/components/DeferredView.tsx b/src/components/DeferredView.tsx
new file mode 100644
index 0000000..1de12d4
--- /dev/null
+++ b/src/components/DeferredView.tsx
@@ -0,0 +1,20 @@
+'use client';
+
+import { createElement, useSyncExternalStore, type ComponentType, type ReactNode } from 'react';
+import { createDeferredResource } from '@/lib/deferred-resource';
+
+export function createDeferredView<Props extends object>(
+  importView: () => Promise<ComponentType<Props>>,
+  fallback: ReactNode = <p role="status" className="py-8 text-center text-sm text-zinc-500">Loading...</p>,
+) {
+  const resource = createDeferredResource(importView);
+
+  function View(props: Props) {
+    const snapshot = useSyncExternalStore(resource.subscribe, resource.getSnapshot, resource.getServerSnapshot);
+    if (snapshot.status === 'error') throw snapshot.error;
+    if (snapshot.status === 'ready') return createElement(snapshot.value, props);
+    return fallback;
+  }
+
+  return { View, preload: resource.preload };
+}
diff --git a/src/components/DesktopSidebar.tsx b/src/components/DesktopSidebar.tsx
index cb702ae..9dec6cf 100644
--- a/src/components/DesktopSidebar.tsx
+++ b/src/components/DesktopSidebar.tsx
@@ -4,7 +4,11 @@ import { CheckCircle2, Flame, ChartNoAxesColumn } from 'lucide-react';
 import { TabType } from './BottomNav';
 import { useStore } from '@/lib/store';
 
-export function DesktopSidebar({ activeTab, onChangeTab }: { activeTab: TabType; onChangeTab: (tab: TabType) => void }) {
+export function DesktopSidebar({ activeTab, onChangeTab, onWarmTab }: {
+  activeTab: TabType;
+  onChangeTab: (tab: TabType) => void;
+  onWarmTab?: (tab: TabType) => void;
+}) {
   const { activePlayer, activePlayerSummary } = useStore();
   const tabs = [
     { id: 'today' as const, label: 'Today', icon: CheckCircle2, shortcut: '1' },
@@ -20,6 +24,8 @@ export function DesktopSidebar({ activeTab, onChangeTab }: { activeTab: TabType;
           <button
             key={id}
             onClick={() => onChangeTab(id)}
+            onPointerEnter={() => onWarmTab?.(id)}
+            onFocus={() => onWarmTab?.(id)}
             aria-current={activeTab === id ? 'page' : undefined}
             className={`w-full min-h-10 flex items-center justify-between gap-3 px-3 py-2 rounded-lg text-left transition-colors border ${
               activeTab === id
diff --git a/src/components/HabitCard.tsx b/src/components/HabitCard.tsx
index 3ee2f00..2f8a5b4 100644
--- a/src/components/HabitCard.tsx
+++ b/src/components/HabitCard.tsx
@@ -5,8 +5,7 @@ import { CheckIn, Habit, HealthTelemetryRecord, Player } from '@/lib/types';
 import { getHealthProgressDetails } from '@/lib/health-correlation';
 import { calculateHealthPoints } from '@/lib/health-rewards';
 import { HabitIcon } from './HabitIcon';
-import dynamic from 'next/dynamic';
-import { loadCurrentPage } from '@/lib/load-current-page';
+import { createDeferredView } from './DeferredView';
 
 
 import {
@@ -25,8 +24,8 @@ import {
 import { soundEngine } from '@/lib/sound-utils';
 import { hapticLight, hapticSuccess } from '@/lib/haptic-utils';
 
-const ProofModal = dynamic(() => loadCurrentPage(() => import('./ProofModal')).then(module => module.ProofModal));
-const ProofGalleryModal = dynamic(() => loadCurrentPage(() => import('./ProofGalleryModal')).then(module => module.ProofGalleryModal));
+const { View: ProofModal } = createDeferredView(() => import('./ProofModal').then(module => module.ProofModal), null);
+const { View: ProofGalleryModal } = createDeferredView(() => import('./ProofGalleryModal').then(module => module.ProofGalleryModal), null);
 
 interface HabitCardProps {
   habit: Habit;
diff --git a/src/components/Header.tsx b/src/components/Header.tsx
index 31c1b2d..4ada9e3 100644
--- a/src/components/Header.tsx
+++ b/src/components/Header.tsx
@@ -7,7 +7,7 @@ import { soundEngine } from '@/lib/sound-utils';
 import { hapticLight } from '@/lib/haptic-utils';
 import { getPlayerColorStyles } from '@/lib/player-colors';
 
-export function Header({ onOpenSettings }: { onOpenSettings: () => void }) {
+export function Header({ onOpenSettings, onWarmSettings }: { onOpenSettings: () => void; onWarmSettings?: () => void }) {
   const { activePlayer, activePlayerSummary, themePreference, effectiveTheme, toggleTheme } = useStore();
 
   const handleProfileClick = () => {
@@ -58,6 +58,8 @@ export function Header({ onOpenSettings }: { onOpenSettings: () => void }) {
           <button
             type="button"
             onClick={handleProfileClick}
+            onPointerEnter={onWarmSettings}
+            onFocus={onWarmSettings}
             aria-label="Open profile and settings"
             title="Profile and settings"
             className="flex size-11 items-center justify-center rounded-lg border font-mono text-xs font-bold transition-colors hover:brightness-110 active:scale-95"
diff --git a/src/components/TodayView.tsx b/src/components/TodayView.tsx
index fac25a3..a816fbc 100644
--- a/src/components/TodayView.tsx
+++ b/src/components/TodayView.tsx
@@ -19,14 +19,13 @@ import { hapticCelebration, hapticLight } from '@/lib/haptic-utils';
 import { fireCelebrationConfetti } from '@/lib/confetti';
 import { HabitCard } from './HabitCard';
 import { DateNavigator } from './DateNavigator';
-import dynamic from 'next/dynamic';
-import { loadCurrentPage } from '@/lib/load-current-page';
+import { createDeferredView } from './DeferredView';
 
 import { Habit } from '@/lib/types';
 import { calculateHabitStreak } from '@/lib/score-calculator';
 
-const ActivityFeed = dynamic(() => loadCurrentPage(() => import('./ActivityFeed')).then(module => module.ActivityFeed));
-const ProofGalleryModal = dynamic(() => loadCurrentPage(() => import('./ProofGalleryModal')).then(module => module.ProofGalleryModal));
+const { View: ActivityFeed } = createDeferredView(() => import('./ActivityFeed').then(module => module.ActivityFeed));
+const { View: ProofGalleryModal } = createDeferredView(() => import('./ProofGalleryModal').then(module => module.ProofGalleryModal), null);
 
 export function TodayView({ onOpenHabits, onOpenDuel }: { onOpenHabits: () => void; onOpenDuel?: () => void }) {
   const multiplayer = useMultiplayer();
diff --git a/src/lib/deferred-resource.test.ts b/src/lib/deferred-resource.test.ts
new file mode 100644
index 0000000..c247a78
--- /dev/null
+++ b/src/lib/deferred-resource.test.ts
@@ -0,0 +1,103 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createDeferredResource } from './deferred-resource';
+
+const settle = () => new Promise<void>(resolve => setImmediate(resolve));
+
+test('reading or rendering the server snapshot never imports or activates a deferred view', () => {
+  let imports = 0;
+  let activations = 0;
+  const resource = createDeferredResource(async () => { imports++; return 'view'; }, async load => {
+    activations++;
+    return load();
+  });
+  const initial = resource.getSnapshot();
+  assert.equal(resource.getSnapshot(), initial);
+  assert.equal(resource.getServerSnapshot(), initial);
+  assert.equal(imports, 0);
+  assert.equal(activations, 0);
+});
+
+test('intent preload shares one import but actual activation still runs the deployment guard', async () => {
+  let imports = 0;
+  let activations = 0;
+  let notifications = 0;
+  const resource = createDeferredResource(async () => { imports++; return 'view'; }, async load => {
+    activations++;
+    return load();
+  });
+  resource.preload();
+  resource.preload();
+  await settle();
+  assert.equal(imports, 1);
+  assert.equal(activations, 0);
+  assert.equal(resource.getSnapshot().status, 'pending');
+  const offA = resource.subscribe(() => { notifications++; });
+  const offB = resource.subscribe(() => { notifications++; });
+  await settle();
+  assert.equal(imports, 1);
+  assert.equal(activations, 1);
+  assert.equal(notifications, 2);
+  assert.deepEqual(resource.getSnapshot(), { status: 'ready', value: 'view' });
+  offA(); offB();
+  resource.subscribe(() => { notifications++; })();
+  await settle();
+  assert.equal(activations, 1);
+  assert.equal(notifications, 2);
+  assert.equal(resource.getServerSnapshot().status, 'pending');
+});
+
+test('a pending deployment check prevents importing or publishing a view on actual activation', async () => {
+  let release: (() => void) | undefined;
+  const gate = new Promise<void>(resolve => { release = resolve; });
+  let imports = 0;
+  const resource = createDeferredResource(async () => { imports++; return 'view'; }, async load => {
+    await gate;
+    return load();
+  });
+  const off = resource.subscribe(() => {});
+  await settle();
+  assert.equal(imports, 0);
+  assert.equal(resource.getSnapshot().status, 'pending');
+  assert.ok(release);
+  release();
+  await settle();
+  assert.equal(imports, 1);
+  assert.equal(resource.getSnapshot().status, 'ready');
+  off();
+});
+
+test('a failed intent preload remains silent and retries when the Player opens the view', async () => {
+  let attempts = 0;
+  const resource = createDeferredResource(async () => {
+    attempts++;
+    if (attempts === 1) throw new Error('Temporary connection failure');
+    return 'view';
+  });
+  resource.preload();
+  await settle();
+  assert.equal(attempts, 1);
+  assert.equal(resource.getSnapshot().status, 'pending');
+  const off = resource.subscribe(() => {});
+  await settle();
+  assert.equal(attempts, 2);
+  assert.deepEqual(resource.getSnapshot(), { status: 'ready', value: 'view' });
+  off();
+});
+
+test('actual activation errors reach the snapshot and unsubscribed views receive no late updates', async () => {
+  const error = new Error('View unavailable');
+  let reject: ((error: Error) => void) | undefined;
+  const pending = new Promise<string>((_, fail) => { reject = fail; });
+  let notifications = 0;
+  const resource = createDeferredResource(() => pending);
+  const off = resource.subscribe(() => { notifications++; });
+  await settle();
+  off();
+  assert.ok(reject);
+  reject(error);
+  await settle();
+  assert.equal(notifications, 0);
+  assert.deepEqual(resource.getSnapshot(), { status: 'error', error });
+  assert.equal(resource.getServerSnapshot().status, 'pending');
+});
diff --git a/src/lib/deferred-resource.ts b/src/lib/deferred-resource.ts
new file mode 100644
index 0000000..4dcc1ae
--- /dev/null
+++ b/src/lib/deferred-resource.ts
@@ -0,0 +1,48 @@
+import { loadCurrentPage } from './load-current-page';
+
+export type DeferredSnapshot<T> =
+  | { readonly status: 'pending' }
+  | { readonly status: 'ready'; readonly value: T }
+  | { readonly status: 'error'; readonly error: unknown };
+
+export function createDeferredResource<T>(
+  importModule: () => Promise<T>,
+  activate: (load: () => Promise<T>) => Promise<T> = loadCurrentPage,
+) {
+  const initial: DeferredSnapshot<T> = { status: 'pending' };
+  let snapshot: DeferredSnapshot<T> = initial;
+  let imported: Promise<T> | undefined;
+  let activation: Promise<void> | undefined;
+  const listeners = new Set<() => void>();
+
+  function importOnce(): Promise<T> {
+    if (!imported) {
+      imported = Promise.resolve().then(importModule).catch(error => {
+        imported = undefined;
+        throw error;
+      });
+    }
+    return imported;
+  }
+
+  function publish(next: DeferredSnapshot<T>) {
+    snapshot = next;
+    for (const listener of listeners) listener();
+  }
+
+  return {
+    getSnapshot: () => snapshot,
+    getServerSnapshot: () => initial,
+    preload: () => { void importOnce().catch(() => {}); },
+    subscribe(listener: () => void) {
+      listeners.add(listener);
+      if (!activation) {
+        activation = activate(importOnce).then(
+          value => publish({ status: 'ready', value }),
+          error => publish({ status: 'error', error }),
+        );
+      }
+      return () => { listeners.delete(listener); };
+    },
+  };
+}
diff --git a/src/lib/load-current-page.test.ts b/src/lib/load-current-page.test.ts
index 4170c5c..8e393e0 100644
--- a/src/lib/load-current-page.test.ts
+++ b/src/lib/load-current-page.test.ts
@@ -1,6 +1,7 @@
 import assert from 'node:assert/strict';
-import { test } from 'node:test';
+import { test, type TestContext } from 'node:test';
 import { hasAppVersionChanged } from './load-current-page';
+import { createDeferredResource } from './deferred-resource';
 
 test('detects a new deployment before requesting its old lazy chunks', () => {
   assert.equal(hasAppVersionChanged('deployment-a', { version: 'deployment-b' }), true);
@@ -14,3 +15,77 @@ test('missing or invalid version responses cannot force an update reload', () =>
   assert.equal(hasAppVersionChanged('', { version: 'deployment-b' }), false);
   assert.equal(hasAppVersionChanged(undefined, { version: 'deployment-b' }), false);
 });
+
+const settle = () => new Promise<void>(resolve => setImmediate(resolve));
+
+function browser(t: TestContext, fetchVersion: typeof fetch, onLine = true) {
+  const originals = new Map(['window', 'navigator', 'fetch'].map(name =>
+    [name, Object.getOwnPropertyDescriptor(globalThis, name)]));
+  const previousVersion = process.env.NEXT_PUBLIC_APP_VERSION;
+  const storage = new Map<string, string>();
+  const navigations: string[] = [];
+  const values = {
+    window: {
+      sessionStorage: { getItem: (key: string) => storage.get(key) ?? null,
+        setItem: (key: string, value: string) => { storage.set(key, value); } },
+      location: { href: 'https://app.example.test/?action=checkin&habit=reading&invite=code',
+        replace: (url: string) => { navigations.push(url); } },
+    },
+    navigator: { onLine },
+    fetch: fetchVersion,
+  };
+  for (const [name, value] of Object.entries(values)) {
+    Object.defineProperty(globalThis, name, { configurable: true, writable: true, value });
+  }
+  process.env.NEXT_PUBLIC_APP_VERSION = 'deployment-old';
+  t.after(() => {
+    for (const [name, descriptor] of originals) {
+      if (descriptor) Object.defineProperty(globalThis, name, descriptor);
+      else Reflect.deleteProperty(globalThis, name);
+    }
+    if (previousVersion === undefined) delete process.env.NEXT_PUBLIC_APP_VERSION;
+    else process.env.NEXT_PUBLIC_APP_VERSION = previousVersion;
+  });
+  return { storage, navigations };
+}
+
+test('deferred views honor actual deployment recovery before importing and cannot loop reloads', async t => {
+  const context = browser(t, async () => new Response(JSON.stringify({ version: 'deployment-new' })));
+  let imports = 0;
+  const resource = createDeferredResource(async () => { imports++; return 'old view'; });
+  const off = resource.subscribe(() => {});
+  await settle();
+  assert.equal(imports, 0);
+  assert.equal(resource.getSnapshot().status, 'pending');
+  assert.deepEqual(context.navigations, ['/?tab=today&invite=code']);
+  off();
+  const second = createDeferredResource(async () => { imports++; return 'old view'; });
+  const offSecond = second.subscribe(() => {});
+  await settle();
+  const snapshot = second.getSnapshot();
+  assert.equal(snapshot.status, 'error');
+  assert.equal(imports, 0);
+  assert.equal(context.navigations.length, 1);
+  offSecond();
+});
+
+test('deferred views stay usable when the deployment endpoint is unavailable', async t => {
+  const context = browser(t, async () => { throw new TypeError('Network unavailable'); });
+  const resource = createDeferredResource(async () => 'cached view');
+  const off = resource.subscribe(() => {});
+  await settle();
+  assert.deepEqual(resource.getSnapshot(), { status: 'ready', value: 'cached view' });
+  assert.deepEqual(context.navigations, []);
+  off();
+});
+
+test('offline deferred views do not issue a deployment request', async t => {
+  let requests = 0;
+  browser(t, async () => { requests++; return new Response('{}'); }, false);
+  const resource = createDeferredResource(async () => 'offline view');
+  const off = resource.subscribe(() => {});
+  await settle();
+  assert.equal(requests, 0);
+  assert.deepEqual(resource.getSnapshot(), { status: 'ready', value: 'offline view' });
+  off();
+});

From 0b5db4ba284c674e43e398b6ad131f1a74b1fa8a Mon Sep 17 00:00:00 2001
From: Maseeek <maseeekyt@gmail.com>
Date: Mon, 12 Oct 2026 03:27:50 +0100
Subject: [PATCH 03/10] fix(sync): retain capped history when counts are
 unavailable

Treat nonfinite totals as unknown and keep reading until an empty page
when no usable count exists. A short response can reflect the server's
page cap, so it cannot prove that history is complete.

Exercise the actual Supabase HTTP client in pagination tests, including
wildcard totals, missing count headers, lower page caps, and page errors.
The HTTP-only fixture rejects accidental realtime connections.

Refs #63.
---
 src/lib/duel-sync.test.ts | 229 ++++++++++++++++++++------------------
 src/lib/duel-sync.ts      |   4 +-
 2 files changed, 123 insertions(+), 110 deletions(-)

diff --git a/src/lib/duel-sync.test.ts b/src/lib/duel-sync.test.ts
index 796c872..a8af178 100644
--- a/src/lib/duel-sync.test.ts
+++ b/src/lib/duel-sync.test.ts
@@ -1,131 +1,144 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
+import { createClient } from '@supabase/supabase-js';
 import { fetchDuelRows } from './duel-sync';
-import type { SupabaseClient } from '@supabase/supabase-js';
 
-describe('Duel Rows Pagination and Count Elimination Safety', () => {
-  interface MockRow {
-    id: string;
-    duel_id: string;
-    data: { id: string; name: string };
+// Pagination uses the real HTTP client and must never open a realtime socket.
+class HttpOnlyTransport extends EventTarget {
+  readonly CONNECTING = 0;
+  readonly OPEN = 1;
+  readonly CLOSING = 2;
+  readonly CLOSED = 3;
+  readonly readyState = 3;
+  readonly url = '';
+  readonly protocol = '';
+  onopen: WebSocket['onopen'] = null;
+  onmessage: WebSocket['onmessage'] = null;
+  onclose: WebSocket['onclose'] = null;
+  onerror: WebSocket['onerror'] = null;
+  constructor() {
+    super();
+    throw new Error('Pagination must not open a realtime socket');
   }
+  close() { throw new Error('Pagination must not use a realtime socket'); }
+  send() { throw new Error('Pagination must not use a realtime socket'); }
+}
 
-  function createMockSupabaseClient(options: {
+describe('Duel history pagination', () => {
+  function createClientFixture(options: {
     totalRows: number;
-    backendPageCap?: number;
-    onQuery?: (params: { offset: number; pageSize: number; selectCountOption?: { count?: string } }) => void;
-  }): { client: SupabaseClient; getQueries: () => Array<{ offset: number; selectCountOption?: { count?: string } }> } {
-    const allData: MockRow[] = Array.from({ length: options.totalRows }, (_, i) => ({
-      id: `row-${String(i).padStart(6, '0')}`,
-      duel_id: 'duel-test',
-      data: { id: `item-${i}`, name: `Item ${i}` },
+    pageCap?: number;
+    omitCount?: boolean;
+    omitCountHeader?: boolean;
+    failAtOffset?: number;
+  }) {
+    const data = Array.from({ length: options.totalRows }, (_, index) => ({
+      id: 'row-' + String(index).padStart(6, '0'),
+      data: { id: 'item-' + index, name: 'Item ' + index },
     }));
-
-    const queries: Array<{ offset: number; selectCountOption?: { count?: string } }> = [];
-
-    const mockClient = {
-      from(table: string) {
-        assert.ok(table === 'duel_habits' || table === 'duel_check_ins');
-        return {
-          select(columns: string, selectOptions?: { count?: 'exact' }) {
-            assert.equal(columns, 'data');
-            return {
-              eq(column: string, value: string) {
-                assert.equal(column, 'duel_id');
-                assert.equal(value, 'duel-test');
-                return {
-                  order(orderColumn: string) {
-                    assert.equal(orderColumn, 'id');
-                    return {
-                      range(start: number, end: number) {
-                        queries.push({ offset: start, selectCountOption: selectOptions });
-                        options.onQuery?.({ offset: start, pageSize: end - start + 1, selectCountOption: selectOptions });
-
-                        // Apply server-side max-rows cap if specified
-                        const requestedCount = end - start + 1;
-                        const effectiveLimit = options.backendPageCap
-                          ? Math.min(requestedCount, options.backendPageCap)
-                          : requestedCount;
-
-                        const pageRows = allData.slice(start, start + effectiveLimit);
-                        return Promise.resolve({
-                          data: pageRows,
-                          count: selectOptions?.count === 'exact' ? allData.length : null,
-                          error: null,
-                        });
-                      },
-                    };
-                  },
-                };
-              },
-            };
-          },
-        };
+    const queries: { offset: number; exactCount: boolean }[] = [];
+    const client = createClient('http://localhost:54321', 'mock-publishable-key', {
+      auth: { persistSession: false, autoRefreshToken: false, detectSessionInUrl: false },
+      realtime: { transport: HttpOnlyTransport },
+      global: {
+        fetch: async (input, init) => {
+          const url = new URL(typeof input === 'string' ? input : input instanceof URL ? input.href : input.url);
+          assert.ok(['/rest/v1/duel_habits', '/rest/v1/duel_check_ins'].includes(url.pathname));
+          assert.equal(init?.method, 'GET');
+          assert.equal(url.searchParams.get('select'), 'data');
+          assert.equal(url.searchParams.get('duel_id'), 'eq.duel-test');
+          assert.equal(url.searchParams.get('order'), 'id.asc');
+          const offset = Number(url.searchParams.get('offset') ?? 0);
+          const limit = Number(url.searchParams.get('limit'));
+          assert.equal(limit, 1000);
+          const exactCount = new Headers(init?.headers).get('prefer')?.includes('count=exact') ?? false;
+          queries.push({ offset, exactCount });
+          if (offset === options.failAtOffset) {
+            return new Response(JSON.stringify({ message: 'Database unavailable', code: 'MOCK_FAILURE' }), { status: 400 });
+          }
+          const page = data.slice(offset, offset + Math.min(limit, options.pageCap ?? limit));
+          const total = exactCount && !options.omitCount ? String(data.length) : '*';
+          const range = page.length ? offset + '-' + (offset + page.length - 1) : '*';
+          const headers = new Headers({ 'content-type': 'application/json' });
+          if (!options.omitCountHeader) headers.set('content-range', range + '/' + total);
+          return new Response(JSON.stringify(page), {
+            headers,
+          });
+        },
       },
-    } as unknown as SupabaseClient;
-
-    return { client: mockClient, getQueries: () => queries };
+    });
+    return { client, queries };
   }
 
-  it('pagination returns complete history for 0 rows', async () => {
-    const { client, getQueries } = createMockSupabaseClient({ totalRows: 0 });
-    const rows = await fetchDuelRows<{ id: string; name: string }>(client, 'duel_habits', 'duel-test');
-
-    assert.deepStrictEqual(rows, []);
-    assert.strictEqual(getQueries().length, 1);
-    assert.strictEqual(getQueries()[0].selectCountOption?.count, 'exact');
+  it('loads an empty history with one exact-count request', async () => {
+    const { client, queries } = createClientFixture({ totalRows: 0 });
+    assert.deepEqual(await fetchDuelRows(client, 'duel_habits', 'duel-test'), []);
+    assert.deepEqual(queries, [{ offset: 0, exactCount: true }]);
   });
 
-  it('pagination returns complete history for exactly 1000 rows in single query with count', async () => {
-    const { client, getQueries } = createMockSupabaseClient({ totalRows: 1000 });
-    const rows = await fetchDuelRows<{ id: string; name: string }>(client, 'duel_habits', 'duel-test');
+  it('stops at the known count for exactly one full page', async () => {
+    const { client, queries } = createClientFixture({ totalRows: 1000 });
+    const rows = await fetchDuelRows<{ id: string }>(client, 'duel_habits', 'duel-test');
+    assert.equal(rows.length, 1000);
+    assert.equal(rows[0].id, 'item-0');
+    assert.equal(rows[999].id, 'item-999');
+    assert.deepEqual(queries, [{ offset: 0, exactCount: true }]);
+  });
 
-    assert.strictEqual(rows.length, 1000);
-    assert.strictEqual(rows[0].id, 'item-0');
-    assert.strictEqual(rows[999].id, 'item-999');
-    assert.strictEqual(getQueries().length, 1, 'Should complete in 1 page when count matches total rows');
-    assert.strictEqual(getQueries()[0].selectCountOption?.count, 'exact');
+  it('loads all pages while requesting the exact count only once', async () => {
+    const { client, queries } = createClientFixture({ totalRows: 2500 });
+    const rows = await fetchDuelRows<{ id: string }>(client, 'duel_check_ins', 'duel-test');
+    assert.equal(rows.length, 2500);
+    assert.equal(rows[0].id, 'item-0');
+    assert.equal(rows[2499].id, 'item-2499');
+    assert.deepEqual(queries, [
+      { offset: 0, exactCount: true },
+      { offset: 1000, exactCount: false },
+      { offset: 2000, exactCount: false },
+    ]);
   });
 
-  it('pagination returns complete history for >1000 rows without repeated count queries', async () => {
-    const total = 2500;
-    const { client, getQueries } = createMockSupabaseClient({ totalRows: total });
-    const rows = await fetchDuelRows<{ id: string; name: string }>(client, 'duel_check_ins', 'duel-test');
+  it('retains full history when the backend caps each page below the requested limit', async () => {
+    const { client, queries } = createClientFixture({ totalRows: 1250, pageCap: 400 });
+    const rows = await fetchDuelRows<{ id: string }>(client, 'duel_check_ins', 'duel-test');
+    assert.equal(rows.length, 1250);
+    assert.equal(rows[0].id, 'item-0');
+    assert.equal(rows[1249].id, 'item-1249');
+    assert.deepEqual(queries, [
+      { offset: 0, exactCount: true },
+      { offset: 400, exactCount: false },
+      { offset: 800, exactCount: false },
+      { offset: 1200, exactCount: false },
+    ]);
+  });
 
-    assert.strictEqual(rows.length, 2500);
-    assert.strictEqual(rows[0].id, 'item-0');
-    assert.strictEqual(rows[2499].id, 'item-2499');
+  it('treats a nonnumeric total as unavailable and reads through the empty page', async () => {
+    const { client, queries } = createClientFixture({ totalRows: 2500, omitCount: true });
+    const rows = await fetchDuelRows<{ id: string }>(client, 'duel_check_ins', 'duel-test');
+    assert.equal(rows.length, 2500);
+    assert.deepEqual(queries, [
+      { offset: 0, exactCount: true },
+      { offset: 1000, exactCount: true },
+      { offset: 2000, exactCount: true },
+      { offset: 2500, exactCount: true },
+    ]);
+  });
 
-    const queries = getQueries();
-    assert.strictEqual(queries.length, 3, '2500 rows should take 3 pages (1000, 1000, 500)');
-    // First query requests count exact
-    assert.strictEqual(queries[0].selectCountOption?.count, 'exact', 'First query requests count exact');
-    // Subsequent queries must NOT request count exact (safely eliminated!)
-    assert.strictEqual(queries[1].selectCountOption?.count, undefined, 'Second query eliminates count exact');
-    assert.strictEqual(queries[2].selectCountOption?.count, undefined, 'Third query eliminates count exact');
+  it('retains capped history when count headers are missing', async () => {
+    const { client, queries } = createClientFixture({ totalRows: 1250, pageCap: 400, omitCountHeader: true });
+    const rows = await fetchDuelRows<{ id: string }>(client, 'duel_check_ins', 'duel-test');
+    assert.equal(rows.length, 1250);
+    assert.equal(new Set(rows.map(row => row.id)).size, 1250);
+    assert.equal(rows[1249].id, 'item-1249');
+    assert.deepEqual(queries.map(query => query.offset), [0, 400, 800, 1200, 1250]);
+    assert.ok(queries.every(query => query.exactCount));
   });
 
-  it('pagination handles PostgREST backend capping page below 1000 without dropping records', async () => {
-    // PostgREST max-rows configured to 400, but table has 1250 rows
-    const total = 1250;
-    const { client, getQueries } = createMockSupabaseClient({
-      totalRows: total,
-      backendPageCap: 400,
+  it('propagates a later page failure instead of returning partial history', async () => {
+    const { client, queries } = createClientFixture({ totalRows: 2500, failAtOffset: 1000 });
+    await assert.rejects(fetchDuelRows(client, 'duel_check_ins', 'duel-test'), {
+      message: 'Database unavailable', code: 'MOCK_FAILURE',
     });
-
-    const rows = await fetchDuelRows<{ id: string; name: string }>(client, 'duel_check_ins', 'duel-test');
-
-    // Must return all 1250 rows without dropping any records!
-    assert.strictEqual(rows.length, 1250, 'All 1250 records must be present');
-    assert.strictEqual(rows[0].id, 'item-0');
-    assert.strictEqual(rows[1249].id, 'item-1249');
-
-    const queries = getQueries();
-    // 400 + 400 + 400 + 50 = 1250 (4 queries)
-    assert.strictEqual(queries.length, 4);
-    assert.strictEqual(queries[0].selectCountOption?.count, 'exact', 'Count requested on page 0');
-    assert.strictEqual(queries[1].selectCountOption?.count, undefined, 'Subsequent pages omit count');
-    assert.strictEqual(queries[2].selectCountOption?.count, undefined);
-    assert.strictEqual(queries[3].selectCountOption?.count, undefined);
+    assert.equal(queries.length, 2);
   });
 });
diff --git a/src/lib/duel-sync.ts b/src/lib/duel-sync.ts
index d28ec76..d36bd07 100644
--- a/src/lib/duel-sync.ts
+++ b/src/lib/duel-sync.ts
@@ -14,11 +14,11 @@ export async function fetchDuelRows<T>(client: SupabaseClient, table: string, du
       .order('id')
       .range(offset, offset + pageSize - 1);
     if (error) throw error;
-    if (totalCount === null && typeof count === 'number') {
+    if (totalCount === null && typeof count === 'number' && Number.isFinite(count) && count >= 0) {
       totalCount = count;
     }
     rows.push(...(data || []).map(row => row.data as T));
-    if (!data?.length || (totalCount !== null && rows.length >= totalCount) || (totalCount === null && data.length < pageSize)) return rows;
+    if (!data?.length || (totalCount !== null && rows.length >= totalCount)) return rows;
     offset += data.length;
   }
 }

From 3862085bda1de08c53b01e48d5cd713545be8d74 Mon Sep 17 00:00:00 2001
From: Maseeek <maseeekyt@gmail.com>
Date: Mon, 12 Oct 2026 03:27:50 +0100
Subject: [PATCH 04/10] perf(history): reuse indexes and avoid repeated view
 calculations

Reuse the existing first-record Habit/date and unique weekly-date indexes
for Today streaks and Check-in lookups. Memoize exact selected-day totals
and compute badges only in their consumer instead of every store update.

Aggregate weekly Duel points and badge progress in one history pass.
Parse Activity timestamps once before sorting and skip search strings
for an empty query while preserving full history, ties, and duplicates.

Add regression coverage for rest-day bridging, daily and weekly caps,
backdated search, and duplicate records, and extend calculation benchmarks.

Refs #63.
---
 scripts/benchmark-performance.ts              |  12 +-
 src/components/ActivityFeed.tsx               |  97 +++---------
 src/components/TodayView.tsx                  |  15 +-
 src/components/TrophyCabinet.tsx              |  11 +-
 src/lib/activity-timeline-regressions.test.ts |  57 +++++++
 src/lib/activity-timeline.ts                  | 149 ++++++++++++++++++
 src/lib/badge-utils.ts                        | 142 ++++++++++-------
 src/lib/calculation-regressions.test.ts       |  97 ++++++++++++
 src/lib/check-in-index.ts                     |   2 +
 src/lib/score-calculator.ts                   |  96 +++++++----
 src/lib/store.tsx                             |  35 ++--
 11 files changed, 510 insertions(+), 203 deletions(-)
 create mode 100644 src/lib/activity-timeline-regressions.test.ts
 create mode 100644 src/lib/activity-timeline.ts
 create mode 100644 src/lib/calculation-regressions.test.ts

diff --git a/scripts/benchmark-performance.ts b/scripts/benchmark-performance.ts
index d6b0f97..a7f2811 100644
--- a/scripts/benchmark-performance.ts
+++ b/scripts/benchmark-performance.ts
@@ -1,7 +1,9 @@
 import { performance } from 'node:perf_hooks';
 import { getInitialState } from '../src/lib/seed';
 import { addDays, getTodayDateString, getWeekKey } from '../src/lib/date-utils';
-import { calculatePlayerScores } from '../src/lib/score-calculator';
+import { calculateHabitStreak, calculatePlayerScores, getWeeklyDailyDuelPoints } from '../src/lib/score-calculator';
+import { calculatePlayerBadges } from '../src/lib/badge-utils';
+import { indexCheckIns } from '../src/lib/check-in-index';
 import { rebalanceAllWeeklyCheckIns, rebalanceWeeklyHabitCheckIns } from '../src/lib/weekly-utils';
 import type { CheckIn } from '../src/lib/types';
 
@@ -38,6 +40,14 @@ bench('both player summaries', () => {
   calculatePlayerScores('maciek', checkIns, state.habits);
   calculatePlayerScores('myrna', checkIns, state.habits);
 });
+bench('Today habit streaks with shared index', () => {
+  const indexed = indexCheckIns(checkIns);
+  for (const habit of state.habits) {
+    if (habit.playerId === 'maciek' && habit.isActive) calculateHabitStreak(habit, checkIns, [], today, indexed);
+  }
+});
+bench('weekly Duel day points', () => getWeeklyDailyDuelPoints(checkIns, today));
+bench('selected Player badges', () => calculatePlayerBadges('maciek', checkIns, state.habits, state.stakes, 365));
 bench('hydrate weekly rebalance', () => rebalanceAllWeeklyCheckIns(checkIns, state.habits));
 
 const habit = state.habits.find(habit => habit.weeklyTargetDays);
diff --git a/src/components/ActivityFeed.tsx b/src/components/ActivityFeed.tsx
index 77f6564..e709118 100644
--- a/src/components/ActivityFeed.tsx
+++ b/src/components/ActivityFeed.tsx
@@ -3,13 +3,14 @@
 import React, { useMemo, useState } from 'react';
 import { useStore } from '@/lib/store';
 import { Habit, CheckIn, Player } from '@/lib/types';
-import { formatFriendlyDate, formatDateString, formatTimeAgo } from '@/lib/date-utils';
+import { formatFriendlyDate, formatTimeAgo } from '@/lib/date-utils';
 import { HabitIcon } from './HabitIcon';
 import { ProofGalleryModal } from './ProofGalleryModal';
 import { Camera, ChevronDown, Heart, MessageSquare, Search, Send, Sparkles, X } from 'lucide-react';
 import { soundEngine } from '@/lib/sound-utils';
 import { hapticSuccess, hapticLight } from '@/lib/haptic-utils';
 import { fireCelebrationConfetti } from '@/lib/confetti';
+import { buildTimelineItems, filterTimelineItems } from '@/lib/activity-timeline';
 
 export function ActivityFeed() {
   const {
@@ -70,84 +71,28 @@ export function ActivityFeed() {
     handleSendReaction(selectedEmoji, customMsg.trim());
   };
 
-  type TimelineItem =
-    | {
-        type: 'check_in';
-        id: string;
-        timestamp: string;
-        date: string;
-        checkIn: CheckIn;
-        habit: Habit;
-        player: Player;
-      }
-    | {
-        type: 'reaction';
-        id: string;
-        timestamp: string;
-        date: string;
-        fromPlayer: Player;
-        toPlayer: Player;
-        emoji: string;
-        message: string;
-      };
-
-  const timelineItems = useMemo(() => {
-    const timelineItems: TimelineItem[] = [];
-    const habitById = new Map(habits.map(habit => [habit.id, habit]));
-
-    checkIns.forEach((ci) => {
-      const habit = habitById.get(ci.habitId);
-      const player = players[ci.playerId];
-      if (habit && player) {
-        timelineItems.push({
-          type: 'check_in',
-          id: ci.id,
-          timestamp: ci.completedAt || `${ci.date}T12:00:00.000Z`,
-          date: ci.date,
-          checkIn: ci,
-          habit,
-          player,
-        });
-      }
-    });
-
-    reactions.forEach((r) => {
-      const fromPlayer = players[r.fromPlayerId];
-      const toPlayer = players[r.toPlayerId];
-      if (fromPlayer && toPlayer) {
-        timelineItems.push({
-          type: 'reaction',
-          id: r.id,
-          timestamp: r.timestamp,
-          date: formatDateString(new Date(r.timestamp)),
-          fromPlayer,
-          toPlayer,
-          emoji: r.emoji,
-          message: r.message,
-        });
-      }
-    });
-
-    timelineItems.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+  const timelineItems = useMemo(
+    () => buildTimelineItems({ checkIns, habits, players, reactions }),
+    [checkIns, habits, players, reactions]
+  );
 
-    return timelineItems;
-  }, [checkIns, habits, players, reactions]);
+  const filteredItems = useMemo(
+    () =>
+      filterTimelineItems(timelineItems, {
+        feedFilter,
+        playerFilter,
+        activePlayerId,
+        partnerId,
+        search,
+      }),
+    [timelineItems, feedFilter, playerFilter, activePlayerId, partnerId, search]
+  );
 
-  const filteredItems = useMemo(() => {
-    const query = search.trim().toLowerCase();
-    return timelineItems.filter((item) => {
-      if (feedFilter !== 'all' && item.type !== feedFilter) return false;
-      const actorId = item.type === 'check_in' ? item.player.id : item.fromPlayer.id;
-      if (playerFilter === 'me' && actorId !== activePlayerId) return false;
-      if (playerFilter === 'partner' && actorId !== partnerId) return false;
-      const content = item.type === 'check_in'
-        ? `${item.player.name} ${item.habit.title} ${item.checkIn.note || ''}`
-        : `${item.fromPlayer.name} ${item.toPlayer.name} ${item.message}`;
-      return content.toLowerCase().includes(query);
-    });
-  }, [timelineItems, feedFilter, playerFilter, activePlayerId, partnerId, search]);
   const visibleItems = filteredItems.slice(0, visibleCount);
-  const checkInCount = timelineItems.filter((item) => item.type === 'check_in').length;
+  const checkInCount = useMemo(
+    () => timelineItems.filter((item) => item.type === 'check_in').length,
+    [timelineItems]
+  );
 
   const inlineReply = (itemId: string) => replyTo === itemId && partner ? (
     <form onSubmit={(event) => {
diff --git a/src/components/TodayView.tsx b/src/components/TodayView.tsx
index a816fbc..0e53365 100644
--- a/src/components/TodayView.tsx
+++ b/src/components/TodayView.tsx
@@ -22,7 +22,6 @@ import { DateNavigator } from './DateNavigator';
 import { createDeferredView } from './DeferredView';
 
 import { Habit } from '@/lib/types';
-import { calculateHabitStreak } from '@/lib/score-calculator';
 
 const { View: ActivityFeed } = createDeferredView(() => import('./ActivityFeed').then(module => module.ActivityFeed));
 const { View: ProofGalleryModal } = createDeferredView(() => import('./ProofGalleryModal').then(module => module.ProofGalleryModal), null);
@@ -41,7 +40,7 @@ export function TodayView({ onOpenHabits, onOpenDuel }: { onOpenHabits: () => vo
     selectedDate,
     isTodaySelected,
     checkIns,
-    restDays,
+    getHabitStreak,
     activePlayer,
     isPartnerConnected,
     partnerId,
@@ -77,9 +76,9 @@ export function TodayView({ onOpenHabits, onOpenDuel }: { onOpenHabits: () => vo
   }, []);
 
   const context = `${activePlayer?.id}:${selectedDate}`;
-  const points = checkIns
+  const points = useMemo(() => checkIns
     .filter((checkIn) => checkIn.playerId === activePlayer?.id && checkIn.date === selectedDate)
-    .reduce((sum, checkIn) => sum + checkIn.pointsEarned, 0);
+    .reduce((sum, checkIn) => sum + checkIn.pointsEarned, 0), [checkIns, activePlayer?.id, selectedDate]);
   const rawPar = multiplayer.configured
     ? activeHabits.reduce((sum, habit) => sum + habit.points, 0)
     : 240;
@@ -161,9 +160,9 @@ export function TodayView({ onOpenHabits, onOpenDuel }: { onOpenHabits: () => vo
   }, []);
 
   const partner = partnerId ? players[partnerId] : null;
-  const partnerPoints = checkIns
+  const partnerPoints = useMemo(() => checkIns
     .filter((checkIn) => checkIn.playerId === partnerId && checkIn.date === selectedDate)
-    .reduce((sum, checkIn) => sum + checkIn.pointsEarned, 0);
+    .reduce((sum, checkIn) => sum + checkIn.pointsEarned, 0), [checkIns, partnerId, selectedDate]);
   const partnerRawPar = multiplayer.configured
     ? habits.filter((h) => h.playerId === partnerId && h.isActive).reduce((sum, h) => sum + h.points, 0)
     : par;
@@ -175,8 +174,8 @@ export function TodayView({ onOpenHabits, onOpenDuel }: { onOpenHabits: () => vo
     : [];
   const todayStr = getTodayDateString();
   const habitStreaks = useMemo(() => new Map(activeHabits.map(habit =>
-    [habit.id, calculateHabitStreak(habit, checkIns, restDays, todayStr)]
-  )), [activeHabits, checkIns, restDays, todayStr]);
+    [habit.id, getHabitStreak(habit, todayStr)]
+  )), [activeHabits, getHabitStreak, todayStr]);
   const getHabitCardProps = (habit: Habit) => ({
     habit,
     selectedDate,
diff --git a/src/components/TrophyCabinet.tsx b/src/components/TrophyCabinet.tsx
index 32fe6c1..0a9fedf 100644
--- a/src/components/TrophyCabinet.tsx
+++ b/src/components/TrophyCabinet.tsx
@@ -1,6 +1,7 @@
 'use client';
 
-import React, { useState } from 'react';
+import React, { useMemo, useState } from 'react';
+import { calculatePlayerBadges } from '@/lib/badge-utils';
 import { useStore } from '@/lib/store';
 import { getPlayerThemeStyles } from '@/lib/player-colors';
 import { PlayerId } from '@/lib/types';
@@ -23,11 +24,15 @@ import { soundEngine } from '@/lib/sound-utils';
 import { hapticLight } from '@/lib/haptic-utils';
 
 export function TrophyCabinet() {
-  const { maciekBadges, myrnaBadges, activePlayerId, players } = useStore();
+  const { checkIns, habits, stakes, maciekSummary, myrnaSummary, activePlayerId, players } = useStore();
   const [selectedPlayer, setSelectedPlayer] = useState<PlayerId>(activePlayerId || 'maciek');
   const [filter, setFilter] = useState<'all' | 'unlocked' | 'locked'>('all');
 
-  const badges = selectedPlayer === 'maciek' ? maciekBadges : myrnaBadges;
+  const currentStreak = selectedPlayer === 'maciek' ? maciekSummary.currentStreak : myrnaSummary.currentStreak;
+  const badges = useMemo(
+    () => calculatePlayerBadges(selectedPlayer, checkIns, habits, stakes, currentStreak),
+    [selectedPlayer, checkIns, habits, stakes, currentStreak]
+  );
 
   const filteredBadges = badges.filter((b) => {
     if (filter === 'unlocked') return b.isUnlocked;
diff --git a/src/lib/activity-timeline-regressions.test.ts b/src/lib/activity-timeline-regressions.test.ts
new file mode 100644
index 0000000..35744e9
--- /dev/null
+++ b/src/lib/activity-timeline-regressions.test.ts
@@ -0,0 +1,57 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { buildTimelineItems, compareTimelineItems, filterTimelineItems, parseTimelineTimestamp } from './activity-timeline';
+import { getInitialState } from './seed';
+import type { CheckIn, CouplesReaction, Habit, PlayerId } from './types';
+
+const state = getInitialState();
+function reading(playerId: PlayerId): Habit {
+  const found = state.habits.find(item => item.id === playerId + '-reading');
+  assert.ok(found);
+  return found;
+}
+function check(id: string, item: Habit, date: string, completedAt: string, note?: string): CheckIn {
+  return { id, habitId: item.id, playerId: item.playerId, date, completedAt, pointsEarned: 25, note };
+}
+
+test('Activity sorts backdated records by completion time and retains stable ties and timezone offsets', () => {
+  const owner = reading('maciek');
+  const guest = reading('myrna');
+  const checkIns = [
+    check('offset', owner, '2026-10-12', '2026-10-12T12:00:00+02:00'),
+    check('old', owner, '2024-01-01', '2024-01-01T12:00:00Z', 'An older reflection'),
+    check('backdated', owner, '2026-10-01', '2026-10-12T11:00:00Z'),
+    check('tie', guest, '2026-10-12', '2026-10-12T10:00:00Z'),
+    check('fallback', owner, '2026-10-11', ''),
+  ];
+  const reactions: CouplesReaction[] = [{ id: 'reaction', fromPlayerId: 'myrna', toPlayerId: 'maciek',
+    emoji: 'x', message: 'Nice progress', timestamp: '2026-10-12T10:00:00Z' }];
+  const items = buildTimelineItems({ checkIns, habits: state.habits, players: state.players, reactions });
+  assert.deepEqual(items.map(item => item.id), ['backdated', 'offset', 'tie', 'reaction', 'fallback', 'old']);
+  const options = { feedFilter: 'all', playerFilter: 'everyone', activePlayerId: 'maciek', partnerId: 'myrna', search: '' } as const;
+  assert.deepEqual(filterTimelineItems(items, { ...options, search: 'older reflection' }).map(item => item.id), ['old']);
+  assert.deepEqual(filterTimelineItems(items, { ...options, playerFilter: 'partner' }).map(item => item.id), ['tie', 'reaction']);
+  assert.deepEqual(filterTimelineItems(items, { ...options, feedFilter: 'reaction' }).map(item => item.id), ['reaction']);
+  assert.deepEqual(filterTimelineItems(items, { ...options, playerFilter: 'me' }).map(item => item.id), ['backdated', 'offset', 'fallback', 'old']);
+});
+
+test('Activity search includes records older than the initial visible page without truncating counts', () => {
+  const owner = reading('maciek');
+  const checkIns = Array.from({ length: 80 }, (_, index) => {
+    const date = '2026-01-' + String(index % 28 + 1).padStart(2, '0');
+    return check('record-' + index, owner, date, date + 'T12:00:00Z', index === 0 ? 'Rare archive note' : undefined);
+  });
+  const items = buildTimelineItems({ checkIns, habits: state.habits, players: state.players, reactions: [] });
+  assert.equal(items.length, 80);
+  const found = filterTimelineItems(items, { feedFilter: 'check_in', playerFilter: 'everyone',
+    activePlayerId: 'maciek', partnerId: 'myrna', search: 'RARE ARCHIVE' });
+  assert.deepEqual(found.map(item => item.id), ['record-0']);
+});
+
+test('Activity timestamp comparison retains missing, invalid and equal timestamp behavior', () => {
+  assert.equal(parseTimelineTimestamp('2026-10-12T12:00:00+02:00'), Date.parse('2026-10-12T10:00:00Z'));
+  assert.ok(Number.isNaN(parseTimelineTimestamp(undefined)));
+  assert.ok(Number.isNaN(parseTimelineTimestamp('invalid')));
+  assert.equal(compareTimelineItems({ timestampMs: 10 }, { timestampMs: 10 }), 0);
+  assert.equal(compareTimelineItems({ timestampMs: NaN }, { timestampMs: 10 }), 0);
+});
diff --git a/src/lib/activity-timeline.ts b/src/lib/activity-timeline.ts
new file mode 100644
index 0000000..c7f58c4
--- /dev/null
+++ b/src/lib/activity-timeline.ts
@@ -0,0 +1,149 @@
+import type { CheckIn, Habit, Player, CouplesReaction, PlayerId } from './types';
+import { formatDateString } from './date-utils';
+
+export type TimelineItem =
+  | {
+      type: 'check_in';
+      id: string;
+      timestamp: string;
+      timestampMs: number;
+      date: string;
+      checkIn: CheckIn;
+      habit: Habit;
+      player: Player;
+    }
+  | {
+      type: 'reaction';
+      id: string;
+      timestamp: string;
+      timestampMs: number;
+      date: string;
+      fromPlayer: Player;
+      toPlayer: Player;
+      emoji: string;
+      message: string;
+    };
+
+export interface BuildTimelineOptions {
+  checkIns: CheckIn[];
+  habits: Habit[];
+  players: Record<PlayerId, Player>;
+  reactions: CouplesReaction[];
+}
+
+export interface FilterTimelineOptions {
+  feedFilter: 'all' | 'check_in' | 'reaction';
+  playerFilter: 'everyone' | 'me' | 'partner';
+  activePlayerId: PlayerId | null;
+  partnerId: PlayerId | null;
+  search: string;
+}
+
+/**
+ * Parses an ISO or date timestamp into epoch milliseconds.
+ * Returns NaN if the timestamp is missing, empty, or invalid.
+ */
+export function parseTimelineTimestamp(timestamp: string | undefined | null): number {
+  if (!timestamp) return NaN;
+  return Date.parse(timestamp);
+}
+
+/**
+ * Chronological comparator for timeline items (newest first).
+ * Uses pre-parsed timestampMs numbers. Preserves exact baseline ordering,
+ * including ties and NaN fallback handling.
+ */
+export function compareTimelineItems(
+  a: { timestampMs: number },
+  b: { timestampMs: number }
+): number {
+  const diff = b.timestampMs - a.timestampMs;
+  return Number.isNaN(diff) ? 0 : diff;
+}
+
+/**
+ * Builds chronological timeline items from check-ins and reactions.
+ * Parses timestamps once per record at ingestion rather than allocating
+ * `new Date()` instances repeatedly during sorting.
+ */
+export function buildTimelineItems({
+  checkIns,
+  habits,
+  players,
+  reactions,
+}: BuildTimelineOptions): TimelineItem[] {
+  const timelineItems: TimelineItem[] = [];
+  const habitById = new Map(habits.map((habit) => [habit.id, habit]));
+
+  for (let i = 0; i < checkIns.length; i++) {
+    const ci = checkIns[i];
+    const habit = habitById.get(ci.habitId);
+    const player = players[ci.playerId];
+    if (habit && player) {
+      const timestamp = ci.completedAt || `${ci.date}T12:00:00.000Z`;
+      const timestampMs = parseTimelineTimestamp(timestamp);
+      timelineItems.push({
+        type: 'check_in',
+        id: ci.id,
+        timestamp,
+        timestampMs,
+        date: ci.date,
+        checkIn: ci,
+        habit,
+        player,
+      });
+    }
+  }
+
+  for (let i = 0; i < reactions.length; i++) {
+    const r = reactions[i];
+    const fromPlayer = players[r.fromPlayerId];
+    const toPlayer = players[r.toPlayerId];
+    if (fromPlayer && toPlayer) {
+      const timestampMs = parseTimelineTimestamp(r.timestamp);
+      timelineItems.push({
+        type: 'reaction',
+        id: r.id,
+        timestamp: r.timestamp,
+        timestampMs,
+        date: formatDateString(new Date(r.timestamp)),
+        fromPlayer,
+        toPlayer,
+        emoji: r.emoji,
+        message: r.message,
+      });
+    }
+  }
+
+  timelineItems.sort(compareTimelineItems);
+
+  return timelineItems;
+}
+
+/**
+ * Filters timeline items across feed type, player actor, and full-history search.
+ * Bypasses string allocations and lowercase conversions when search query is empty.
+ */
+export function filterTimelineItems(
+  items: TimelineItem[],
+  { feedFilter, playerFilter, activePlayerId, partnerId, search }: FilterTimelineOptions
+): TimelineItem[] {
+  const query = search.trim().toLowerCase();
+
+  return items.filter((item) => {
+    if (feedFilter !== 'all' && item.type !== feedFilter) return false;
+
+    const actorId = item.type === 'check_in' ? item.player.id : item.fromPlayer.id;
+    if (playerFilter === 'me' && actorId !== activePlayerId) return false;
+    if (playerFilter === 'partner' && actorId !== partnerId) return false;
+
+    if (!query) return true;
+
+    const content =
+      item.type === 'check_in'
+        ? `${item.player.name} ${item.habit.title} ${item.checkIn.note || ''}`
+        : `${item.fromPlayer.name} ${item.toPlayer.name} ${item.message}`;
+
+    return content.toLowerCase().includes(query);
+  });
+}
diff --git a/src/lib/badge-utils.ts b/src/lib/badge-utils.ts
index 5ea5a2d..1ce61b1 100644
--- a/src/lib/badge-utils.ts
+++ b/src/lib/badge-utils.ts
@@ -11,11 +11,11 @@ export const BADGE_DEFINITIONS: BadgeDefinition[] = [
     category: 'streak',
   },
   {
-      id: 'perfect_par',
+    id: 'perfect_par',
     title: 'Daily Par Master',
     description: 'Score 240+ points in a single day',
     icon: 'Trophy',
-      targetCount: 240,
+    targetCount: 240,
     category: 'parity',
   },
   {
@@ -107,78 +107,98 @@ export function calculatePlayerBadges(
   stakes: Stake[],
   currentStreak: number
 ): PlayerBadgeStatus[] {
-  const playerLogs = checkIns.filter((c) => c.playerId === playerId);
+  // Pre-classify habits for this player in a single pass over habits
+  const readingHabitSet = new Set<string>();
+  const cleanHabitSet = new Set<string>();
+  const gymHabitSet = new Set<string>();
+  const langHabitSet = new Set<string>();
+  const projectHabitSet = new Set<string>();
 
-  // Daily point sums
-  const dailyPointsMap: Record<string, number> = {};
-  playerLogs.forEach((l) => {
-    dailyPointsMap[l.date] = (dailyPointsMap[l.date] || 0) + l.pointsEarned;
-  });
-
-  // Check if scored 240+ in any single day
-  const maxDayPoints = Object.values(dailyPointsMap).reduce((max, pts) => Math.max(max, pts), 0);
+  for (let i = 0; i < habits.length; i++) {
+    const h = habits[i];
+    if (h.playerId !== playerId) continue;
+    if (h.isQuantitative || h.iconName === 'BookOpen') readingHabitSet.add(h.id);
+    if (h.category === 'environment') cleanHabitSet.add(h.id);
+    if (h.category === 'physical') gymHabitSet.add(h.id);
+    if (h.category === 'language') langHabitSet.add(h.id);
+    if (h.category === 'deep_work') projectHabitSet.add(h.id);
+  }
 
-  // Cumulative pages read
-  const readingHabitIds = habits
-    .filter((h) => h.playerId === playerId && (h.isQuantitative || h.iconName === 'BookOpen'))
-    .map((h) => h.id);
-  const totalPages = playerLogs
-    .filter((l) => readingHabitIds.includes(l.habitId))
-    .reduce((sum, l) => sum + (l.quantity || l.pointsEarned), 0);
+  const partnerId: PlayerId = playerId === 'maciek' ? 'myrna' : 'maciek';
+  const dailyPointsMap: Record<string, number> = Object.create(null);
+  const internalPartnerDailyPoints: Record<string, number> = Object.create(null);
+  const dateToWeekMap = new Map<string, string>();
+  const weeklyGymCounts: Record<string, number> = Object.create(null);
 
-  // Clean space with photos
-  const cleanHabitIds = habits
-    .filter((h) => h.playerId === playerId && h.category === 'environment')
-    .map((h) => h.id);
-  const cleanWithPhotoCount = playerLogs.filter(
-    (l) => cleanHabitIds.includes(l.habitId) && ((l.proofUrls && l.proofUrls.length > 0) || l.proofUrl)
-  ).length;
+  let playerLogsCount = 0;
+  let totalPages = 0;
+  let cleanWithPhotoCount = 0;
+  let languageCount = 0;
+  let projectCount = 0;
 
-  // Gym workouts in single week
-  const gymHabitIds = habits
-    .filter((h) => h.playerId === playerId && h.category === 'physical')
-    .map((h) => h.id);
-  const weeklyGymCounts: Record<string, number> = {};
-  playerLogs
-    .filter((l) => gymHabitIds.includes(l.habitId))
-    .forEach((l) => {
-      const d = parseDate(l.date);
-      const { year, week } = getISOWeek(d);
-      const key = `${year}-W${week}`;
-      weeklyGymCounts[key] = (weeklyGymCounts[key] || 0) + 1;
-    });
-  const maxGymInSingleWeek = Object.values(weeklyGymCounts).reduce((max, c) => Math.max(max, c), 0);
+  // Single pass over checkIns
+  for (let i = 0; i < checkIns.length; i++) {
+    const l = checkIns[i];
+    if (l.playerId === playerId) {
+      playerLogsCount++;
+      dailyPointsMap[l.date] = (dailyPointsMap[l.date] || 0) + l.pointsEarned;
 
-  // Language count
-  const langHabitIds = habits
-    .filter((h) => h.playerId === playerId && h.category === 'language')
-    .map((h) => h.id);
-  const languageCount = playerLogs.filter((l) => langHabitIds.includes(l.habitId)).length;
+      if (readingHabitSet.has(l.habitId)) {
+        totalPages += (l.quantity || l.pointsEarned);
+      }
+      if (cleanHabitSet.has(l.habitId) && ((l.proofUrls && l.proofUrls.length > 0) || l.proofUrl)) {
+        cleanWithPhotoCount++;
+      }
+      if (gymHabitSet.has(l.habitId)) {
+        let weekKey = dateToWeekMap.get(l.date);
+        if (weekKey === undefined) {
+          const d = parseDate(l.date);
+          const { year, week } = getISOWeek(d);
+          weekKey = `${year}-W${week}`;
+          dateToWeekMap.set(l.date, weekKey);
+        }
+        weeklyGymCounts[weekKey] = (weeklyGymCounts[weekKey] || 0) + 1;
+      }
+      if (langHabitSet.has(l.habitId)) {
+        languageCount++;
+      }
+      if (projectHabitSet.has(l.habitId)) {
+        projectCount++;
+      }
+    } else if (l.playerId === partnerId) {
+      internalPartnerDailyPoints[l.date] = (internalPartnerDailyPoints[l.date] || 0) + l.pointsEarned;
+    }
+  }
 
-  // Deep work project count
-  const projectHabitIds = habits
-    .filter((h) => h.playerId === playerId && h.category === 'deep_work')
-    .map((h) => h.id);
-  const projectCount = playerLogs.filter((l) => projectHabitIds.includes(l.habitId)).length;
+  // Calculate max day points
+  let maxDayPoints = 0;
+  for (const date in dailyPointsMap) {
+    const pts = dailyPointsMap[date];
+    if (pts > maxDayPoints) maxDayPoints = pts;
+  }
 
-  // Iron Couple Synergy check: did both hit 240+ on any same date?
-  const partnerId: PlayerId = playerId === 'maciek' ? 'myrna' : 'maciek';
-  const partnerLogs = checkIns.filter((c) => c.playerId === partnerId);
-  const partnerDailyPoints: Record<string, number> = {};
-  partnerLogs.forEach((l) => {
-    partnerDailyPoints[l.date] = (partnerDailyPoints[l.date] || 0) + l.pointsEarned;
-  });
+  // Calculate max gym workouts in a single calendar week
+  let maxGymInSingleWeek = 0;
+  for (const weekKey in weeklyGymCounts) {
+    const count = weeklyGymCounts[weekKey];
+    if (count > maxGymInSingleWeek) maxGymInSingleWeek = count;
+  }
 
+  // Check if both hit 240+ on the same day
   let bothHit240OnSameDay = false;
-  for (const [date, pts] of Object.entries(dailyPointsMap)) {
-    if (pts >= 240 && (partnerDailyPoints[date] || 0) >= 240) {
+  for (const date in dailyPointsMap) {
+    if (dailyPointsMap[date] >= 240 && (internalPartnerDailyPoints[date] ?? 0) >= 240) {
       bothHit240OnSameDay = true;
       break;
     }
   }
 
-  // Stakes won
-  const stakesWonCount = stakes.filter((s) => s.winnerId === playerId).length;
+  let stakesWonCount = 0;
+  for (let i = 0; i < stakes.length; i++) {
+    if (stakes[i].winnerId === playerId) {
+      stakesWonCount++;
+    }
+  }
 
   return BADGE_DEFINITIONS.map((def) => {
     let currentVal = 0;
@@ -186,7 +206,7 @@ export function calculatePlayerBadges(
 
     switch (def.id) {
       case 'first_checkin':
-        currentVal = playerLogs.length;
+        currentVal = playerLogsCount;
         unlocked = currentVal >= 1;
         break;
       case 'perfect_par':
diff --git a/src/lib/calculation-regressions.test.ts b/src/lib/calculation-regressions.test.ts
new file mode 100644
index 0000000..2b961da
--- /dev/null
+++ b/src/lib/calculation-regressions.test.ts
@@ -0,0 +1,97 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { calculatePlayerBadges } from './badge-utils';
+import { indexCheckIns } from './check-in-index';
+import { addDays } from './date-utils';
+import { calculateHabitStreak, calculateWeeklyHabitStreak, getWeeklyDailyDuelPoints } from './score-calculator';
+import { getInitialState } from './seed';
+import type { CheckIn, Habit, RestDay } from './types';
+
+const state = getInitialState();
+function habit(id: string): Habit {
+  const found = state.habits.find(item => item.id === id);
+  assert.ok(found);
+  return found;
+}
+function log(item: Habit, date: string, extra: Partial<CheckIn> = {}): CheckIn {
+  return { id: `${item.id}-${date}`, habitId: item.id, playerId: item.playerId, date,
+    pointsEarned: item.points, completedAt: `${date}T12:00:00Z`, ...extra };
+}
+
+test('badges retain duplicate records, zero-quantity fallback, proofs and multiple physical habits', () => {
+  const reading = habit('maciek-reading');
+  const clean = habit('maciek-clean');
+  const gym = habit('maciek-gym');
+  const secondGym = { ...gym, id: 'second-gym' };
+  const date = '2025-12-29';
+  const checks = [
+    log(reading, date, { id: 'read-zero', quantity: 0 }),
+    log(reading, date, { id: 'read-quantity', quantity: 15 }),
+    log(clean, date, { id: 'proof-single', proofUrl: 'photo' }),
+    log(clean, date, { id: 'proof-empty', proofUrls: [] }),
+    log(clean, date, { id: 'proof-multiple', proofUrls: ['one', 'two'] }),
+    log(gym, date, { id: 'gym-1' }), log(gym, date, { id: 'gym-2' }),
+    log(gym, date, { id: 'gym-3' }), log(secondGym, date),
+    log(habit('maciek-language'), date),
+    log(habit('myrna-gym'), date, { pointsEarned: 240 }),
+  ];
+  const badges = calculatePlayerBadges('maciek', checks, [...state.habits, secondGym], [], 5);
+  const value = (id: string) => badges.find(item => item.badge.id === id)?.currentValue;
+  assert.equal(value('first_checkin'), 10);
+  assert.equal(value('reading_100'), 40);
+  assert.equal(value('clean_space_sentinel'), 2);
+  assert.equal(value('gym_par'), 4);
+  assert.equal(value('polyglot'), 1);
+  assert.equal(value('perfect_par'), 260);
+  assert.equal(value('iron_couple'), 1);
+});
+
+test('weekly Duel points include duplicate records and both sides of the civil New Year', () => {
+  const owner = habit('maciek-gym');
+  const guest = habit('myrna-gym');
+  const checks = [log(owner, '2025-12-29', { pointsEarned: 50 }),
+    log(owner, '2025-12-29', { id: 'duplicate', pointsEarned: 20 }),
+    log(guest, '2025-12-29'), log(owner, '2026-01-01', { pointsEarned: 100 }),
+    log(owner, '2026-01-04', { pointsEarned: 15 }),
+    log(owner, '2025-12-28', { pointsEarned: 999 }), log(owner, '2026-01-05', { pointsEarned: 999 })];
+  const days = getWeeklyDailyDuelPoints(checks, '2026-01-01');
+  assert.deepEqual(days.map(day => day.maciekPoints), [70, 0, 0, 100, 0, 0, 15]);
+  assert.deepEqual(days.map(day => day.myrnaPoints), [40, 0, 0, 0, 0, 0, 0]);
+  assert.equal(days[3].dateStr, '2026-01-01');
+});
+
+test('indexed daily streaks bridge only the Player rest day over a DST civil boundary', () => {
+  const item = habit('maciek-reading');
+  const checks = ['2026-10-25', '2026-10-24', '2026-10-22', '2026-10-21'].map(date => log(item, date));
+  checks.push(log(item, '2026-10-22', { id: 'duplicate' }));
+  const rest: RestDay = { id: 'rest', playerId: 'maciek', date: '2026-10-23', createdAt: '' };
+  const indexed = indexCheckIns(checks);
+  assert.equal(calculateHabitStreak(item, checks, [rest], '2026-10-25'), 4);
+  assert.equal(calculateHabitStreak(item, checks, [rest], '2026-10-25', indexed), 4);
+  assert.equal(calculateHabitStreak(item, checks, [{ ...rest, playerId: 'myrna' }], '2026-10-25', indexed), 2);
+  assert.equal(calculateHabitStreak(item, [], [rest], '2026-10-25', indexCheckIns([])), 0);
+});
+
+test('daily streaks retain the 365-calendar-day cap when indexed', () => {
+  const item = habit('maciek-reading');
+  const checks = Array.from({ length: 730 }, (_, day) => log(item, addDays('2026-10-12', -day)));
+  const indexed = indexCheckIns(checks);
+  assert.equal(calculateHabitStreak(item, checks, [], '2026-10-12'), 365);
+  assert.equal(calculateHabitStreak(item, checks, [], '2026-10-12', indexed), 365);
+});
+
+test('weekly streaks retain 52 prior weeks and distinguish partial, completed and duplicate-only weeks', () => {
+  const item = habit('maciek-gym');
+  const today = '2026-10-14';
+  const checks: CheckIn[] = [];
+  for (let week = 1; week <= 60; week++) {
+    for (let day = 0; day < 4; day++) checks.push(log(item, addDays('2026-10-12', -7 * week + day)));
+  }
+  checks.push(log(item, '2026-10-12'));
+  assert.equal(calculateWeeklyHabitStreak(item, checks, today, indexCheckIns(checks)), 52);
+  for (let day = 1; day < 4; day++) checks.push(log(item, addDays('2026-10-12', day)));
+  assert.equal(calculateWeeklyHabitStreak(item, checks, today), 53);
+  assert.equal(calculateWeeklyHabitStreak(item, checks, today, indexCheckIns(checks)), 53);
+  const duplicates = Array.from({ length: 4 }, (_, index) => log(item, '2026-10-12', { id: `duplicate-${index}` }));
+  assert.equal(calculateWeeklyHabitStreak(item, duplicates, today, indexCheckIns(duplicates)), 0);
+});
diff --git a/src/lib/check-in-index.ts b/src/lib/check-in-index.ts
index 87cd401..a5f8796 100644
--- a/src/lib/check-in-index.ts
+++ b/src/lib/check-in-index.ts
@@ -33,3 +33,5 @@ export function indexCheckIns(checkIns: CheckIn[]) {
   }
   return { byHabitAndDate, weeklyDates };
 }
+
+export type CheckInIndex = ReturnType<typeof indexCheckIns>;
diff --git a/src/lib/score-calculator.ts b/src/lib/score-calculator.ts
index bbe9e55..f9ecb6e 100644
--- a/src/lib/score-calculator.ts
+++ b/src/lib/score-calculator.ts
@@ -15,6 +15,7 @@ import {
   parseDate,
   addDays,
 } from './date-utils';
+import type { CheckInIndex } from './check-in-index';
 
 export function calculatePlayerScores(
   playerId: PlayerId,
@@ -262,21 +263,35 @@ export interface DailyDuelPoint {
 
 export function getWeeklyDailyDuelPoints(checkIns: CheckIn[], today = getTodayDateString()): DailyDuelPoint[] {
   const days = getCurrentWeekDays(today);
+  const weekStart = days[0].dateStr;
+  const weekEnd = days[6].dateStr;
 
-  return days.map((day) => {
-    const dayLogs = checkIns.filter((c) => c.date === day.dateStr);
-    const maciekPoints = dayLogs
-      .filter((c) => c.playerId === 'maciek')
-      .reduce((sum, c) => sum + c.pointsEarned, 0);
-    const myrnaPoints = dayLogs
-      .filter((c) => c.playerId === 'myrna')
-      .reduce((sum, c) => sum + c.pointsEarned, 0);
+  const pointsMap = new Map<string, { maciek: number; myrna: number }>();
+  for (let i = 0; i < days.length; i++) {
+    pointsMap.set(days[i].dateStr, { maciek: 0, myrna: 0 });
+  }
 
+  for (let i = 0; i < checkIns.length; i++) {
+    const c = checkIns[i];
+    if (c.date >= weekStart && c.date <= weekEnd) {
+      const entry = pointsMap.get(c.date);
+      if (entry !== undefined) {
+        if (c.playerId === 'maciek') {
+          entry.maciek += c.pointsEarned;
+        } else if (c.playerId === 'myrna') {
+          entry.myrna += c.pointsEarned;
+        }
+      }
+    }
+  }
+
+  return days.map((day) => {
+    const entry = pointsMap.get(day.dateStr);
     return {
       dayName: day.dayName,
       dateStr: day.dateStr,
-      maciekPoints,
-      myrnaPoints,
+      maciekPoints: entry ? entry.maciek : 0,
+      myrnaPoints: entry ? entry.myrna : 0,
       isToday: day.isToday,
       isFuture: day.isFuture,
     };
@@ -311,7 +326,8 @@ export function getStakesRecord(stakes: Stake[]): StakesRecord {
 export function calculateWeeklyHabitStreak(
   habit: Habit,
   checkIns: CheckIn[],
-  today = getTodayDateString()
+  today = getTodayDateString(),
+  indexed?: CheckInIndex
 ): number {
   if (!habit.weeklyTargetDays || habit.weeklyTargetDays <= 0) return 0;
 
@@ -319,16 +335,25 @@ export function calculateWeeklyHabitStreak(
   const todayDays = getCurrentWeekDays(today);
   const currentWeekMondayStr = todayDays[0].dateStr;
 
-  const weekCompletions = new Map<string, Set<string>>();
-  for (const checkIn of checkIns) {
-    if (checkIn.habitId !== habit.id) continue;
-    const weekKey = getWeekKey(checkIn.date);
-    let completedDates = weekCompletions.get(weekKey);
-    if (!completedDates) {
-      completedDates = new Set<string>();
-      weekCompletions.set(weekKey, completedDates);
+  let weekCompletions: Map<string, Set<string>> | undefined;
+
+  if (indexed) {
+    weekCompletions = indexed.weeklyDates.get(habit.id);
+    if (!weekCompletions || weekCompletions.size === 0) return 0;
+  } else {
+    weekCompletions = new Map<string, Set<string>>();
+    for (let i = 0; i < checkIns.length; i++) {
+      const checkIn = checkIns[i];
+      if (checkIn.habitId !== habit.id) continue;
+      const weekKey = getWeekKey(checkIn.date);
+      let completedDates = weekCompletions.get(weekKey);
+      if (!completedDates) {
+        completedDates = new Set<string>();
+        weekCompletions.set(weekKey, completedDates);
+      }
+      completedDates.add(checkIn.date);
     }
-    completedDates.add(checkIn.date);
+    if (weekCompletions.size === 0) return 0;
   }
 
   let streak = 0;
@@ -355,20 +380,31 @@ export function calculateHabitStreak(
   habit: Habit,
   checkIns: CheckIn[],
   restDays: RestDay[] = [],
-  today = getTodayDateString()
+  today = getTodayDateString(),
+  indexed?: CheckInIndex
 ): number {
   if (habit.weeklyTargetDays && habit.weeklyTargetDays > 0) {
-    return calculateWeeklyHabitStreak(habit, checkIns, today);
+    return calculateWeeklyHabitStreak(habit, checkIns, today, indexed);
   }
 
-  const uniqueDates = new Set<string>();
-  for (const checkIn of checkIns) {
-    if (checkIn.habitId === habit.id) uniqueDates.add(checkIn.date);
+  let dateSource: { has(key: string): boolean };
+  if (indexed) {
+    const habitDates = indexed.byHabitAndDate.get(habit.id);
+    if (!habitDates || habitDates.size === 0) return 0;
+    dateSource = habitDates;
+  } else {
+    const uniqueDates = new Set<string>();
+    for (let i = 0; i < checkIns.length; i++) {
+      const checkIn = checkIns[i];
+      if (checkIn.habitId === habit.id) uniqueDates.add(checkIn.date);
+    }
+    if (uniqueDates.size === 0) return 0;
+    dateSource = uniqueDates;
   }
-  if (uniqueDates.size === 0) return 0;
 
   const playerRestDays = new Set<string>();
-  for (const restDay of restDays) {
+  for (let i = 0; i < restDays.length; i++) {
+    const restDay = restDays[i];
     if (restDay.playerId === habit.playerId) playerRestDays.add(restDay.date);
   }
 
@@ -376,7 +412,7 @@ export function calculateHabitStreak(
   const checkDate = parseDate(today);
 
   // If not completed today and not a rest day, check from yesterday
-  const todayCovered = uniqueDates.has(today) || playerRestDays.has(today);
+  const todayCovered = dateSource.has(today) || playerRestDays.has(today);
   if (!todayCovered) {
     checkDate.setDate(checkDate.getDate() - 1);
   }
@@ -387,7 +423,7 @@ export function calculateHabitStreak(
     const d = String(checkDate.getDate()).padStart(2, '0');
     const dateStr = `${y}-${m}-${d}`;
 
-    if (uniqueDates.has(dateStr)) {
+    if (dateSource.has(dateStr)) {
       streak++;
       checkDate.setDate(checkDate.getDate() - 1);
     } else if (playerRestDays.has(dateStr)) {
@@ -400,5 +436,3 @@ export function calculateHabitStreak(
 
   return streak;
 }
-
-
diff --git a/src/lib/store.tsx b/src/lib/store.tsx
index 214cd70..0c5c7fc 100644
--- a/src/lib/store.tsx
+++ b/src/lib/store.tsx
@@ -8,7 +8,6 @@ import {
   Habit,
   LeaderboardTier,
   Player,
-  PlayerBadgeStatus,
   PlayerId,
   PlayerScoreSummary,
   RestDay,
@@ -29,8 +28,7 @@ import { maximumHabitPoints, weeklyPointPotential } from './habit-catalog';
 import { parseBackup } from './backup';
 import { canImportLegacyDatabase, needsLegacyReplacement, prepareLegacyImport, readLegacyProgress, restoreLegacyDuelProgress } from './legacy-import';
 import { getTodayDateString, getWeekKey, isFutureDate, isValidDateString } from './date-utils';
-import { calculatePlayerScores, getVersusComparison } from './score-calculator';
-import { calculatePlayerBadges } from './badge-utils';
+import { calculateHabitStreak, calculatePlayerScores, getVersusComparison } from './score-calculator';
 import { indexCheckIns } from './check-in-index';
 import {
   rebalanceWeeklyHabitCheckIns,
@@ -99,9 +97,7 @@ interface StoreContextType {
   maciekSummary: PlayerScoreSummary;
   myrnaSummary: PlayerScoreSummary;
   activePlayerSummary: PlayerScoreSummary;
-  maciekBadges: PlayerBadgeStatus[];
-  myrnaBadges: PlayerBadgeStatus[];
-  activePlayerBadges: PlayerBadgeStatus[];
+  getHabitStreak: (habit: Habit, today?: string) => number;
   soundEnabled: boolean;
   setSoundEnabled: (enabled: boolean) => void;
   selectProfile: (id: PlayerId) => void;
@@ -651,7 +647,7 @@ export function StoreProvider({ children }: { children: React.ReactNode }) {
   );
 
   const partnerCleanSpaceCheckIn = partnerCleanSpaceHabit
-    ? state.checkIns.find((c) => c.habitId === partnerCleanSpaceHabit.id && c.date === selectedDate)
+    ? checkInIndex.byHabitAndDate.get(partnerCleanSpaceHabit.id)?.get(selectedDate)
     : undefined;
 
   const getHealthTelemetryOnDate = useCallback(
@@ -700,9 +696,7 @@ export function StoreProvider({ children }: { children: React.ReactNode }) {
   if (quantity !== undefined && (!Number.isFinite(quantity) || quantity <= 0)) return;
   
   const targetWeekKey = getWeekKey(targetDate);
-  const existingCheckIn = state.checkIns.find(
-    (c) => c.habitId === habitId && c.date === targetDate
-  );
+  const existingCheckIn = checkInIndex.byHabitAndDate.get(habitId)?.get(targetDate);
 
   const telemetry = state.healthTelemetry?.[`${habitId}:${targetDate}`];
   const healthProgress = getHealthProgressDetails(habit, telemetry, existingCheckIn);
@@ -1282,6 +1276,9 @@ export function StoreProvider({ children }: { children: React.ReactNode }) {
   );
 
 
+
+
+
   const disconnectGoogleHealth = useStableCallback(() => { if (typeof document !== 'undefined') {
     document.cookie = 'g_fit_connected=; Path=/; Expires=Thu, 01 Jan 1970 00:00:01 GMT;';
     document.cookie = 'g_fit_access_token=; Path=/; Expires=Thu, 01 Jan 1970 00:00:01 GMT;';
@@ -1315,19 +1312,11 @@ export function StoreProvider({ children }: { children: React.ReactNode }) {
     [state.activePlayerId, maciekSummary, myrnaSummary]
   );
 
-  // Badges
-  const maciekBadges = useMemo(
-    () => calculatePlayerBadges('maciek', state.checkIns, state.habits, state.stakes, maciekSummary.currentStreak),
-    [state.checkIns, state.habits, state.stakes, maciekSummary.currentStreak]
+  const getHabitStreak = useCallback(
+    (habit: Habit, today = todayStr) => calculateHabitStreak(habit, state.checkIns, restDays, today, checkInIndex),
+    [state.checkIns, restDays, todayStr, checkInIndex]
   );
 
-  const myrnaBadges = useMemo(
-    () => calculatePlayerBadges('myrna', state.checkIns, state.habits, state.stakes, myrnaSummary.currentStreak),
-    [state.checkIns, state.habits, state.stakes, myrnaSummary.currentStreak]
-  );
-
-  const activePlayerBadges = state.activePlayerId === 'maciek' ? maciekBadges : myrnaBadges;
-
   const activeWeeklyStake = state.stakes.find((s) => s.period === 'weekly' && s.status === 'active');
   const activeMonthlyStake = state.stakes.find((s) => s.period === 'monthly' && s.status === 'active');
   const getComparison = useCallback(
@@ -1343,7 +1332,7 @@ export function StoreProvider({ children }: { children: React.ReactNode }) {
     players: state.players, habits: state.habits, activeHabits, checkIns: state.checkIns,
     stakes: state.stakes, reactions: state.reactions || [], restDays: state.restDays || [],
     selectedDate, isTodaySelected, setSelectedDate, maciekSummary, myrnaSummary,
-    activePlayerSummary, maciekBadges, myrnaBadges, activePlayerBadges, soundEnabled,
+    activePlayerSummary, getHabitStreak, soundEnabled,
     setSoundEnabled, selectProfile, switchProfile, updateLocalPlayerName, updatePlayerColor, recordInvite, toggleHabit,
     updateCheckInNote, isHabitCompletedToday, getHabitCheckInToday, isHabitCompletedOnDate,
     getHabitCheckInOnDate, getCheckInForHabit, getWeeklyHabitCompletions,
@@ -1359,7 +1348,7 @@ export function StoreProvider({ children }: { children: React.ReactNode }) {
   }), [
     isHydrated, loadedDuelId, syncStatus, storageError, state, activePlayer, activeHabits,
     selectedDate, isTodaySelected, maciekSummary, myrnaSummary, activePlayerSummary,
-    maciekBadges, myrnaBadges, activePlayerBadges, soundEnabled, setSoundEnabled,
+    getHabitStreak, soundEnabled, setSoundEnabled,
     selectProfile, switchProfile, updateLocalPlayerName, updatePlayerColor, recordInvite, toggleHabit, updateCheckInNote,
     isHabitCompletedToday, getHabitCheckInToday, isHabitCompletedOnDate, getHabitCheckInOnDate,
     getCheckInForHabit, getWeeklyHabitCompletions, isHabitWeeklyTargetMet, isHabitSatisfiedOnDate,

From 7ea6b2eb9f8bd533bb5883a95056c59a1778a3c7 Mon Sep 17 00:00:00 2001
From: Maseeek <maseeekyt@gmail.com>
Date: Mon, 12 Oct 2026 03:47:29 +0100
Subject: [PATCH 05/10] docs(performance): record benchmarks and reproducible
 browser checks

Publish production first-open, interaction, offline, and mocked Duel
measurements alongside their assumptions and remaining limits. Include
standalone browser harnesses for loading, persistence, pagination,
realtime bursts, and the overlapping read/write reproduction.

Keep the unattended decision trail with the accepted raw evidence and
document the corrected instrumentation and local-only diagnosis files.

Refs #63.
---
 .gitignore                                    |    2 +
 docs/performance.md                           |   38 +
 docs/performance/2026-10-12/README.md         |   59 +
 docs/performance/2026-10-12/decisions.tsv     |   36 +
 docs/performance/2026-10-12/duel-cap400.json  | 2778 +++++++++++++++++
 docs/performance/2026-10-12/duel-race.json    |  264 ++
 docs/performance/2026-10-12/duel-reload.json  | 1786 +++++++++++
 .../2026-10-12/first-open-mobile.json         |  323 ++
 docs/performance/2026-10-12/first-open.json   |  323 ++
 docs/performance/2026-10-12/interactions.json | 1171 +++++++
 docs/performance/2026-10-12/offline.json      |   37 +
 scripts/benchmark-browser.cjs                 |  188 ++
 scripts/verify-duel-performance.cjs           |  219 ++
 13 files changed, 7224 insertions(+)
 create mode 100644 docs/performance/2026-10-12/README.md
 create mode 100644 docs/performance/2026-10-12/decisions.tsv
 create mode 100644 docs/performance/2026-10-12/duel-cap400.json
 create mode 100644 docs/performance/2026-10-12/duel-race.json
 create mode 100644 docs/performance/2026-10-12/duel-reload.json
 create mode 100644 docs/performance/2026-10-12/first-open-mobile.json
 create mode 100644 docs/performance/2026-10-12/first-open.json
 create mode 100644 docs/performance/2026-10-12/interactions.json
 create mode 100644 docs/performance/2026-10-12/offline.json
 create mode 100644 scripts/benchmark-browser.cjs
 create mode 100644 scripts/verify-duel-performance.cjs

diff --git a/.gitignore b/.gitignore
index 028f697..109df9e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -45,6 +45,8 @@ agent-audit-report.json
 /scripts/*
 !/scripts/revoke-legacy-health-tokens.mjs
 !/scripts/benchmark-performance.ts
+!/scripts/benchmark-browser.cjs
+!/scripts/verify-duel-performance.cjs
 # scratch & local cache
 /.scratch/
 supabase/.temp/
diff --git a/docs/performance.md b/docs/performance.md
index 645f6a1..76d6913 100644
--- a/docs/performance.md
+++ b/docs/performance.md
@@ -1,5 +1,43 @@
 # App loading and interaction performance
 
+## 2026-10-12 follow-up
+
+Compared production builds against `e7b284e` with Chrome 148 on the same machine. The local fixture has 730 prior days across 20 seeded Habits: 14,600 Check-ins, about 2.3 MB. These results measure local client work. The mobile scenario uses a 390×844 viewport and 4× CPU throttling; it does not represent a physical phone or hosted Supabase latency.
+
+The first open of a deferred view waited about 300 ms after its JavaScript was available. The installed React DOM production runtime throttles Suspense fallback replacement. Deferred views now use a guarded import resource and stable external-store snapshots, keeping the deployment check before activation. Tab and Settings imports also warm on pointer entry or keyboard focus. The initial page still loads its existing frame and Today view.
+
+First-open medians, five samples per view, document reload before every sample, HTTP cache retained, and two animation frames after content becomes ready:
+
+| View | Before | After |
+| --- | ---: | ---: |
+| Progress | 331.3 ms | 53.6 ms |
+| Duel | 331.3 ms | 44.8 ms |
+| Settings | 334.8 ms | 41.3 ms |
+| Activity | 333.4 ms | 40.2 ms |
+| Attach Proof | 350.2 ms | 39.1 ms |
+| Shortcuts | 352.9 ms | 48.3 ms |
+
+Repeated interactions alternate build order, with 20 Check-in/undo pairs per build and scenario. Timing includes the real state update, one observed synchronous localStorage write, and two animation frames. The saved state is parsed after timing:
+
+| Scenario | Action | Before | After |
+| --- | --- | ---: | ---: |
+| Desktop | Weekly Check-in | 48.6 ms | 41.4 ms |
+| Desktop | Undo | 53.3 ms | 45.4 ms |
+| Mobile viewport, 4× CPU | Weekly Check-in | 196.3 ms | 172.0 ms |
+| Mobile viewport, 4× CPU | Undo | 149.8 ms | 123.1 ms |
+
+Today streaks reuse the existing Check-in index, selected-day sums stay memoized, and badges are computed when the Trophy Cabinet mounts. Weekly Duel totals aggregate history once. Activity parses each timestamp once before sorting and skips search-string construction for an empty query, while retaining full-history search, counts, stable ties, and backdated records. Local persistence remains synchronous.
+
+Production copies configured for a localhost Supabase mock verify the actual client, store effect, Phoenix subscriptions, and paginated reads. With 2,500 Check-ins, a burst of 20 realtime events drops from 140 requests to 7; exact-count requests drop from 140 to 5. Events during an active read produce one serialized follow-up. A 400-row server cap still returns all 2,500 records, with 11 requests and 5 exact counts per reload. These request counts describe the mock, not hosted latency. When a total is missing or nonnumeric, pagination continues through the empty page so a short server-capped response cannot truncate history.
+
+That verification reproduced a read/write race on the original build: a read started before a local Check-in briefly replaced its optimistic state. The store now rejects reads when the pending-write queue changes during loading and requests a fresh read. The same browser reproduction keeps the Habit checked throughout. Initial loading, Check-in/undo writes, Activity counts, and isolation from local history also pass in the mock.
+
+`npm run check` passes 165 tests, typecheck, and lint; `npm run build` passes. Browser checks cover photo upload and undo, proof gallery, historical calendar navigation and Today reset, shortcut focus trapping and cleanup, light/dark themes, offline Check-in/undo and warmed views, and persisted history after reload. The measured desktop and mobile viewports have no horizontal overflow. Deployment mismatch, recovery reload limits, unavailable version endpoints, offline activation, duplicate records, rest days, and streak caps have focused tests.
+
+Reproduction commands and raw measurements are in [the October 12 evidence directory](performance/2026-10-12/README.md). Run `npx tsx scripts/benchmark-performance.ts` for calculation medians, including shared-index construction and all active Today streaks. The calculation benchmark is separate from the browser timings above.
+
+## 2026-10-10 pass
+
 Measured against main at `779dd85` on 2026-10-10, using production builds, Node 20.20.2 and Chrome on the same machine. The fixture contains 730 days for all 20 seeded habits, or 14,600 check-ins. These local measurements isolate client work; they do not measure authenticated Supabase latency or mobile hardware.
 
 Run the calculation benchmark with `npx tsx scripts/benchmark-performance.ts`. Each result is the median of five runs after one warm-up. Before the change, the weekly check-in diff used the store's `find` for each rebalanced record. The new benchmark uses the store's positional comparison, since rebalancing preserves array order.
diff --git a/docs/performance/2026-10-12/README.md b/docs/performance/2026-10-12/README.md
new file mode 100644
index 0000000..2a4f5c4
--- /dev/null
+++ b/docs/performance/2026-10-12/README.md
@@ -0,0 +1,59 @@
+# October 12 performance evidence
+
+Baseline application source is `e7b284e`. Measurements use production builds and synthetic history in isolated browser contexts. The current source includes guarded deferred views, indexed streaks, coalesced Duel reloads, and rejection of reads that overlap local writes.
+
+## Reproduce local browser measurements
+
+Serve the baseline and current production builds on separate localhost ports, with Supabase environment variables unset. Keep the current checkout on its branch. For the baseline, extract a source snapshot with `git archive e7b284e`; run `npm ci`, `npm run build`, then `npm run start -- --port 43127` in that snapshot. Run the current build on port 43130. The scripts accept different URLs with `--baseline` and `--current`.
+
+Install browser tooling outside the app's dependencies:
+
+```sh
+npm install --prefix .scratch/browser-tools playwright
+.scratch/browser-tools/node_modules/.bin/playwright install chromium
+```
+
+Run from the repository root:
+
+```sh
+NODE_PATH="$PWD/.scratch/browser-tools/node_modules" node scripts/benchmark-browser.cjs --mode first-open --samples 5 --output .scratch/first-open.json
+NODE_PATH="$PWD/.scratch/browser-tools/node_modules" node scripts/benchmark-browser.cjs --mode interactions --samples 20 --output .scratch/interactions.json
+NODE_PATH="$PWD/.scratch/browser-tools/node_modules" node scripts/benchmark-browser.cjs --mode interactions --mobile --cpu 4 --samples 20 --output .scratch/interactions-mobile.json
+NODE_PATH="$PWD/.scratch/browser-tools/node_modules" node scripts/benchmark-browser.cjs --mode offline --output .scratch/offline.json
+```
+
+Use `--chrome /path/to/chrome` to select an installed browser. This run used `/usr/bin/google-chrome`, version 148.0.7778.178. Timing ends after actual content or persistence and two animation frames. First-open samples reload the document but retain the HTTP cache. Interaction samples alternate build order and parse the saved state after timing. The mobile option changes the viewport; CPU throttling is synthetic.
+
+## Reproduce Duel reload and write-race checks
+
+Use separate baseline/current production snapshots configured for the mock below. They must not share the anonymous builds used above, because public environment variables are embedded during build:
+
+```sh
+NEXT_PUBLIC_SUPABASE_URL=http://127.0.0.1:54321 NEXT_PUBLIC_SUPABASE_ANON_KEY=mock-publishable-key npm run build
+NEXT_PUBLIC_SUPABASE_URL=http://127.0.0.1:54321 NEXT_PUBLIC_SUPABASE_ANON_KEY=mock-publishable-key npm run start -- --port 43131
+```
+
+Serve the corresponding current snapshot on port 43132. No Supabase server is required: Playwright handles the localhost HTTP responses and Phoenix WebSocket protocol. The fixture contains 2,500 Check-ins; responses wait 50 ms. `npm test` in the repository root creates the compiled seed module used by the harness.
+
+```sh
+npm test
+NODE_PATH="$PWD/.scratch/browser-tools/node_modules" node scripts/verify-duel-performance.cjs --page-cap 1000 --output .scratch/duel-reload.json
+NODE_PATH="$PWD/.scratch/browser-tools/node_modules" node scripts/verify-duel-performance.cjs --page-cap 400 --output .scratch/duel-cap400.json
+NODE_PATH="$PWD/.scratch/browser-tools/node_modules" node scripts/verify-duel-performance.cjs --race --output .scratch/duel-race.json
+```
+
+The reload checks assert full history, counts, filtered queries, twenty-event bursts, one follow-up for events during loading, actual Check-in/undo writes, and unchanged local history. The race check observes the Habit button while a read overlaps a local write: the baseline becomes unchecked temporarily; the current build remains checked. These tests verify client behavior and request amplification against a mock. They do not establish hosted database latency or server-side authorization.
+
+## Recorded artifacts
+
+- [First opens](first-open.json): five samples per view and build from `benchmark-browser.cjs`.
+- [First opens with a mobile viewport and 4× CPU](first-open-mobile.json): five samples per view and build under synthetic throttling.
+- [Repeated interactions](interactions.json): twenty alternating Check-in/undo pairs per build, desktop and synthetic mobile scenarios.
+- [Offline](offline.json): local mutation/undo, warmed views, and persisted history after reconnect/reload.
+- [Duel reloads](duel-reload.json): pagination and request counts with a 1,000-row page cap.
+- [Duel reloads with a 400-row cap](duel-cap400.json): no history truncation with a lower server limit.
+- [Read/write race](duel-race.json): the same UI reproduction on baseline and current source.
+
+Earlier instrumentation that polled and parsed the entire stored state inside the timed interaction was superseded. The accepted interaction artifact observes one real storage write and parses its value after timing. The mock also exposes `Content-Range` to the browser and waits for quiescence across pagination gaps. These corrections are recorded in the decision trail.
+
+The [decision trail](decisions.tsv) records accepted and abandoned work. Earlier diagnosis logs and quota-interrupted child reports remain local under `.scratch/performance-overnight`; the accepted measurements above and their reusable harnesses are committed here.
diff --git a/docs/performance/2026-10-12/decisions.tsv b/docs/performance/2026-10-12/decisions.tsv
new file mode 100644
index 0000000..34282ba
--- /dev/null
+++ b/docs/performance/2026-10-12/decisions.tsv
@@ -0,0 +1,36 @@
+ts	phase	decision	why	evidence	result
+2026-10-12T00:07:36Z	frame	Set the run deadline to 07:00 Europe/London and verified the stop timer	User requested work until 7am and the workspace timezone is Europe/London	.scratch/performance-overnight/state.json	stop scheduled for 2026-10-12T06:00:00Z
+2026-10-12T00:08:00Z	baseline	Baseline checks and production build passed	Need a clean baseline before accepting optimizations	.scratch/performance-overnight/baseline-check.log; .scratch/performance-overnight/baseline-build.log	134 tests passed; typecheck and lint passed; build passed
+2026-10-12T00:10:01Z	baseline	Measured production Check-ins and navigation with 14600 historical Check-ins	Use the real browser to isolate remaining interaction costs	.scratch/performance-overnight/baseline-browser.json	weekly Check-in median 81.3 ms; undo median 60.1 ms; Progress warm median 32.7 ms
+2026-10-12T00:12:17Z	baseline	Preserved the baseline source and production build in a detached worktree	Rebuild main without losing the original browser comparison target	.scratch/performance-overnight/baseline-app; .scratch/performance-overnight/baseline-isolated-server.log	baseline available on port 43127; main stays on main
+2026-10-12T00:12:52Z	orchestration	Delegated three separate read-only audits to Gemini Pro	Find measured bottlenecks before assigning implementation ownership	.scratch/performance-overnight/state.json	calculations, store/sync and UI/loading audits running
+2026-10-12T00:14:30Z	scope	Restricted calculation implementation to indexed streaks, exact badges and one-pass Duel points	Audit prototypes and unverified claims need real differential checks before accepting gains	.scratch/performance-overnight/calculations-r1.md; .scratch/performance-overnight/ui-r1.md	calculation implementation and evidence review delegated; no CSS or animation changes approved
+2026-10-12T00:16:12Z	scope	Kept synchronous persistence and narrowed store work to reload coalescing and dead polling	Deferred writes change durability; count removal can miss server-capped pages; existing health issue needs coordination	.scratch/performance-overnight/store-r1.md; .scratch/performance-overnight/notes.md	store-r2 assigned; risky suggestions excluded from this slice
+2026-10-12T00:18:38Z	review	Accepted Gemini evidence review flags and narrowed UI work to exact Activity ordering and intent preloads	Audits contained incorrect fetch claims and unsafe truncation; real cold navigation and caller integration remain to verify	.scratch/performance-overnight/trail-review-r1.md; .scratch/performance-overnight/notes.md	unsafe proposals excluded; three implementation tasks active; gains not yet accepted
+2026-10-12T00:24:40Z	baseline	Captured five first-view navigation samples per view after document reload	Earlier cold probes were excluded; needed valid repeatable baseline for loading work	.scratch/performance-overnight/baseline-first-navigation.json	Progress333.2ms; Duel334.7ms; Settings334.1ms; HTTP cache retained
+2026-10-12T00:24:40Z	integration	Assigned portable calculation tests and live indexed-streak/lazy-badge integration	Scratch baseline imports break clean CI and private indexes need actual caller integration	.scratch/performance-overnight/calculations-r2.md; src/lib/calculations-r2.test.ts; .scratch/performance-overnight/notes.md	calculation cleanup and store/Today integration running; R2 gains not yet accepted
+2026-10-12T00:33:07Z	repair	Continued parent work after Gemini quota interrupted three tasks and an alternate-model attempt	Partial files failed checks; provider terminal status is not implementation success	.scratch/performance-overnight/round3-check.log; .scratch/performance-overnight/round3-build.log; .scratch/performance-overnight/state.json	repaired syntax and portable tests; retries held until04:20UTC; repair checks running
+2026-10-12T00:39:00Z	verification	Repaired partial Gemini edits and integrated indexed streaks plus lazy badge calculations	Provider quota ended tasks before valid output; hot-path benefits require actual caller integration	.scratch/performance-overnight/integration-check.log; .scratch/performance-overnight/integration-build.log; .scratch/performance-overnight/repair-differential.log; .scratch/performance-overnight/integration-browser.json	152 tests and build pass; local Check-in median67.5ms; broader browser verification pending
+2026-10-12T00:47:17Z	loading	Replaced lazy tab rendering with a subscribed resolved-component snapshot	Production first opens waited300ms despite cached chunks; keep guarded imports and render as soon as ready	.scratch/performance-overnight/deferred-first-navigation.json; .scratch/performance-overnight/deferred-check.log; .scratch/performance-overnight/deferred-build.log	157 tests/build pass; first opens Progress33.3ms Duel39.8ms Settings30.4ms; broader flows pending
+2026-10-12T01:25:11Z	deferred-views	Use the guarded external-store loader for Activity, proof dialogs, and shortcuts	The measured first opens also incurred the same React fallback delay	src/components/DeferredView.tsx; .scratch/performance-overnight/deferred-extra-first-open.json	passed
+2026-10-12T01:25:11Z	intent-preload	Warm tab and Settings imports on pointer entry or keyboard focus	Intent can overlap chunk loading while the actual open still runs the deployment guard	src/components/Header.tsx; src/lib/deferred-resource.test.ts; src/lib/load-current-page.test.ts	160 tests and production build passed
+2026-10-12T01:25:11Z	browser-fallback	Use isolated headless Chrome after the preview host disconnected and alternate GUI inventory was empty	The explicit unavailable error prohibited preview retries and browser verification still needed to finish	.scratch/performance-overnight/headless-verification.cjs; .scratch/performance-overnight/headless-verification.json	60 comparative first-open samples and smoke passed
+2026-10-12T01:25:11Z	verification	Correct the harness dialog locator to the actual accessible name Shortcuts	The initial smoke timeout used Keyboard shortcuts while the app exposes Shortcuts	.scratch/performance-overnight/headless-verification-initial.json; .scratch/performance-overnight/headless-smoke.log	corrected smoke passed
+2026-10-12T01:25:11Z	visual-check	Inspect full-page light and dark screenshots after interaction smoke	Confirm the actual production UI remains readable and intact	.scratch/performance-overnight/headless-dark.png; .scratch/performance-overnight/headless-light.png	inspected; no new visual regression found
+2026-10-12T01:28:12Z	realtime	Reduce the reloader API and require its error handler	Only schedule, cancellation, and cancelled status are needed by the store; test-only idle and running APIs added complexity	src/lib/coalesced-reload.ts; src/lib/coalesced-reload.test.ts; .scratch/performance-overnight/reloader-check.log	162 tests, lint, typecheck, and production build passed
+2026-10-12T01:38:59Z	authenticated-reload	Verify the real production Duel subscription and mutation paths with a localhost mock	Unit tests alone did not cover the store effect, client subscription, and paginated query wiring	.scratch/performance-overnight/authenticated-reload.cjs; .scratch/performance-overnight/authenticated-reload.json; .scratch/performance-overnight/authenticated-reload-r5.log	baseline and current passed; twenty-event burst now one reload instead of twenty; history and writes preserved
+2026-10-12T01:38:59Z	verification	Correct mock request and accessibility assumptions before accepting Duel results	POST carries duel_id in the row; Activity is a tab; the timeline heading includes its count	.scratch/performance-overnight/authenticated-reload.log; .scratch/performance-overnight/authenticated-reload-r2.log; .scratch/performance-overnight/authenticated-reload-r4.log; .scratch/performance-overnight/authenticated-reload-r5.log	harness errors fixed; production application source unchanged
+2026-10-12T01:39:00Z	measurement	Replace repeated JSON parsing while waiting for persistence with a one-write observer	Polling the 2.3MB state added artificial work inside the timed interaction	.scratch/performance-overnight/interleaved-interactions-storage-polling.json; .scratch/performance-overnight/interleaved-interactions.cjs	old timing retained but superseded; corrected comparison running
+2026-10-12T01:43:00Z	authenticated-counts	Expose Content-Range in the cross-origin mock and assert exact-count elimination	The first mock hid that response header from the browser, forcing the existing unknown-count fallback	.scratch/performance-overnight/authenticated-reload-hidden-count-header.json; .scratch/performance-overnight/authenticated-reload.json; .scratch/performance-overnight/authenticated-reload-r6.log	corrected mock passed; each current reload requests five exact counts instead of seven
+2026-10-12T01:43:00Z	interaction-measurement	Accept the alternating comparison after removing state-polling overhead	Twenty measured check-in and undo pairs per build and scenario reduce order bias and retain real persistence in the timing	.scratch/performance-overnight/interleaved-interactions.json; .scratch/performance-overnight/interleaved-interactions-r2.log	desktop medians 48.55 to 41.4ms and 53.25 to 45.35ms; 4x CPU medians 196.25 to 172ms and 149.85 to 123.1ms; no errors or viewport overflow
+2026-10-12T01:44:24Z	authenticated-cap	Wait for quiescence across all pages before beginning the next scenario	The 400-row cap created gaps between requests, so an active-request count of zero did not mean a reload had finished	.scratch/performance-overnight/authenticated-reload-cap400.log; .scratch/performance-overnight/authenticated-reload.cjs	corrected harness running; possible existing read/write race queued for a separate reproduction
+2026-10-12T01:47:53Z	authenticated-race	Reject reads that overlap a queued local write and request one fresh reload	The production mock reproduced checked, unchecked, then checked again on both builds when a read overlapped a check-in	.scratch/performance-overnight/authenticated-race-before.json; src/lib/store.tsx	fix implemented; before baseline flicker 69ms and serialized current flicker 170ms; verification pending
+2026-10-12T01:53:18Z	race-verification	Verify the write barrier against the same real production reproduction	The checked state must remain visible while a fresh read catches up with the queued write	.scratch/performance-overnight/authenticated-race-after.json; .scratch/performance-overnight/authenticated-race-after.log; .scratch/performance-overnight/race-check.log; .scratch/performance-overnight/race-build.log	baseline still flickers; current stays checked; 162 tests and production build passed
+2026-10-12T01:53:18Z	pagination	Verify the actual browser query path with a 400-row server cap	The count optimization must retain history when a backend returns fewer rows than requested	.scratch/performance-overnight/authenticated-reload-cap400.json; .scratch/performance-overnight/authenticated-reload-cap400-r2.log	both retain 2500 records; current burst uses eleven requests and five exact counts instead of 220 requests and counts
+2026-10-12T01:58:45Z	offline-verification	Verify offline mutation, undo, warmed tabs, and persisted history on both production builds	The deferred loader and calculation changes must retain local offline use	scripts/benchmark-browser.cjs; .scratch/performance-overnight/offline-browser.json; .scratch/performance-overnight/offline-browser.log	passed; both retain 14600 rows after reconnect and reload
+2026-10-12T02:08:46Z	index-reuse	Use the existing first-record Habit/date index for partner proof and Check-in lookup	Both Array.find calls repeat a history scan whose exact duplicate-first behavior is already indexed	src/lib/store.tsx; src/lib/check-in-index.ts; src/lib/check-in-index.test.ts	implemented without another index or changed selection semantics; full packaging checks pending
+2026-10-12T02:21:30Z	pagination-test	Exercise pagination through the actual Supabase HTTP client without a client type cast	The prior mock reimplemented the method chain and could miss wire-level count behavior	src/lib/duel-sync.test.ts; .scratch/performance-overnight/real-client-pagination.log	Node20 lacks native WebSocket; injected a transport that fails if HTTP-only pagination tries to connect; focused checks running
+2026-10-12T02:25:16Z	count-boundary	Validate finite counts and end unknown-count pagination only on an empty page	The real SDK returns NaN for wildcard totals; short pages may be server caps rather than the end of history	src/lib/duel-sync.ts; src/lib/duel-sync.test.ts; .scratch/performance-overnight/real-client-pagination-r2.log	implemented; unknown-count and missing-header capped-history tests added; focused verification pending
+2026-10-12T02:25:16Z	test-instrument	Use a nonretryable mock page error for the propagation assertion	The SDK retries 503 responses, so counting exactly two calls was a false harness assumption	.scratch/performance-overnight/real-client-pagination-r2.log; src/lib/duel-sync.test.ts	mock changed to400; production retry behavior untouched
+2026-10-12T02:35:09Z	evidence-packaging	Move the canonical trail into the committed evidence directory and retain a local symlink	This unattended change needs a reviewable trail plus reusable scripts and accepted raw measurements	docs/performance/2026-10-12/decisions.tsv; docs/performance/2026-10-12/README.md; scripts/benchmark-browser.cjs; scripts/verify-duel-performance.cjs	one canonical log; accepted evidence copied; early diagnosis artifacts remain local
+2026-10-12T02:42:27Z	packaging	Commit the sync, view-loading, unknown-count, and history work as separate changes on main	Separate commits let reviewers assess and revert each behavior independently	fbc0c76; f8d7837; 0b5db4b; 3862085; .scratch/performance-overnight/packaged-check.log; .scratch/performance-overnight/packaged-build.log	165 tests, lint, typecheck, and production build passed; fresh anonymous and mock servers started
diff --git a/docs/performance/2026-10-12/duel-cap400.json b/docs/performance/2026-10-12/duel-cap400.json
new file mode 100644
index 0000000..5ea9c13
--- /dev/null
+++ b/docs/performance/2026-10-12/duel-cap400.json
@@ -0,0 +1,2778 @@
+{
+  "measuredAt": "2026-10-12T02:01:49.858Z",
+  "pageCap": 400,
+  "method": "Production copies configured only for a Playwright-routed localhost Supabase mock. 2500 CheckIns, 50ms per HTTP response, real Phoenix subscriptions/events, no live database or auth. Counts verify reload amplification, not hosted latency.",
+  "variants": {
+    "baseline": {
+      "initialQueries": [
+        {
+          "phase": "initial",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "initial",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "initial",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "initial",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        }
+      ],
+      "burst": [
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        }
+      ],
+      "during": [
+        {
+          "phase": "during-load",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": true,
+          "rows": 100
+        }
+      ],
+      "writes": [
+        {
+          "table": "duel_check_ins",
+          "method": "POST"
+        },
+        {
+          "table": "duel_check_ins",
+          "method": "DELETE"
+        }
+      ],
+      "errors": [],
+      "localHistoryUntouched": true,
+      "visibleHistory": 2500
+    },
+    "current": {
+      "initialQueries": [
+        {
+          "phase": "initial",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "initial",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "initial",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "initial",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": false,
+          "rows": 100
+        }
+      ],
+      "burst": [
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": false,
+          "rows": 100
+        }
+      ],
+      "during": [
+        {
+          "phase": "during-load",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": false,
+          "rows": 100
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 400,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 800,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1200,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1600,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": false,
+          "rows": 400
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2400,
+          "limit": 1000,
+          "exact": false,
+          "rows": 100
+        }
+      ],
+      "writes": [
+        {
+          "table": "duel_check_ins",
+          "method": "POST"
+        },
+        {
+          "table": "duel_check_ins",
+          "method": "DELETE"
+        }
+      ],
+      "errors": [],
+      "localHistoryUntouched": true,
+      "visibleHistory": 2500
+    }
+  },
+  "browser": "148.0.7778.178"
+}
\ No newline at end of file
diff --git a/docs/performance/2026-10-12/duel-race.json b/docs/performance/2026-10-12/duel-race.json
new file mode 100644
index 0000000..83553c5
--- /dev/null
+++ b/docs/performance/2026-10-12/duel-race.json
@@ -0,0 +1,264 @@
+{
+  "measuredAt": "2026-10-12T02:41:43.860Z",
+  "pageCap": 1000,
+  "method": "Production copies configured only for a Playwright-routed localhost Supabase mock. 2500 CheckIns, 50ms per HTTP response, real Phoenix subscriptions/events, no live database or auth. Counts verify reload amplification, not hosted latency.",
+  "variants": {
+    "baseline": {
+      "queries": [
+        {
+          "phase": "race",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "race",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "race",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "race",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "race",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "race",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "race",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "race",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "race",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "race",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "race",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "race",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 501
+        },
+        {
+          "phase": "race",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "race",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 501
+        }
+      ],
+      "trace": [
+        {
+          "checked": true,
+          "ms": 616.3999999985099
+        },
+        {
+          "checked": false,
+          "ms": 757.1999999955297
+        },
+        {
+          "checked": true,
+          "ms": 823.5
+        }
+      ],
+      "finalChecked": true,
+      "errors": []
+    },
+    "current": {
+      "queries": [
+        {
+          "phase": "race",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "race",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "race",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "race",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "race",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "race",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": false,
+          "rows": 1000
+        },
+        {
+          "phase": "race",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": false,
+          "rows": 501
+        },
+        {
+          "phase": "race",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "race",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "race",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "race",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "race",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "race",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": false,
+          "rows": 1000
+        },
+        {
+          "phase": "race",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": false,
+          "rows": 501
+        }
+      ],
+      "trace": [
+        {
+          "checked": true,
+          "ms": 638.7000000029802
+        }
+      ],
+      "finalChecked": true,
+      "errors": []
+    }
+  },
+  "browser": "148.0.7778.178"
+}
\ No newline at end of file
diff --git a/docs/performance/2026-10-12/duel-reload.json b/docs/performance/2026-10-12/duel-reload.json
new file mode 100644
index 0000000..646369b
--- /dev/null
+++ b/docs/performance/2026-10-12/duel-reload.json
@@ -0,0 +1,1786 @@
+{
+  "measuredAt": "2026-10-12T02:10:42.388Z",
+  "pageCap": 1000,
+  "method": "Production copies configured only for a Playwright-routed localhost Supabase mock. 2500 CheckIns, 50ms per HTTP response, real Phoenix subscriptions/events, no live database or auth. Counts verify reload amplification, not hosted latency.",
+  "variants": {
+    "baseline": {
+      "initialQueries": [
+        {
+          "phase": "initial",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "initial",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "initial",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "initial",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        }
+      ],
+      "burst": [
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        }
+      ],
+      "during": [
+        {
+          "phase": "during-load",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": true,
+          "rows": 500
+        }
+      ],
+      "writes": [
+        {
+          "table": "duel_check_ins",
+          "method": "POST"
+        },
+        {
+          "table": "duel_check_ins",
+          "method": "DELETE"
+        }
+      ],
+      "errors": [],
+      "localHistoryUntouched": true,
+      "visibleHistory": 2500
+    },
+    "current": {
+      "initialQueries": [
+        {
+          "phase": "initial",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "initial",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "initial",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "initial",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": false,
+          "rows": 1000
+        },
+        {
+          "phase": "initial",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": false,
+          "rows": 500
+        }
+      ],
+      "burst": [
+        {
+          "phase": "burst",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": false,
+          "rows": 1000
+        },
+        {
+          "phase": "burst",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": false,
+          "rows": 500
+        }
+      ],
+      "during": [
+        {
+          "phase": "during-load",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": false,
+          "rows": 1000
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": false,
+          "rows": 500
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_habits",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 20
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 1000
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_stakes",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_reactions",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_rest_days",
+          "start": 0,
+          "limit": 1000,
+          "exact": true,
+          "rows": 0
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 1000,
+          "limit": 1000,
+          "exact": false,
+          "rows": 1000
+        },
+        {
+          "phase": "during-load",
+          "table": "duel_check_ins",
+          "start": 2000,
+          "limit": 1000,
+          "exact": false,
+          "rows": 500
+        }
+      ],
+      "writes": [
+        {
+          "table": "duel_check_ins",
+          "method": "POST"
+        },
+        {
+          "table": "duel_check_ins",
+          "method": "DELETE"
+        }
+      ],
+      "errors": [],
+      "localHistoryUntouched": true,
+      "visibleHistory": 2500
+    }
+  },
+  "browser": "148.0.7778.178"
+}
\ No newline at end of file
diff --git a/docs/performance/2026-10-12/first-open-mobile.json b/docs/performance/2026-10-12/first-open-mobile.json
new file mode 100644
index 0000000..bff384b
--- /dev/null
+++ b/docs/performance/2026-10-12/first-open-mobile.json
@@ -0,0 +1,323 @@
+{
+  "measuredAt": "2026-10-12T02:06:25.295Z",
+  "mode": "first-open",
+  "samples": 5,
+  "cpu": 4,
+  "mobile": true,
+  "method": "Production builds, 730 prior days across 20 seeded habits (14600 CheckIns), same Chrome process with isolated contexts. First opens follow document reload with HTTP cache retained. Interactions alternate build order, include one observed localStorage write and two animation frames, and parse its value after timing. CPU throttling simulates slower execution; it is not physical mobile hardware.",
+  "variants": {
+    "baseline": {
+      "samples": [
+        {
+          "feature": "Progress",
+          "ms": 383.29999999701977,
+          "sample": 1
+        },
+        {
+          "feature": "Progress",
+          "ms": 359.3999999985099,
+          "sample": 2
+        },
+        {
+          "feature": "Progress",
+          "ms": 354.09999999403954,
+          "sample": 3
+        },
+        {
+          "feature": "Progress",
+          "ms": 377.29999999701977,
+          "sample": 4
+        },
+        {
+          "feature": "Progress",
+          "ms": 379.5,
+          "sample": 5
+        },
+        {
+          "feature": "Duel",
+          "ms": 377.70000000298023,
+          "sample": 1
+        },
+        {
+          "feature": "Duel",
+          "ms": 370,
+          "sample": 2
+        },
+        {
+          "feature": "Duel",
+          "ms": 360.29999999701977,
+          "sample": 3
+        },
+        {
+          "feature": "Duel",
+          "ms": 336.90000000596046,
+          "sample": 4
+        },
+        {
+          "feature": "Duel",
+          "ms": 340.8999999985099,
+          "sample": 5
+        },
+        {
+          "feature": "Settings",
+          "ms": 359.70000000298023,
+          "sample": 1
+        },
+        {
+          "feature": "Settings",
+          "ms": 354.70000000298023,
+          "sample": 2
+        },
+        {
+          "feature": "Settings",
+          "ms": 353.3999999985099,
+          "sample": 3
+        },
+        {
+          "feature": "Settings",
+          "ms": 362.5,
+          "sample": 4
+        },
+        {
+          "feature": "Settings",
+          "ms": 351.1000000014901,
+          "sample": 5
+        },
+        {
+          "feature": "Activity",
+          "ms": 422.3999999985099,
+          "sample": 1
+        },
+        {
+          "feature": "Activity",
+          "ms": 376,
+          "sample": 2
+        },
+        {
+          "feature": "Activity",
+          "ms": 363.1000000014901,
+          "sample": 3
+        },
+        {
+          "feature": "Activity",
+          "ms": 374.79999999701977,
+          "sample": 4
+        },
+        {
+          "feature": "Activity",
+          "ms": 367.3999999985099,
+          "sample": 5
+        },
+        {
+          "feature": "Proof",
+          "ms": 369.09999999403954,
+          "sample": 1
+        },
+        {
+          "feature": "Proof",
+          "ms": 379.5,
+          "sample": 2
+        },
+        {
+          "feature": "Proof",
+          "ms": 374.90000000596046,
+          "sample": 3
+        },
+        {
+          "feature": "Proof",
+          "ms": 362.19999999552965,
+          "sample": 4
+        },
+        {
+          "feature": "Proof",
+          "ms": 367.79999999701977,
+          "sample": 5
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 342.29999999701977,
+          "sample": 1
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 358.80000000447035,
+          "sample": 2
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 351.79999999701977,
+          "sample": 3
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 342.70000000298023,
+          "sample": 4
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 346.70000000298023,
+          "sample": 5
+        }
+      ],
+      "errors": [],
+      "persistedAfterReload": 14600
+    },
+    "current": {
+      "samples": [
+        {
+          "feature": "Progress",
+          "ms": 176,
+          "sample": 1
+        },
+        {
+          "feature": "Progress",
+          "ms": 141.10000000149012,
+          "sample": 2
+        },
+        {
+          "feature": "Progress",
+          "ms": 139.60000000149012,
+          "sample": 3
+        },
+        {
+          "feature": "Progress",
+          "ms": 130.89999999850988,
+          "sample": 4
+        },
+        {
+          "feature": "Progress",
+          "ms": 126.5,
+          "sample": 5
+        },
+        {
+          "feature": "Duel",
+          "ms": 168.19999999552965,
+          "sample": 1
+        },
+        {
+          "feature": "Duel",
+          "ms": 138,
+          "sample": 2
+        },
+        {
+          "feature": "Duel",
+          "ms": 132.60000000149012,
+          "sample": 3
+        },
+        {
+          "feature": "Duel",
+          "ms": 142.5,
+          "sample": 4
+        },
+        {
+          "feature": "Duel",
+          "ms": 142.29999999701977,
+          "sample": 5
+        },
+        {
+          "feature": "Settings",
+          "ms": 108.79999999701977,
+          "sample": 1
+        },
+        {
+          "feature": "Settings",
+          "ms": 95.80000000447035,
+          "sample": 2
+        },
+        {
+          "feature": "Settings",
+          "ms": 96.29999999701977,
+          "sample": 3
+        },
+        {
+          "feature": "Settings",
+          "ms": 97.09999999403954,
+          "sample": 4
+        },
+        {
+          "feature": "Settings",
+          "ms": 96.60000000149012,
+          "sample": 5
+        },
+        {
+          "feature": "Activity",
+          "ms": 142.19999999552965,
+          "sample": 1
+        },
+        {
+          "feature": "Activity",
+          "ms": 127.29999999701977,
+          "sample": 2
+        },
+        {
+          "feature": "Activity",
+          "ms": 135.69999999552965,
+          "sample": 3
+        },
+        {
+          "feature": "Activity",
+          "ms": 120.10000000149012,
+          "sample": 4
+        },
+        {
+          "feature": "Activity",
+          "ms": 140.69999999552965,
+          "sample": 5
+        },
+        {
+          "feature": "Proof",
+          "ms": 108.10000000149012,
+          "sample": 1
+        },
+        {
+          "feature": "Proof",
+          "ms": 88.5,
+          "sample": 2
+        },
+        {
+          "feature": "Proof",
+          "ms": 85,
+          "sample": 3
+        },
+        {
+          "feature": "Proof",
+          "ms": 85.40000000596046,
+          "sample": 4
+        },
+        {
+          "feature": "Proof",
+          "ms": 89.30000000447035,
+          "sample": 5
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 105.39999999850988,
+          "sample": 1
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 88,
+          "sample": 2
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 85.09999999403954,
+          "sample": 3
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 87.79999999701977,
+          "sample": 4
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 95.79999999701977,
+          "sample": 5
+        }
+      ],
+      "errors": [],
+      "persistedAfterReload": 14600
+    }
+  },
+  "browser": "148.0.7778.178"
+}
\ No newline at end of file
diff --git a/docs/performance/2026-10-12/first-open.json b/docs/performance/2026-10-12/first-open.json
new file mode 100644
index 0000000..aea5236
--- /dev/null
+++ b/docs/performance/2026-10-12/first-open.json
@@ -0,0 +1,323 @@
+{
+  "measuredAt": "2026-10-12T01:58:44.942Z",
+  "mode": "first-open",
+  "samples": 5,
+  "cpu": 1,
+  "mobile": false,
+  "method": "Production builds, 730 prior days across 20 seeded habits (14600 CheckIns), same Chrome process with isolated contexts. First opens follow document reload with HTTP cache retained. Interactions alternate build order, include one observed localStorage write and two animation frames, and parse its value after timing. CPU throttling simulates slower execution; it is not physical mobile hardware.",
+  "variants": {
+    "baseline": {
+      "samples": [
+        {
+          "feature": "Progress",
+          "ms": 334.69999999552965,
+          "sample": 1
+        },
+        {
+          "feature": "Progress",
+          "ms": 326.90000000596046,
+          "sample": 2
+        },
+        {
+          "feature": "Progress",
+          "ms": 337.19999999552965,
+          "sample": 3
+        },
+        {
+          "feature": "Progress",
+          "ms": 331.29999999701977,
+          "sample": 4
+        },
+        {
+          "feature": "Progress",
+          "ms": 326.90000000596046,
+          "sample": 5
+        },
+        {
+          "feature": "Duel",
+          "ms": 326,
+          "sample": 1
+        },
+        {
+          "feature": "Duel",
+          "ms": 331.29999999701977,
+          "sample": 2
+        },
+        {
+          "feature": "Duel",
+          "ms": 331.79999999701977,
+          "sample": 3
+        },
+        {
+          "feature": "Duel",
+          "ms": 329.80000000447035,
+          "sample": 4
+        },
+        {
+          "feature": "Duel",
+          "ms": 337.30000000447035,
+          "sample": 5
+        },
+        {
+          "feature": "Settings",
+          "ms": 335.6000000014901,
+          "sample": 1
+        },
+        {
+          "feature": "Settings",
+          "ms": 334.80000000447035,
+          "sample": 2
+        },
+        {
+          "feature": "Settings",
+          "ms": 331.30000000447035,
+          "sample": 3
+        },
+        {
+          "feature": "Settings",
+          "ms": 335.90000000596046,
+          "sample": 4
+        },
+        {
+          "feature": "Settings",
+          "ms": 334.09999999403954,
+          "sample": 5
+        },
+        {
+          "feature": "Activity",
+          "ms": 356.40000000596046,
+          "sample": 1
+        },
+        {
+          "feature": "Activity",
+          "ms": 327.8999999985099,
+          "sample": 2
+        },
+        {
+          "feature": "Activity",
+          "ms": 333.3999999985099,
+          "sample": 3
+        },
+        {
+          "feature": "Activity",
+          "ms": 334.40000000596046,
+          "sample": 4
+        },
+        {
+          "feature": "Activity",
+          "ms": 331.6000000014901,
+          "sample": 5
+        },
+        {
+          "feature": "Proof",
+          "ms": 350.29999999701977,
+          "sample": 1
+        },
+        {
+          "feature": "Proof",
+          "ms": 350.20000000298023,
+          "sample": 2
+        },
+        {
+          "feature": "Proof",
+          "ms": 348,
+          "sample": 3
+        },
+        {
+          "feature": "Proof",
+          "ms": 374.8999999985099,
+          "sample": 4
+        },
+        {
+          "feature": "Proof",
+          "ms": 346.80000000447035,
+          "sample": 5
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 347.19999999552965,
+          "sample": 1
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 352.8999999985099,
+          "sample": 2
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 369.3999999985099,
+          "sample": 3
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 354.8999999985099,
+          "sample": 4
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 351.70000000298023,
+          "sample": 5
+        }
+      ],
+      "errors": [],
+      "persistedAfterReload": 14600
+    },
+    "current": {
+      "samples": [
+        {
+          "feature": "Progress",
+          "ms": 82.70000000298023,
+          "sample": 1
+        },
+        {
+          "feature": "Progress",
+          "ms": 72.5,
+          "sample": 2
+        },
+        {
+          "feature": "Progress",
+          "ms": 53.600000001490116,
+          "sample": 3
+        },
+        {
+          "feature": "Progress",
+          "ms": 25.700000002980232,
+          "sample": 4
+        },
+        {
+          "feature": "Progress",
+          "ms": 43.400000005960464,
+          "sample": 5
+        },
+        {
+          "feature": "Duel",
+          "ms": 47.19999999552965,
+          "sample": 1
+        },
+        {
+          "feature": "Duel",
+          "ms": 44.80000000447035,
+          "sample": 2
+        },
+        {
+          "feature": "Duel",
+          "ms": 45.20000000298023,
+          "sample": 3
+        },
+        {
+          "feature": "Duel",
+          "ms": 36.19999999552965,
+          "sample": 4
+        },
+        {
+          "feature": "Duel",
+          "ms": 44.29999999701977,
+          "sample": 5
+        },
+        {
+          "feature": "Settings",
+          "ms": 41.29999999701977,
+          "sample": 1
+        },
+        {
+          "feature": "Settings",
+          "ms": 42.79999999701977,
+          "sample": 2
+        },
+        {
+          "feature": "Settings",
+          "ms": 38.5,
+          "sample": 3
+        },
+        {
+          "feature": "Settings",
+          "ms": 42.100000001490116,
+          "sample": 4
+        },
+        {
+          "feature": "Settings",
+          "ms": 40,
+          "sample": 5
+        },
+        {
+          "feature": "Activity",
+          "ms": 41.79999999701977,
+          "sample": 1
+        },
+        {
+          "feature": "Activity",
+          "ms": 39.70000000298023,
+          "sample": 2
+        },
+        {
+          "feature": "Activity",
+          "ms": 40.20000000298023,
+          "sample": 3
+        },
+        {
+          "feature": "Activity",
+          "ms": 43.30000000447035,
+          "sample": 4
+        },
+        {
+          "feature": "Activity",
+          "ms": 38.100000001490116,
+          "sample": 5
+        },
+        {
+          "feature": "Proof",
+          "ms": 38.900000005960464,
+          "sample": 1
+        },
+        {
+          "feature": "Proof",
+          "ms": 39.100000001490116,
+          "sample": 2
+        },
+        {
+          "feature": "Proof",
+          "ms": 44.19999999552965,
+          "sample": 3
+        },
+        {
+          "feature": "Proof",
+          "ms": 36.399999998509884,
+          "sample": 4
+        },
+        {
+          "feature": "Proof",
+          "ms": 42.399999998509884,
+          "sample": 5
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 66.29999999701977,
+          "sample": 1
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 54,
+          "sample": 2
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 31.69999999552965,
+          "sample": 3
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 48.30000000447035,
+          "sample": 4
+        },
+        {
+          "feature": "Shortcuts",
+          "ms": 25.900000005960464,
+          "sample": 5
+        }
+      ],
+      "errors": [],
+      "persistedAfterReload": 14600
+    }
+  },
+  "browser": "148.0.7778.178"
+}
\ No newline at end of file
diff --git a/docs/performance/2026-10-12/interactions.json b/docs/performance/2026-10-12/interactions.json
new file mode 100644
index 0000000..1b06c10
--- /dev/null
+++ b/docs/performance/2026-10-12/interactions.json
@@ -0,0 +1,1171 @@
+{
+  "measuredAt": "2026-10-12T01:37:31.532Z",
+  "method": "Alternating baseline/current pairs in one Chrome process, 14600 local CheckIns, real button click through persisted mutation and two animation frames. No source profiling instrumentation. Mobile is a 390x844 viewport with 4x CDP CPU throttling, not physical hardware.",
+  "scenarios": {
+    "desktop": {
+      "baseline": {
+        "samples": [
+          {
+            "action": "check-in",
+            "ms": 48.600000001490116,
+            "checks": 14601,
+            "points": 40,
+            "sample": 1
+          },
+          {
+            "action": "undo",
+            "ms": 56.100000001490116,
+            "checks": 14600,
+            "points": null,
+            "sample": 1
+          },
+          {
+            "action": "check-in",
+            "ms": 55.20000000298023,
+            "checks": 14601,
+            "points": 40,
+            "sample": 2
+          },
+          {
+            "action": "undo",
+            "ms": 53.899999998509884,
+            "checks": 14600,
+            "points": null,
+            "sample": 2
+          },
+          {
+            "action": "check-in",
+            "ms": 47.899999998509884,
+            "checks": 14601,
+            "points": 40,
+            "sample": 3
+          },
+          {
+            "action": "undo",
+            "ms": 50.80000000447035,
+            "checks": 14600,
+            "points": null,
+            "sample": 3
+          },
+          {
+            "action": "check-in",
+            "ms": 50,
+            "checks": 14601,
+            "points": 40,
+            "sample": 4
+          },
+          {
+            "action": "undo",
+            "ms": 54.5,
+            "checks": 14600,
+            "points": null,
+            "sample": 4
+          },
+          {
+            "action": "check-in",
+            "ms": 53.600000001490116,
+            "checks": 14601,
+            "points": 40,
+            "sample": 5
+          },
+          {
+            "action": "undo",
+            "ms": 54.80000000447035,
+            "checks": 14600,
+            "points": null,
+            "sample": 5
+          },
+          {
+            "action": "check-in",
+            "ms": 48.70000000298023,
+            "checks": 14601,
+            "points": 40,
+            "sample": 6
+          },
+          {
+            "action": "undo",
+            "ms": 52.600000001490116,
+            "checks": 14600,
+            "points": null,
+            "sample": 6
+          },
+          {
+            "action": "check-in",
+            "ms": 46.100000001490116,
+            "checks": 14601,
+            "points": 40,
+            "sample": 7
+          },
+          {
+            "action": "undo",
+            "ms": 50.20000000298023,
+            "checks": 14600,
+            "points": null,
+            "sample": 7
+          },
+          {
+            "action": "check-in",
+            "ms": 52.5,
+            "checks": 14601,
+            "points": 40,
+            "sample": 8
+          },
+          {
+            "action": "undo",
+            "ms": 54.5,
+            "checks": 14600,
+            "points": null,
+            "sample": 8
+          },
+          {
+            "action": "check-in",
+            "ms": 48.5,
+            "checks": 14601,
+            "points": 40,
+            "sample": 9
+          },
+          {
+            "action": "undo",
+            "ms": 48.70000000298023,
+            "checks": 14600,
+            "points": null,
+            "sample": 9
+          },
+          {
+            "action": "check-in",
+            "ms": 44.899999998509884,
+            "checks": 14601,
+            "points": 40,
+            "sample": 10
+          },
+          {
+            "action": "undo",
+            "ms": 50.20000000298023,
+            "checks": 14600,
+            "points": null,
+            "sample": 10
+          },
+          {
+            "action": "check-in",
+            "ms": 50.20000000298023,
+            "checks": 14601,
+            "points": 40,
+            "sample": 11
+          },
+          {
+            "action": "undo",
+            "ms": 52.79999999701977,
+            "checks": 14600,
+            "points": null,
+            "sample": 11
+          },
+          {
+            "action": "check-in",
+            "ms": 53.30000000447035,
+            "checks": 14601,
+            "points": 40,
+            "sample": 12
+          },
+          {
+            "action": "undo",
+            "ms": 53.70000000298023,
+            "checks": 14600,
+            "points": null,
+            "sample": 12
+          },
+          {
+            "action": "check-in",
+            "ms": 44.899999998509884,
+            "checks": 14601,
+            "points": 40,
+            "sample": 13
+          },
+          {
+            "action": "undo",
+            "ms": 50,
+            "checks": 14600,
+            "points": null,
+            "sample": 13
+          },
+          {
+            "action": "check-in",
+            "ms": 53.29999999701977,
+            "checks": 14601,
+            "points": 40,
+            "sample": 14
+          },
+          {
+            "action": "undo",
+            "ms": 54,
+            "checks": 14600,
+            "points": null,
+            "sample": 14
+          },
+          {
+            "action": "check-in",
+            "ms": 44.100000001490116,
+            "checks": 14601,
+            "points": 40,
+            "sample": 15
+          },
+          {
+            "action": "undo",
+            "ms": 48,
+            "checks": 14600,
+            "points": null,
+            "sample": 15
+          },
+          {
+            "action": "check-in",
+            "ms": 46.600000001490116,
+            "checks": 14601,
+            "points": 40,
+            "sample": 16
+          },
+          {
+            "action": "undo",
+            "ms": 53.80000000447035,
+            "checks": 14600,
+            "points": null,
+            "sample": 16
+          },
+          {
+            "action": "check-in",
+            "ms": 45.79999999701977,
+            "checks": 14601,
+            "points": 40,
+            "sample": 17
+          },
+          {
+            "action": "undo",
+            "ms": 55.100000001490116,
+            "checks": 14600,
+            "points": null,
+            "sample": 17
+          },
+          {
+            "action": "check-in",
+            "ms": 47.899999998509884,
+            "checks": 14601,
+            "points": 40,
+            "sample": 18
+          },
+          {
+            "action": "undo",
+            "ms": 49.399999998509884,
+            "checks": 14600,
+            "points": null,
+            "sample": 18
+          },
+          {
+            "action": "check-in",
+            "ms": 44.399999998509884,
+            "checks": 14601,
+            "points": 40,
+            "sample": 19
+          },
+          {
+            "action": "undo",
+            "ms": 48.600000001490116,
+            "checks": 14600,
+            "points": null,
+            "sample": 19
+          },
+          {
+            "action": "check-in",
+            "ms": 54.69999999552965,
+            "checks": 14601,
+            "points": 40,
+            "sample": 20
+          },
+          {
+            "action": "undo",
+            "ms": 55.70000000298023,
+            "checks": 14600,
+            "points": null,
+            "sample": 20
+          }
+        ],
+        "errors": [],
+        "persistedAfterReload": 14600,
+        "overflow": {
+          "width": 1280,
+          "documentWidth": 1280
+        }
+      },
+      "current": {
+        "samples": [
+          {
+            "action": "check-in",
+            "ms": 41.30000000447035,
+            "checks": 14601,
+            "points": 40,
+            "sample": 1
+          },
+          {
+            "action": "undo",
+            "ms": 47.79999999701977,
+            "checks": 14600,
+            "points": null,
+            "sample": 1
+          },
+          {
+            "action": "check-in",
+            "ms": 40.399999998509884,
+            "checks": 14601,
+            "points": 40,
+            "sample": 2
+          },
+          {
+            "action": "undo",
+            "ms": 45.30000000447035,
+            "checks": 14600,
+            "points": null,
+            "sample": 2
+          },
+          {
+            "action": "check-in",
+            "ms": 44,
+            "checks": 14601,
+            "points": 40,
+            "sample": 3
+          },
+          {
+            "action": "undo",
+            "ms": 48.099999994039536,
+            "checks": 14600,
+            "points": null,
+            "sample": 3
+          },
+          {
+            "action": "check-in",
+            "ms": 42.5,
+            "checks": 14601,
+            "points": 40,
+            "sample": 4
+          },
+          {
+            "action": "undo",
+            "ms": 50.29999999701977,
+            "checks": 14600,
+            "points": null,
+            "sample": 4
+          },
+          {
+            "action": "check-in",
+            "ms": 45.100000001490116,
+            "checks": 14601,
+            "points": 40,
+            "sample": 5
+          },
+          {
+            "action": "undo",
+            "ms": 44.5,
+            "checks": 14600,
+            "points": null,
+            "sample": 5
+          },
+          {
+            "action": "check-in",
+            "ms": 38.5,
+            "checks": 14601,
+            "points": 40,
+            "sample": 6
+          },
+          {
+            "action": "undo",
+            "ms": 43.399999998509884,
+            "checks": 14600,
+            "points": null,
+            "sample": 6
+          },
+          {
+            "action": "check-in",
+            "ms": 40.79999999701977,
+            "checks": 14601,
+            "points": 40,
+            "sample": 7
+          },
+          {
+            "action": "undo",
+            "ms": 43.899999998509884,
+            "checks": 14600,
+            "points": null,
+            "sample": 7
+          },
+          {
+            "action": "check-in",
+            "ms": 44.099999994039536,
+            "checks": 14601,
+            "points": 40,
+            "sample": 8
+          },
+          {
+            "action": "undo",
+            "ms": 44.100000001490116,
+            "checks": 14600,
+            "points": null,
+            "sample": 8
+          },
+          {
+            "action": "check-in",
+            "ms": 45.399999998509884,
+            "checks": 14601,
+            "points": 40,
+            "sample": 9
+          },
+          {
+            "action": "undo",
+            "ms": 48.20000000298023,
+            "checks": 14600,
+            "points": null,
+            "sample": 9
+          },
+          {
+            "action": "check-in",
+            "ms": 39,
+            "checks": 14601,
+            "points": 40,
+            "sample": 10
+          },
+          {
+            "action": "undo",
+            "ms": 45.399999998509884,
+            "checks": 14600,
+            "points": null,
+            "sample": 10
+          },
+          {
+            "action": "check-in",
+            "ms": 39.399999998509884,
+            "checks": 14601,
+            "points": 40,
+            "sample": 11
+          },
+          {
+            "action": "undo",
+            "ms": 44.20000000298023,
+            "checks": 14600,
+            "points": null,
+            "sample": 11
+          },
+          {
+            "action": "check-in",
+            "ms": 37.5,
+            "checks": 14601,
+            "points": 40,
+            "sample": 12
+          },
+          {
+            "action": "undo",
+            "ms": 45.099999994039536,
+            "checks": 14600,
+            "points": null,
+            "sample": 12
+          },
+          {
+            "action": "check-in",
+            "ms": 47.70000000298023,
+            "checks": 14601,
+            "points": 40,
+            "sample": 13
+          },
+          {
+            "action": "undo",
+            "ms": 50.399999998509884,
+            "checks": 14600,
+            "points": null,
+            "sample": 13
+          },
+          {
+            "action": "check-in",
+            "ms": 39,
+            "checks": 14601,
+            "points": 40,
+            "sample": 14
+          },
+          {
+            "action": "undo",
+            "ms": 43.600000001490116,
+            "checks": 14600,
+            "points": null,
+            "sample": 14
+          },
+          {
+            "action": "check-in",
+            "ms": 42.5,
+            "checks": 14601,
+            "points": 40,
+            "sample": 15
+          },
+          {
+            "action": "undo",
+            "ms": 42.899999998509884,
+            "checks": 14600,
+            "points": null,
+            "sample": 15
+          },
+          {
+            "action": "check-in",
+            "ms": 41.5,
+            "checks": 14601,
+            "points": 40,
+            "sample": 16
+          },
+          {
+            "action": "undo",
+            "ms": 43.20000000298023,
+            "checks": 14600,
+            "points": null,
+            "sample": 16
+          },
+          {
+            "action": "check-in",
+            "ms": 44.30000000447035,
+            "checks": 14601,
+            "points": 40,
+            "sample": 17
+          },
+          {
+            "action": "undo",
+            "ms": 51,
+            "checks": 14600,
+            "points": null,
+            "sample": 17
+          },
+          {
+            "action": "check-in",
+            "ms": 38.599999994039536,
+            "checks": 14601,
+            "points": 40,
+            "sample": 18
+          },
+          {
+            "action": "undo",
+            "ms": 46,
+            "checks": 14600,
+            "points": null,
+            "sample": 18
+          },
+          {
+            "action": "check-in",
+            "ms": 45.20000000298023,
+            "checks": 14601,
+            "points": 40,
+            "sample": 19
+          },
+          {
+            "action": "undo",
+            "ms": 46.600000001490116,
+            "checks": 14600,
+            "points": null,
+            "sample": 19
+          },
+          {
+            "action": "check-in",
+            "ms": 40.600000001490116,
+            "checks": 14601,
+            "points": 40,
+            "sample": 20
+          },
+          {
+            "action": "undo",
+            "ms": 45.79999999701977,
+            "checks": 14600,
+            "points": null,
+            "sample": 20
+          }
+        ],
+        "errors": [],
+        "persistedAfterReload": 14600,
+        "overflow": {
+          "width": 1280,
+          "documentWidth": 1280
+        }
+      }
+    },
+    "mobile-4x-cpu": {
+      "baseline": {
+        "samples": [
+          {
+            "action": "check-in",
+            "ms": 211.10000000149012,
+            "checks": 14601,
+            "points": 40,
+            "sample": 1
+          },
+          {
+            "action": "undo",
+            "ms": 148.10000000149012,
+            "checks": 14600,
+            "points": null,
+            "sample": 1
+          },
+          {
+            "action": "check-in",
+            "ms": 216.39999999850988,
+            "checks": 14601,
+            "points": 40,
+            "sample": 2
+          },
+          {
+            "action": "undo",
+            "ms": 171,
+            "checks": 14600,
+            "points": null,
+            "sample": 2
+          },
+          {
+            "action": "check-in",
+            "ms": 202.89999999850988,
+            "checks": 14601,
+            "points": 40,
+            "sample": 3
+          },
+          {
+            "action": "undo",
+            "ms": 146.10000000149012,
+            "checks": 14600,
+            "points": null,
+            "sample": 3
+          },
+          {
+            "action": "check-in",
+            "ms": 194.59999999403954,
+            "checks": 14601,
+            "points": 40,
+            "sample": 4
+          },
+          {
+            "action": "undo",
+            "ms": 156.20000000298023,
+            "checks": 14600,
+            "points": null,
+            "sample": 4
+          },
+          {
+            "action": "check-in",
+            "ms": 204.10000000149012,
+            "checks": 14601,
+            "points": 40,
+            "sample": 5
+          },
+          {
+            "action": "undo",
+            "ms": 225,
+            "checks": 14600,
+            "points": null,
+            "sample": 5
+          },
+          {
+            "action": "check-in",
+            "ms": 194.10000000149012,
+            "checks": 14601,
+            "points": 40,
+            "sample": 6
+          },
+          {
+            "action": "undo",
+            "ms": 154.19999999552965,
+            "checks": 14600,
+            "points": null,
+            "sample": 6
+          },
+          {
+            "action": "check-in",
+            "ms": 183.5,
+            "checks": 14601,
+            "points": 40,
+            "sample": 7
+          },
+          {
+            "action": "undo",
+            "ms": 146.69999999552965,
+            "checks": 14600,
+            "points": null,
+            "sample": 7
+          },
+          {
+            "action": "check-in",
+            "ms": 224,
+            "checks": 14601,
+            "points": 40,
+            "sample": 8
+          },
+          {
+            "action": "undo",
+            "ms": 169.29999999701977,
+            "checks": 14600,
+            "points": null,
+            "sample": 8
+          },
+          {
+            "action": "check-in",
+            "ms": 195.39999999850988,
+            "checks": 14601,
+            "points": 40,
+            "sample": 9
+          },
+          {
+            "action": "undo",
+            "ms": 149.69999999552965,
+            "checks": 14600,
+            "points": null,
+            "sample": 9
+          },
+          {
+            "action": "check-in",
+            "ms": 188.60000000149012,
+            "checks": 14601,
+            "points": 40,
+            "sample": 10
+          },
+          {
+            "action": "undo",
+            "ms": 141.20000000298023,
+            "checks": 14600,
+            "points": null,
+            "sample": 10
+          },
+          {
+            "action": "check-in",
+            "ms": 206,
+            "checks": 14601,
+            "points": 40,
+            "sample": 11
+          },
+          {
+            "action": "undo",
+            "ms": 154.70000000298023,
+            "checks": 14600,
+            "points": null,
+            "sample": 11
+          },
+          {
+            "action": "check-in",
+            "ms": 189.10000000149012,
+            "checks": 14601,
+            "points": 40,
+            "sample": 12
+          },
+          {
+            "action": "undo",
+            "ms": 146.29999999701977,
+            "checks": 14600,
+            "points": null,
+            "sample": 12
+          },
+          {
+            "action": "check-in",
+            "ms": 193.5,
+            "checks": 14601,
+            "points": 40,
+            "sample": 13
+          },
+          {
+            "action": "undo",
+            "ms": 147.30000000447035,
+            "checks": 14600,
+            "points": null,
+            "sample": 13
+          },
+          {
+            "action": "check-in",
+            "ms": 200.79999999701977,
+            "checks": 14601,
+            "points": 40,
+            "sample": 14
+          },
+          {
+            "action": "undo",
+            "ms": 156.89999999850988,
+            "checks": 14600,
+            "points": null,
+            "sample": 14
+          },
+          {
+            "action": "check-in",
+            "ms": 184,
+            "checks": 14601,
+            "points": 40,
+            "sample": 15
+          },
+          {
+            "action": "undo",
+            "ms": 149.20000000298023,
+            "checks": 14600,
+            "points": null,
+            "sample": 15
+          },
+          {
+            "action": "check-in",
+            "ms": 197.09999999403954,
+            "checks": 14601,
+            "points": 40,
+            "sample": 16
+          },
+          {
+            "action": "undo",
+            "ms": 142.29999999701977,
+            "checks": 14600,
+            "points": null,
+            "sample": 16
+          },
+          {
+            "action": "check-in",
+            "ms": 202.30000000447035,
+            "checks": 14601,
+            "points": 40,
+            "sample": 17
+          },
+          {
+            "action": "undo",
+            "ms": 153.39999999850988,
+            "checks": 14600,
+            "points": null,
+            "sample": 17
+          },
+          {
+            "action": "check-in",
+            "ms": 191,
+            "checks": 14601,
+            "points": 40,
+            "sample": 18
+          },
+          {
+            "action": "undo",
+            "ms": 150,
+            "checks": 14600,
+            "points": null,
+            "sample": 18
+          },
+          {
+            "action": "check-in",
+            "ms": 185.60000000149012,
+            "checks": 14601,
+            "points": 40,
+            "sample": 19
+          },
+          {
+            "action": "undo",
+            "ms": 148.09999999403954,
+            "checks": 14600,
+            "points": null,
+            "sample": 19
+          },
+          {
+            "action": "check-in",
+            "ms": 205.89999999850988,
+            "checks": 14601,
+            "points": 40,
+            "sample": 20
+          },
+          {
+            "action": "undo",
+            "ms": 160.39999999850988,
+            "checks": 14600,
+            "points": null,
+            "sample": 20
+          }
+        ],
+        "errors": [],
+        "persistedAfterReload": 14600,
+        "overflow": {
+          "width": 390,
+          "documentWidth": 390
+        }
+      },
+      "current": {
+        "samples": [
+          {
+            "action": "check-in",
+            "ms": 181.5,
+            "checks": 14601,
+            "points": 40,
+            "sample": 1
+          },
+          {
+            "action": "undo",
+            "ms": 131,
+            "checks": 14600,
+            "points": null,
+            "sample": 1
+          },
+          {
+            "action": "check-in",
+            "ms": 167.90000000596046,
+            "checks": 14601,
+            "points": 40,
+            "sample": 2
+          },
+          {
+            "action": "undo",
+            "ms": 134.69999999552965,
+            "checks": 14600,
+            "points": null,
+            "sample": 2
+          },
+          {
+            "action": "check-in",
+            "ms": 186.5,
+            "checks": 14601,
+            "points": 40,
+            "sample": 3
+          },
+          {
+            "action": "undo",
+            "ms": 128,
+            "checks": 14600,
+            "points": null,
+            "sample": 3
+          },
+          {
+            "action": "check-in",
+            "ms": 160.20000000298023,
+            "checks": 14601,
+            "points": 40,
+            "sample": 4
+          },
+          {
+            "action": "undo",
+            "ms": 121.69999999552965,
+            "checks": 14600,
+            "points": null,
+            "sample": 4
+          },
+          {
+            "action": "check-in",
+            "ms": 168.10000000149012,
+            "checks": 14601,
+            "points": 40,
+            "sample": 5
+          },
+          {
+            "action": "undo",
+            "ms": 123.80000000447035,
+            "checks": 14600,
+            "points": null,
+            "sample": 5
+          },
+          {
+            "action": "check-in",
+            "ms": 176.69999999552965,
+            "checks": 14601,
+            "points": 40,
+            "sample": 6
+          },
+          {
+            "action": "undo",
+            "ms": 131.39999999850988,
+            "checks": 14600,
+            "points": null,
+            "sample": 6
+          },
+          {
+            "action": "check-in",
+            "ms": 172.69999999552965,
+            "checks": 14601,
+            "points": 40,
+            "sample": 7
+          },
+          {
+            "action": "undo",
+            "ms": 120.90000000596046,
+            "checks": 14600,
+            "points": null,
+            "sample": 7
+          },
+          {
+            "action": "check-in",
+            "ms": 164.20000000298023,
+            "checks": 14601,
+            "points": 40,
+            "sample": 8
+          },
+          {
+            "action": "undo",
+            "ms": 119.19999999552965,
+            "checks": 14600,
+            "points": null,
+            "sample": 8
+          },
+          {
+            "action": "check-in",
+            "ms": 238.89999999850988,
+            "checks": 14601,
+            "points": 40,
+            "sample": 9
+          },
+          {
+            "action": "undo",
+            "ms": 121.19999999552965,
+            "checks": 14600,
+            "points": null,
+            "sample": 9
+          },
+          {
+            "action": "check-in",
+            "ms": 171.69999999552965,
+            "checks": 14601,
+            "points": 40,
+            "sample": 10
+          },
+          {
+            "action": "undo",
+            "ms": 125.70000000298023,
+            "checks": 14600,
+            "points": null,
+            "sample": 10
+          },
+          {
+            "action": "check-in",
+            "ms": 169.19999999552965,
+            "checks": 14601,
+            "points": 40,
+            "sample": 11
+          },
+          {
+            "action": "undo",
+            "ms": 121.79999999701977,
+            "checks": 14600,
+            "points": null,
+            "sample": 11
+          },
+          {
+            "action": "check-in",
+            "ms": 164.39999999850988,
+            "checks": 14601,
+            "points": 40,
+            "sample": 12
+          },
+          {
+            "action": "undo",
+            "ms": 119.60000000149012,
+            "checks": 14600,
+            "points": null,
+            "sample": 12
+          },
+          {
+            "action": "check-in",
+            "ms": 172.29999999701977,
+            "checks": 14601,
+            "points": 40,
+            "sample": 13
+          },
+          {
+            "action": "undo",
+            "ms": 122.40000000596046,
+            "checks": 14600,
+            "points": null,
+            "sample": 13
+          },
+          {
+            "action": "check-in",
+            "ms": 177.29999999701977,
+            "checks": 14601,
+            "points": 40,
+            "sample": 14
+          },
+          {
+            "action": "undo",
+            "ms": 198.60000000149012,
+            "checks": 14600,
+            "points": null,
+            "sample": 14
+          },
+          {
+            "action": "check-in",
+            "ms": 165.5,
+            "checks": 14601,
+            "points": 40,
+            "sample": 15
+          },
+          {
+            "action": "undo",
+            "ms": 124.10000000149012,
+            "checks": 14600,
+            "points": null,
+            "sample": 15
+          },
+          {
+            "action": "check-in",
+            "ms": 161.39999999850988,
+            "checks": 14601,
+            "points": 40,
+            "sample": 16
+          },
+          {
+            "action": "undo",
+            "ms": 121.29999999701977,
+            "checks": 14600,
+            "points": null,
+            "sample": 16
+          },
+          {
+            "action": "check-in",
+            "ms": 177.5,
+            "checks": 14601,
+            "points": 40,
+            "sample": 17
+          },
+          {
+            "action": "undo",
+            "ms": 121,
+            "checks": 14600,
+            "points": null,
+            "sample": 17
+          },
+          {
+            "action": "check-in",
+            "ms": 193,
+            "checks": 14601,
+            "points": 40,
+            "sample": 18
+          },
+          {
+            "action": "undo",
+            "ms": 138,
+            "checks": 14600,
+            "points": null,
+            "sample": 18
+          },
+          {
+            "action": "check-in",
+            "ms": 178.69999999552965,
+            "checks": 14601,
+            "points": 40,
+            "sample": 19
+          },
+          {
+            "action": "undo",
+            "ms": 126.5,
+            "checks": 14600,
+            "points": null,
+            "sample": 19
+          },
+          {
+            "action": "check-in",
+            "ms": 168.39999999850988,
+            "checks": 14601,
+            "points": 40,
+            "sample": 20
+          },
+          {
+            "action": "undo",
+            "ms": 117.19999999552965,
+            "checks": 14600,
+            "points": null,
+            "sample": 20
+          }
+        ],
+        "errors": [],
+        "persistedAfterReload": 14600,
+        "overflow": {
+          "width": 390,
+          "documentWidth": 390
+        }
+      }
+    }
+  },
+  "browser": "148.0.7778.178"
+}
\ No newline at end of file
diff --git a/docs/performance/2026-10-12/offline.json b/docs/performance/2026-10-12/offline.json
new file mode 100644
index 0000000..fce2866
--- /dev/null
+++ b/docs/performance/2026-10-12/offline.json
@@ -0,0 +1,37 @@
+{
+  "measuredAt": "2026-10-12T01:56:12.353Z",
+  "mode": "offline",
+  "samples": 5,
+  "cpu": 1,
+  "mobile": false,
+  "method": "Production builds, 730 prior days across 20 seeded habits (14600 CheckIns), same Chrome process with isolated contexts. First opens follow document reload with HTTP cache retained. Interactions alternate build order, include one observed localStorage write and two animation frames, and parse its value after timing. CPU throttling simulates slower execution; it is not physical mobile hardware.",
+  "variants": {
+    "baseline": {
+      "samples": [],
+      "errors": [],
+      "offline": {
+        "localMutationAndUndo": true,
+        "warmedViews": [
+          "Progress",
+          "Duel",
+          "Settings"
+        ]
+      },
+      "persistedAfterReload": 14600
+    },
+    "current": {
+      "samples": [],
+      "errors": [],
+      "offline": {
+        "localMutationAndUndo": true,
+        "warmedViews": [
+          "Progress",
+          "Duel",
+          "Settings"
+        ]
+      },
+      "persistedAfterReload": 14600
+    }
+  },
+  "browser": "148.0.7778.178"
+}
\ No newline at end of file
diff --git a/scripts/benchmark-browser.cjs b/scripts/benchmark-browser.cjs
new file mode 100644
index 0000000..deacf0e
--- /dev/null
+++ b/scripts/benchmark-browser.cjs
@@ -0,0 +1,188 @@
+const { chromium } = require('playwright');
+const { parseArgs } = require('node:util');
+const fs = require('node:fs');
+const path = require('node:path');
+const assert = require('node:assert/strict');
+
+const { values } = parseArgs({ options: {
+  baseline: { type: 'string', default: 'http://localhost:43127/' },
+  current: { type: 'string', default: 'http://localhost:43130/' },
+  mode: { type: 'string', default: 'first-open' },
+  samples: { type: 'string', default: '5' },
+  output: { type: 'string', default: '.scratch/browser-performance.json' },
+  chrome: { type: 'string' },
+  mobile: { type: 'boolean', default: false },
+  cpu: { type: 'string', default: '1' },
+} });
+assert.ok(['first-open', 'interactions', 'offline'].includes(values.mode));
+const samples = Number(values.samples);
+const cpu = Number(values.cpu);
+assert.ok(Number.isInteger(samples) && samples > 0);
+assert.ok(Number.isFinite(cpu) && cpu >= 1);
+const output = path.resolve(values.output);
+fs.mkdirSync(path.dirname(output), { recursive: true });
+const results = { measuredAt: new Date().toISOString(), mode: values.mode, samples, cpu, mobile: values.mobile,
+  method: 'Production builds, 730 prior days across 20 seeded habits (14600 CheckIns), same Chrome process with isolated contexts. First opens follow document reload with HTTP cache retained. Interactions alternate build order, include one observed localStorage write and two animation frames, and parse its value after timing. CPU throttling simulates slower execution; it is not physical mobile hardware.', variants: {} };
+
+async function seed(page) {
+  await page.getByRole('dialog', { name: 'Select Profile' }).waitFor();
+  await page.evaluate(() => {
+    const state = JSON.parse(localStorage.getItem('do_it_app_data_v2'));
+    const today = new Date();
+    state.checkIns = [];
+    for (let day = 1; day <= 730; day++) {
+      const d = new Date(today); d.setDate(d.getDate() - day);
+      const date = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+      for (const h of state.habits) state.checkIns.push({ id: `${h.id}-${date}`, habitId: h.id, playerId: h.playerId, date,
+        pointsEarned: h.points, completedAt: `${date}T12:00:00Z`, ...(h.isQuantitative ? { quantity: h.maxQuantity } : {}) });
+    }
+    state.activePlayerId = 'maciek'; state.soundEnabled = false;
+    localStorage.setItem('do_it_sound_enabled', 'false');
+    localStorage.setItem('do_it_app_data_v2', JSON.stringify(state));
+  });
+  await page.reload();
+  await page.getByText('Daily Ritual', { exact: true }).waitFor();
+  await page.evaluate(() => new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve))));
+}
+
+async function openFeature(page, feature) {
+  return page.evaluate(async ({ feature, mobile }) => {
+    const start = performance.now();
+    if (feature === 'Shortcuts') window.dispatchEvent(new KeyboardEvent('keydown', { key: '?', bubbles: true }));
+    else {
+      const button = feature === 'Settings' ? document.querySelector('button[aria-label="Open profile and settings"]')
+        : feature === 'Proof' ? document.querySelector('button[aria-label="Mark Clean Space completed"]')
+        : feature === 'Activity' ? Array.from(document.querySelectorAll('button')).find(b => b.innerText === 'Activity')
+        : Array.from(document.querySelectorAll(mobile ? 'nav[aria-label="Main navigation"] button' : 'aside button')).find(b => b.innerText.includes(feature));
+      if (!button) throw new Error('Missing trigger ' + feature);
+      button.click();
+    }
+    const ready = () => feature === 'Duel' ? document.body.innerText.includes('WEEKLY WAGER')
+      : feature === 'Activity' ? document.body.innerText.includes('The timeline')
+      : feature === 'Proof' ? Boolean(document.querySelector('#proof-modal-title'))
+      : feature === 'Shortcuts' ? Boolean(document.querySelector('#shortcuts-modal-title'))
+      : document.querySelector('h1')?.innerText === feature;
+    await new Promise((resolve, reject) => {
+      const deadline = performance.now() + 10000;
+      function check() {
+        if (ready()) resolve();
+        else if (performance.now() > deadline) reject(new Error('Content timeout ' + feature));
+        else setTimeout(check, 5);
+      }
+      check();
+    });
+    await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+    return { feature, ms: performance.now() - start };
+  }, { feature, mobile: values.mobile });
+}
+
+async function checkIn(page, undo) {
+  return page.evaluate(async undo => {
+    const label = undo ? 'Mark Gym & Strength uncompleted for today' : 'Mark Gym & Strength completed';
+    const button = document.querySelector(`button[aria-label="${label}"]`);
+    if (!button) throw new Error('Missing action ' + label);
+    const original = Storage.prototype.setItem;
+    let timeout;
+    const persisted = new Promise((resolve, reject) => {
+      timeout = setTimeout(() => reject(new Error('Persistence timeout')), 10000);
+      Storage.prototype.setItem = function(key, value) {
+        original.call(this, key, value);
+        if (this === localStorage && key === 'do_it_app_data_v2') resolve(value);
+      };
+    });
+    const start = performance.now();
+    let saved;
+    try {
+      button.click();
+      saved = await persisted;
+      await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+    } finally {
+      Storage.prototype.setItem = original;
+      clearTimeout(timeout);
+    }
+    const elapsed = performance.now() - start;
+    const state = JSON.parse(saved);
+    const d = new Date();
+    const today = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+    const entry = state.checkIns.find(c => c.habitId === 'maciek-gym' && c.date === today);
+    return { action: undo ? 'undo' : 'check-in', ms: elapsed, checks: state.checkIns.length, points: entry?.pointsEarned ?? null };
+  }, undo);
+}
+
+async function pair(page) {
+  const checked = await checkIn(page, false);
+  assert.equal(checked.checks, 14601); assert.equal(checked.points, 40);
+  const undone = await checkIn(page, true);
+  assert.equal(undone.checks, 14600); assert.equal(undone.points, null);
+  return [checked, undone];
+}
+
+async function offline(variant) {
+  const { context, page } = variant;
+  for (const feature of ['Progress', 'Duel', 'Settings']) {
+    await page.goto(variant.url); await page.getByText('Daily Ritual', { exact: true }).waitFor();
+    await openFeature(page, feature);
+  }
+  await page.goto(variant.url); await page.getByText('Daily Ritual', { exact: true }).waitFor();
+  await context.setOffline(true);
+  try {
+    assert.equal(await page.evaluate(() => navigator.onLine), false);
+    await pair(page);
+    await openFeature(page, 'Progress');
+    const today = page.getByRole('button', { name: values.mobile ? 'Today' : 'Today 1', exact: true });
+    await today.click();
+    await page.getByText('Daily Ritual', { exact: true }).waitFor();
+    await openFeature(page, 'Duel');
+    await today.click();
+    await page.getByText('Daily Ritual', { exact: true }).waitFor();
+    await openFeature(page, 'Settings');
+    assert.equal(await page.getByRole('heading', { name: 'Settings', exact: true }).isVisible(), true);
+    return { localMutationAndUndo: true, warmedViews: ['Progress', 'Duel', 'Settings'] };
+  } finally { await context.setOffline(false); }
+}
+
+(async () => {
+  const browser = await chromium.launch({ headless: true, ...(values.chrome ? { executablePath: values.chrome } : {}) });
+  results.browser = browser.version();
+  const live = {};
+  try {
+    for (const [name, url] of [['baseline', values.baseline], ['current', values.current]]) {
+      const context = await browser.newContext({ viewport: values.mobile ? { width: 390, height: 844 } : { width: 1280, height: 800 }, timezoneId: 'Europe/London', reducedMotion: 'reduce' });
+      const page = await context.newPage();
+      const cdp = await context.newCDPSession(page);
+      await cdp.send('Emulation.setCPUThrottlingRate', { rate: cpu });
+      const errors = []; page.on('pageerror', error => errors.push(error.message));
+      await page.goto(url); await seed(page);
+      live[name] = { context, page, url };
+      results.variants[name] = { samples: [], errors };
+      if (values.mode === 'interactions') { await pair(page); await page.waitForTimeout(650); }
+    }
+    if (values.mode === 'interactions') {
+      for (let sample = 1; sample <= samples; sample++) {
+        for (const name of (sample % 2 ? ['baseline', 'current'] : ['current', 'baseline'])) {
+          results.variants[name].samples.push(...(await pair(live[name].page)).map(row => ({ ...row, sample })));
+        }
+        await live.current.page.waitForTimeout(550);
+      }
+    } else {
+      for (const [name, variant] of Object.entries(live)) {
+        if (values.mode === 'offline') results.variants[name].offline = await offline(variant);
+        else for (const feature of ['Progress', 'Duel', 'Settings', 'Activity', 'Proof', 'Shortcuts']) {
+          for (let sample = 1; sample <= samples; sample++) {
+            await variant.page.goto(variant.url); await variant.page.getByText('Daily Ritual', { exact: true }).waitFor();
+            results.variants[name].samples.push({ ...await openFeature(variant.page, feature), sample });
+          }
+        }
+      }
+    }
+    for (const [name, variant] of Object.entries(live)) {
+      await variant.page.goto(variant.url); await variant.page.getByText('Daily Ritual', { exact: true }).waitFor();
+      const checkCount = await variant.page.evaluate(() => JSON.parse(localStorage.getItem('do_it_app_data_v2')).checkIns.length);
+      assert.equal(checkCount, 14600);
+      assert.deepEqual(results.variants[name].errors, []);
+      results.variants[name].persistedAfterReload = checkCount;
+    }
+  } catch (error) { results.failure = error.message; throw error; }
+  finally { fs.writeFileSync(output, JSON.stringify(results, null, 2)); await browser.close(); }
+  console.log(JSON.stringify({ output, passed: true }));
+})().catch(error => { console.error(error); process.exitCode = 1; });
diff --git a/scripts/verify-duel-performance.cjs b/scripts/verify-duel-performance.cjs
new file mode 100644
index 0000000..1bc5d29
--- /dev/null
+++ b/scripts/verify-duel-performance.cjs
@@ -0,0 +1,219 @@
+const { chromium } = require('playwright');
+const fs = require('node:fs');
+const path = require('node:path');
+const assert = require('node:assert/strict');
+const { parseArgs } = require('node:util');
+const { values } = parseArgs({ options: {
+  baseline: { type: 'string', default: 'http://localhost:43131/' },
+  current: { type: 'string', default: 'http://localhost:43132/' },
+  output: { type: 'string', default: '.scratch/duel-performance.json' },
+  chrome: { type: 'string' },
+  'page-cap': { type: 'string', default: '1000' },
+  race: { type: 'boolean', default: false },
+} });
+const resultPath = path.resolve(values.output);
+const root = path.dirname(resultPath);
+fs.mkdirSync(root, { recursive: true });
+const pageCap = Number(values['page-cap']);
+assert.ok(Number.isInteger(pageCap) && pageCap > 0);
+const raceOnly = values.race;
+
+const initial = require(path.resolve('.scratch/test-build/seed.js')).getInitialState();
+const owner = '11111111-1111-4111-8111-111111111111';
+const guest = '22222222-2222-4222-8222-222222222222';
+const duelId = '33333333-3333-4333-8333-333333333333';
+const user = { id: owner, email: 'performance-owner@local.test', aud: 'authenticated', role: 'authenticated', app_metadata: {}, user_metadata: {}, created_at: '2026-01-01T00:00:00Z' };
+const duel = { id: duelId, owner_id: owner, guest_id: guest, owner_name: 'Perf Owner', guest_name: 'Perf Guest', owner_color: 'blue', guest_color: 'purple', invite_code: '44444444-4444-4444-8444-444444444444' };
+const results = { measuredAt: new Date().toISOString(), pageCap, method: 'Production copies configured only for a Playwright-routed localhost Supabase mock. 2500 CheckIns, 50ms per HTTP response, real Phoenix subscriptions/events, no live database or auth. Counts verify reload amplification, not hosted latency.', variants: {} };
+
+function makeRows() {
+  const checks = [];
+  const today = new Date();
+  for (let day = 1; day <= 125; day++) {
+    const d = new Date(today); d.setDate(d.getDate() - day);
+    const date = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+    for (const h of initial.habits) checks.push({ id: `${h.id}-${date}`, habitId: h.id, playerId: h.playerId, date, pointsEarned: h.points, completedAt: `${date}T12:00:00Z` });
+  }
+  return { duel_habits: initial.habits, duel_check_ins: checks, duel_stakes: [], duel_reactions: [], duel_rest_days: [] };
+}
+
+async function until(page, predicate, label) {
+  const end = Date.now() + 10000;
+  while (!predicate()) {
+    if (Date.now() > end) throw new Error('Timeout ' + label);
+    await page.waitForTimeout(10);
+  }
+}
+
+async function verify(browser, name, url) {
+  const context = await browser.newContext({ timezoneId: 'Europe/London', reducedMotion: 'reduce' });
+  const page = await context.newPage();
+  const rows = makeRows();
+  const queries = [];
+  const writes = [];
+  const subscriptions = [];
+  const errors = [];
+  let phase = 'initial';
+  let active = 0;
+  let lastQueryAt = 0;
+  page.on('pageerror', error => errors.push(error.message));
+  await page.addInitScript(({ user, token }) => {
+    localStorage.setItem('sb-127-auth-token', JSON.stringify({ access_token: token, refresh_token: 'local-mock-refresh', token_type: 'bearer', expires_in: 86400, expires_at: Math.floor(Date.now()/1000)+86400, user }));
+    localStorage.setItem('do_it_sound_enabled', 'false');
+    localStorage.setItem('do_it_app_data_v2', 'local-history-sentinel');
+  }, { user, token: 'eyJhbGciOiJub25lIn0.' + Buffer.from(JSON.stringify({ sub: owner, exp: Math.floor(Date.now()/1000)+86400, role: 'authenticated' })).toString('base64url') + '.local-mock' });
+
+  await page.route('http://127.0.0.1:54321/**', async route => {
+    const request = route.request();
+    const url = new URL(request.url());
+    const table = url.pathname.split('/').pop();
+    const headers = { 'content-type': 'application/json', 'access-control-allow-origin': '*', 'access-control-expose-headers': 'content-range' };
+    if (table === 'duels') return route.fulfill({ status: 200, headers, body: JSON.stringify([duel]) });
+    if (url.pathname === '/auth/v1/user') return route.fulfill({ status: 200, headers, body: JSON.stringify(user) });
+    if (!(table in rows)) throw new Error('Unexpected mock request ' + url.pathname);
+    if (request.method() === 'POST') {
+      const body = request.postDataJSON();
+      for (const row of Array.isArray(body) ? body : [body]) {
+        assert.equal(row.duel_id, duelId);
+        const index = rows[table].findIndex(entry => entry.id === row.id);
+        if (index === -1) rows[table].push(row.data); else rows[table][index] = row.data;
+        writes.push({ table, method: 'POST', row });
+      }
+      return route.fulfill({ status: 201, headers, body: '' });
+    }
+    assert.equal(url.searchParams.get('duel_id'), 'eq.' + duelId);
+    if (request.method() === 'DELETE') {
+      const id = url.searchParams.get('id').slice(3);
+      rows[table] = rows[table].filter(entry => entry.id !== id);
+      writes.push({ table, method: 'DELETE', id });
+      return route.fulfill({ status: 204, headers, body: '' });
+    }
+    assert.equal(request.method(), 'GET');
+    assert.equal(url.searchParams.get('select'), 'data');
+    assert.equal(url.searchParams.get('order'), 'id.asc');
+    const start = Number(url.searchParams.get('offset') || 0);
+    const limit = Number(url.searchParams.get('limit') || 1000);
+    const sorted = [...rows[table]].sort((a,b) => a.id.localeCompare(b.id));
+    const selected = sorted.slice(start, start + Math.min(limit, pageCap)).map(data => ({ data }));
+    const exact = request.headers().prefer?.includes('count=exact') ?? false;
+    queries.push({ phase, table, start, limit, exact, rows: selected.length });
+    lastQueryAt = Date.now();
+    active++;
+    try {
+      await new Promise(resolve => setTimeout(resolve, 50));
+      headers['content-range'] = `${start}-${Math.max(start, start + selected.length - 1)}/${exact ? sorted.length : '*'}`;
+      await route.fulfill({ status: 200, headers, body: JSON.stringify(selected) });
+    } finally { active--; }
+  });
+
+  await page.routeWebSocket('ws://127.0.0.1:54321/**', socket => {
+    socket.onMessage(raw => {
+      const [joinRef, ref, topic, event, payload] = JSON.parse(String(raw));
+      if (event === 'phx_join') {
+        const filters = (payload.config?.postgres_changes ?? []).map((filter, index) => ({ ...filter, id: index + 1 }));
+        subscriptions.push({ socket, topic, joinRef, filters });
+        socket.send(JSON.stringify([joinRef, ref, topic, 'phx_reply', { status: 'ok', response: { postgres_changes: filters } }]));
+      } else if (event === 'heartbeat' || event === 'phx_leave') {
+        socket.send(JSON.stringify([joinRef, ref, topic, 'phx_reply', { status: 'ok', response: {} }]));
+      }
+    });
+  });
+
+  function notify(count) {
+    const subscription = subscriptions.find(entry => entry.topic === 'realtime:duel-' + duelId);
+    assert.ok(subscription, 'Duel subscription must exist');
+    const filter = subscription.filters.find(entry => entry.table === 'duel_check_ins');
+    assert.ok(filter);
+    for (let i = 0; i < count; i++) {
+      subscription.socket.send(JSON.stringify([subscription.joinRef, null, subscription.topic, 'postgres_changes', { ids: [filter.id], data: { schema: 'public', table: 'duel_check_ins', commit_timestamp: new Date().toISOString(), type: 'UPDATE', errors: [], columns: [], record: {}, old_record: {} } }]));
+    }
+  }
+
+  try {
+    await page.goto(url);
+    await page.getByText('Daily Ritual', { exact: true }).waitFor();
+    await until(page, () => active === 0 && Date.now() - lastQueryAt > 250 && subscriptions.some(s => s.topic === 'realtime:duel-' + duelId), 'initial load');
+    const initialQueries = queries.filter(q => q.phase === 'initial');
+    const checkPages = Math.ceil(2500 / pageCap);
+    assert.equal(initialQueries.filter(q => q.table === 'duel_check_ins').length, checkPages);
+    assert.equal(initialQueries.filter(q => q.exact).length, name === 'current' ? 5 : checkPages + 4);
+    assert.equal(await page.evaluate(() => localStorage.getItem('do_it_app_data_v2')), 'local-history-sentinel');
+
+    if (raceOnly) {
+      phase = 'race';
+      await page.evaluate(() => {
+        window.raceTrace = [];
+        let checkedBefore = false;
+        let last;
+        window.raceObserver = new MutationObserver(() => {
+          const checked = Boolean(document.querySelector('button[aria-label="Mark Gym & Strength uncompleted for today"]'));
+          if (checked) checkedBefore = true;
+          if (checkedBefore && checked !== last) window.raceTrace.push({ checked, ms: performance.now() });
+          last = checked;
+        });
+        window.raceObserver.observe(document.body, { subtree: true, childList: true, attributes: true });
+      });
+      notify(1);
+      await until(page, () => queries.some(q => q.phase === 'race'), 'race read starts');
+      await page.getByRole('button', { name: 'Mark Gym & Strength completed', exact: true }).click();
+      await until(page, () => writes.some(w => w.method === 'POST'), 'race write');
+      notify(1);
+      await until(page, () => active === 0 && Date.now() - lastQueryAt > 250, 'race quiescence');
+      const trace = await page.evaluate(() => { window.raceObserver.disconnect(); return window.raceTrace; });
+      assert.equal(rows.duel_check_ins.length, 2501);
+      const finalChecked = await page.getByRole('button', { name: 'Mark Gym & Strength uncompleted for today', exact: true }).count() === 1;
+      assert.equal(finalChecked, true);
+      assert.equal(trace.some(entry => !entry.checked), name === 'baseline');
+      assert.deepEqual(errors, []);
+      return { queries: queries.filter(q => q.phase === 'race'), trace, finalChecked, errors };
+    }
+
+    phase = 'burst';
+    notify(20);
+    await until(page, () => queries.some(q => q.phase === 'burst'), 'burst first request');
+    await until(page, () => active === 0 && Date.now() - lastQueryAt > 250, 'burst completion');
+    const burst = queries.filter(q => q.phase === 'burst');
+    assert.equal(burst.filter(q => q.table === 'duel_check_ins' && q.start === 0).length, name === 'current' ? 1 : 20);
+    assert.equal(burst.filter(q => q.exact).length, name === 'current' ? 5 : 20 * (checkPages + 4));
+
+    phase = 'during-load';
+    notify(1);
+    await until(page, () => queries.some(q => q.phase === 'during-load'), 'follow-up first request');
+    notify(5);
+    await until(page, () => queries.filter(q => q.phase === 'during-load' && q.table === 'duel_check_ins' && q.start === 0).length >= 2, 'follow-up request');
+    await until(page, () => active === 0 && Date.now() - lastQueryAt > 250, 'follow-up completion');
+    const during = queries.filter(q => q.phase === 'during-load');
+    assert.equal(during.filter(q => q.table === 'duel_check_ins' && q.start === 0).length, name === 'current' ? 2 : 6);
+
+    phase = 'mutation';
+    await page.getByRole('button', { name: 'Mark Gym & Strength completed', exact: true }).click();
+    await until(page, () => writes.some(w => w.method === 'POST'), 'check-in write');
+    const entry = rows.duel_check_ins.find(c => c.habitId === 'maciek-gym' && c.date === new Date().toLocaleDateString('en-CA'));
+    assert.equal(entry?.pointsEarned, 40);
+    await page.getByRole('button', { name: 'Mark Gym & Strength uncompleted for today', exact: true }).click();
+    await until(page, () => writes.some(w => w.method === 'DELETE'), 'undo write');
+    assert.equal(rows.duel_check_ins.length, 2500);
+    assert.equal(await page.evaluate(() => localStorage.getItem('do_it_app_data_v2')), 'local-history-sentinel');
+
+    fs.writeFileSync(path.join(root, `authenticated-${name}-before-activity.txt`), await page.locator('body').innerText());
+    await page.screenshot({ path: path.join(root, `authenticated-${name}-before-activity.png`), fullPage: true });
+    await page.getByRole('tab', { name: 'Activity', exact: true }).click({ timeout: 5000 });
+    await page.waitForFunction(() => document.body.innerText.includes('The timeline'), null, { timeout: 5000 });
+    assert.equal(await page.getByText('2500', { exact: true }).count() > 0, true);
+    assert.deepEqual(errors, []);
+    return { initialQueries, burst, during, writes: writes.map(w => ({ table: w.table, method: w.method })), errors, localHistoryUntouched: true, visibleHistory: 2500 };
+  } finally { await context.close(); }
+}
+
+(async () => {
+  const browser = await chromium.launch({ headless: true, ...(values.chrome ? { executablePath: values.chrome } : {}) });
+  results.browser = browser.version();
+  try {
+    for (const [name, url] of [['baseline', values.baseline], ['current', values.current]]) {
+      results.variants[name] = await verify(browser, name, url);
+      console.log(JSON.stringify({ name, passed: true }));
+      fs.writeFileSync(resultPath, JSON.stringify(results, null, 2));
+    }
+  } catch (error) { results.failure = error.message; throw error; }
+  finally { fs.writeFileSync(resultPath, JSON.stringify(results, null, 2)); await browser.close(); }
+})().catch(error => { console.error(error); process.exitCode = 1; });

From f2dab2714efea0ccb4acc3bfce98f2316a749540 Mon Sep 17 00:00:00 2001
From: Maseeek <maseeekyt@gmail.com>
Date: Mon, 12 Oct 2026 03:57:27 +0100
Subject: [PATCH 06/10] chore(review): collapse generated performance
 measurements

Mark raw benchmark JSON as generated so GitHub keeps the implementation and decision trail visible during review. The complete measurements remain available for download and reproduction.
---
 .gitattributes | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 .gitattributes

diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..c835f4b
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1 @@
+docs/performance/**/*.json linguist-generated=true

From 400fbfe75463b19740352dff92782f235431423a Mon Sep 17 00:00:00 2001
From: Maseeek <maseeekyt@gmail.com>
Date: Mon, 12 Oct 2026 04:40:03 +0100
Subject: [PATCH 07/10] perf(entry): render account and onboarding screens
 promptly

Use the guarded deferred-view resource for the remaining account and
first-run onboarding loaders. The same production probes remove about
300 ms from each flow while keeping their components and props intact.

Add a reusable entry benchmark and verify signup/sign-in switching and
saving the first habit plan against the local mock. Record corrected
browser-local timing, raw measurements, CI status, and preview limits.

Refs #63.
---
 .gitignore                                    |   1 +
 docs/performance.md                           |   2 +
 docs/performance/2026-10-12/README.md         |   4 +
 docs/performance/2026-10-12/decisions.tsv     |   6 +
 .../2026-10-12/entry-performance.json         | 118 ++++++++++++++++++
 scripts/verify-entry-performance.cjs          | 118 ++++++++++++++++++
 src/app/page.tsx                              |   4 +-
 7 files changed, 251 insertions(+), 2 deletions(-)
 create mode 100644 docs/performance/2026-10-12/entry-performance.json
 create mode 100644 scripts/verify-entry-performance.cjs

diff --git a/.gitignore b/.gitignore
index 109df9e..520b407 100644
--- a/.gitignore
+++ b/.gitignore
@@ -47,6 +47,7 @@ agent-audit-report.json
 !/scripts/benchmark-performance.ts
 !/scripts/benchmark-browser.cjs
 !/scripts/verify-duel-performance.cjs
+!/scripts/verify-entry-performance.cjs
 # scratch & local cache
 /.scratch/
 supabase/.temp/
diff --git a/docs/performance.md b/docs/performance.md
index 76d6913..4266a32 100644
--- a/docs/performance.md
+++ b/docs/performance.md
@@ -6,6 +6,8 @@ Compared production builds against `e7b284e` with Chrome 148 on the same machine
 
 The first open of a deferred view waited about 300 ms after its JavaScript was available. The installed React DOM production runtime throttles Suspense fallback replacement. Deferred views now use a guarded import resource and stable external-store snapshots, keeping the deployment check before activation. Tab and Settings imports also warm on pointer entry or keyboard focus. The initial page still loads its existing frame and Today view.
 
+The same loader also removes the remaining delay from default account entry and first-run onboarding. With a browser-local heading probe after document navigation, account entry falls from 379.7 to 80.6 ms and onboarding from 496.9 to 197.1 ms (five samples per flow, mock requests at 50 ms). Signup/sign-in switching and saving a first habit plan pass. The original locator-based timing was superseded because retry polling added a fixed delay to the observation.
+
 First-open medians, five samples per view, document reload before every sample, HTTP cache retained, and two animation frames after content becomes ready:
 
 | View | Before | After |
diff --git a/docs/performance/2026-10-12/README.md b/docs/performance/2026-10-12/README.md
index 2a4f5c4..8ca9d41 100644
--- a/docs/performance/2026-10-12/README.md
+++ b/docs/performance/2026-10-12/README.md
@@ -40,10 +40,13 @@ npm test
 NODE_PATH="$PWD/.scratch/browser-tools/node_modules" node scripts/verify-duel-performance.cjs --page-cap 1000 --output .scratch/duel-reload.json
 NODE_PATH="$PWD/.scratch/browser-tools/node_modules" node scripts/verify-duel-performance.cjs --page-cap 400 --output .scratch/duel-cap400.json
 NODE_PATH="$PWD/.scratch/browser-tools/node_modules" node scripts/verify-duel-performance.cjs --race --output .scratch/duel-race.json
+NODE_PATH="$PWD/.scratch/browser-tools/node_modules" node scripts/verify-entry-performance.cjs --smoke --output .scratch/entry-performance.json
 ```
 
 The reload checks assert full history, counts, filtered queries, twenty-event bursts, one follow-up for events during loading, actual Check-in/undo writes, and unchanged local history. The race check observes the Habit button while a read overlaps a local write: the baseline becomes unchecked temporarily; the current build remains checked. These tests verify client behavior and request amplification against a mock. They do not establish hosted database latency or server-side authorization.
 
+The entry check uses empty auth for the default account screen, then a synthetic account with an empty Duel for first-run onboarding. It measures the heading with a browser-local probe and two animation frames after document navigation. `--smoke` also switches signup/sign-in modes and saves a new habit plan through the mock. No real account is created.
+
 ## Recorded artifacts
 
 - [First opens](first-open.json): five samples per view and build from `benchmark-browser.cjs`.
@@ -53,6 +56,7 @@ The reload checks assert full history, counts, filtered queries, twenty-event bu
 - [Duel reloads](duel-reload.json): pagination and request counts with a 1,000-row page cap.
 - [Duel reloads with a 400-row cap](duel-cap400.json): no history truncation with a lower server limit.
 - [Read/write race](duel-race.json): the same UI reproduction on baseline and current source.
+- [Account entry and onboarding](entry-performance.json): five navigation samples per flow and build, plus mode switching and a saved first plan.
 
 Earlier instrumentation that polled and parsed the entire stored state inside the timed interaction was superseded. The accepted interaction artifact observes one real storage write and parses its value after timing. The mock also exposes `Content-Range` to the browser and waits for quiescence across pagination gaps. These corrections are recorded in the decision trail.
 
diff --git a/docs/performance/2026-10-12/decisions.tsv b/docs/performance/2026-10-12/decisions.tsv
index 34282ba..22c6207 100644
--- a/docs/performance/2026-10-12/decisions.tsv
+++ b/docs/performance/2026-10-12/decisions.tsv
@@ -34,3 +34,9 @@ ts	phase	decision	why	evidence	result
 2026-10-12T02:25:16Z	test-instrument	Use a nonretryable mock page error for the propagation assertion	The SDK retries 503 responses, so counting exactly two calls was a false harness assumption	.scratch/performance-overnight/real-client-pagination-r2.log; src/lib/duel-sync.test.ts	mock changed to400; production retry behavior untouched
 2026-10-12T02:35:09Z	evidence-packaging	Move the canonical trail into the committed evidence directory and retain a local symlink	This unattended change needs a reviewable trail plus reusable scripts and accepted raw measurements	docs/performance/2026-10-12/decisions.tsv; docs/performance/2026-10-12/README.md; scripts/benchmark-browser.cjs; scripts/verify-duel-performance.cjs	one canonical log; accepted evidence copied; early diagnosis artifacts remain local
 2026-10-12T02:42:27Z	packaging	Commit the sync, view-loading, unknown-count, and history work as separate changes on main	Separate commits let reviewers assess and revert each behavior independently	fbc0c76; f8d7837; 0b5db4b; 3862085; .scratch/performance-overnight/packaged-check.log; .scratch/performance-overnight/packaged-build.log	165 tests, lint, typecheck, and production build passed; fresh anonymous and mock servers started
+2026-10-12T02:59:55Z	pull-request	Open and immediately register draft PR64 while keeping the checkout on main	CI and review need a concrete diff during the remaining overnight work	https://github.com/Maseeek/do-it/pull/64; f2dab27	linked successfully; Gemini final review pending quota reset
+2026-10-12T03:13:41Z	preview-access	Use the protected-preview access workflow and try the mapped CLI fallback	The preview redirects to Vercel SSO; the connected token cannot read the project team	.scratch/performance-overnight/vercel-whoami.json; .scratch/performance-overnight/vercel-whoami.log; https://github.com/Maseeek/do-it/pull/64	MCP403 for maseeeks-projects; CLI has no credentials; no protection settings changed; continue local verification
+2026-10-12T03:20:56Z	entry-measurement	Probe entry-screen readiness inside the browser instead of timing locator retries	Locator waits quantized both different flows around864ms; the actual heading needs a local readiness probe	.scratch/performance-overnight/entry-gates-before-locator-polling.json; .scratch/performance-overnight/entry-gates.cjs	corrected method running; default entry is account creation, not sign-in; no accounts created
+2026-10-12T03:24:55Z	entry-loader	Use guarded deferred views for account entry and first-run onboarding	Corrected production probes show380ms and497ms on the remaining lazy gates; SSR response contains only the existing CSR fallback	.scratch/performance-overnight/entry-gates-before.json; .scratch/performance-overnight/auth-ssr.html; src/app/page.tsx	implemented; same components and props; build and verification running
+2026-10-12T03:24:55Z	audit	Preserve the Activity habit-ID mapping after checking the baseline	The baseline already uses a last-value Map, so changing it to first-match would change established behavior	.scratch/performance-overnight/baseline-app/src/components/ActivityFeed.tsx:96; src/lib/activity-timeline.ts:76	no source change
+2026-10-12T03:40:03Z	entry-verification	Verify faster account entry and onboarding plus their loaded interactions	The same guarded loader should remove the measured delay without changing account controls or plan saving	docs/performance/2026-10-12/entry-performance.json; scripts/verify-entry-performance.cjs; .scratch/performance-overnight/entry-check.log; .scratch/performance-overnight/entry-build.log	account379.7 to80.6ms; onboarding496.9 to197.1ms; mode switch and plan save passed;165 tests and build passed
diff --git a/docs/performance/2026-10-12/entry-performance.json b/docs/performance/2026-10-12/entry-performance.json
new file mode 100644
index 0000000..2dd8b03
--- /dev/null
+++ b/docs/performance/2026-10-12/entry-performance.json
@@ -0,0 +1,118 @@
+{
+  "measuredAt": "2026-10-12T03:35:58.495Z",
+  "method": "Configured production copies, isolated contexts, empty local auth for default account creation or a synthetic account with an empty Duel for onboarding. First visit warms HTTP cache; five subsequent document reloads measure navigation start through a browser-local heading readiness probe and two animation frames. Mock requests take 50ms. No accounts are created.",
+  "variants": {
+    "baseline": {
+      "account-entry": {
+        "samples": [
+          {
+            "sample": 1,
+            "ms": 386.59999999403954
+          },
+          {
+            "sample": 2,
+            "ms": 380.09999999403954
+          },
+          {
+            "sample": 3,
+            "ms": 380
+          },
+          {
+            "sample": 4,
+            "ms": 380.20000000298023
+          },
+          {
+            "sample": 5,
+            "ms": 380.79999999701977
+          }
+        ],
+        "errors": []
+      },
+      "onboarding": {
+        "samples": [
+          {
+            "sample": 1,
+            "ms": 502.70000000298023
+          },
+          {
+            "sample": 2,
+            "ms": 496.29999999701977
+          },
+          {
+            "sample": 3,
+            "ms": 497.09999999403954
+          },
+          {
+            "sample": 4,
+            "ms": 497.09999999403954
+          },
+          {
+            "sample": 5,
+            "ms": 480.80000001192093
+          }
+        ],
+        "errors": []
+      }
+    },
+    "current": {
+      "account-entry": {
+        "samples": [
+          {
+            "sample": 1,
+            "ms": 77.29999999701977
+          },
+          {
+            "sample": 2,
+            "ms": 80.5
+          },
+          {
+            "sample": 3,
+            "ms": 80.79999999701977
+          },
+          {
+            "sample": 4,
+            "ms": 80.09999999403954
+          },
+          {
+            "sample": 5,
+            "ms": 80.79999999701977
+          }
+        ],
+        "errors": [],
+        "smoke": {
+          "modeSwitch": true
+        }
+      },
+      "onboarding": {
+        "samples": [
+          {
+            "sample": 1,
+            "ms": 197.70000000298023
+          },
+          {
+            "sample": 2,
+            "ms": 196.59999999403954
+          },
+          {
+            "sample": 3,
+            "ms": 196.70000000298023
+          },
+          {
+            "sample": 4,
+            "ms": 196.79999999701977
+          },
+          {
+            "sample": 5,
+            "ms": 197.09999999403954
+          }
+        ],
+        "errors": [],
+        "smoke": {
+          "savedPlan": true,
+          "ownerWrites": 1
+        }
+      }
+    }
+  },
+  "browser": "148.0.7778.178"
+}
\ No newline at end of file
diff --git a/scripts/verify-entry-performance.cjs b/scripts/verify-entry-performance.cjs
new file mode 100644
index 0000000..1c6b140
--- /dev/null
+++ b/scripts/verify-entry-performance.cjs
@@ -0,0 +1,118 @@
+const { chromium } = require('playwright');
+const fs = require('node:fs');
+const path = require('node:path');
+const assert = require('node:assert/strict');
+const { parseArgs } = require('node:util');
+const { values } = parseArgs({ options: {
+  baseline: { type:'string', default:'http://localhost:43131/' },
+  current: { type:'string', default:'http://localhost:43132/' },
+  output: { type:'string', default:'.scratch/entry-performance.json' },
+  chrome: { type:'string' },
+  smoke: { type:'boolean', default:false },
+} });
+const after = values.smoke;
+const resultPath = path.resolve(values.output);
+fs.mkdirSync(path.dirname(resultPath),{recursive:true});
+const results = { measuredAt: new Date().toISOString(), method: 'Configured production copies, isolated contexts, empty local auth for default account creation or a synthetic account with an empty Duel for onboarding. First visit warms HTTP cache; five subsequent document reloads measure navigation start through a browser-local heading readiness probe and two animation frames. Mock requests take 50ms. No accounts are created.', variants: {} };
+const owner = '11111111-1111-4111-8111-111111111111';
+const guest = '22222222-2222-4222-8222-222222222222';
+const user = { id: owner, email: 'entry-owner@local.test', aud: 'authenticated', role: 'authenticated', app_metadata: {}, user_metadata: {}, created_at: '2026-01-01T00:00:00Z' };
+const duel = { id: '33333333-3333-4333-8333-333333333333', owner_id: owner, guest_id: guest, owner_name: 'Entry Owner', guest_name: 'Entry Guest', owner_color: 'blue', guest_color: 'purple', invite_code: '44444444-4444-4444-8444-444444444444' };
+
+async function prepare(page, mode) {
+  const savedHabits = [];
+  const writes = [];
+  if (mode === 'onboarding') await page.addInitScript(({ user, token }) => {
+    localStorage.setItem('sb-127-auth-token', JSON.stringify({ access_token: token, refresh_token: 'local-mock-refresh', token_type: 'bearer', expires_in: 86400, expires_at: Math.floor(Date.now()/1000)+86400, user }));
+  }, { user, token: 'eyJhbGciOiJub25lIn0.' + Buffer.from(JSON.stringify({ sub: owner, exp: Math.floor(Date.now()/1000)+86400 })).toString('base64url') + '.local-mock' });
+  await page.route('http://127.0.0.1:54321/**', async route => {
+    const url = new URL(route.request().url());
+    await new Promise(resolve => setTimeout(resolve, 50));
+    const table = url.pathname.split('/').pop();
+    if (table === 'duels') return route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify([duel]) });
+    assert.ok(['duel_habits','duel_check_ins','duel_stakes','duel_reactions','duel_rest_days'].includes(table));
+    if (route.request().method()==='POST') {
+      assert.equal(table,'duel_habits');
+      const body=route.request().postDataJSON();
+      for(const row of Array.isArray(body)?body:[body]) {
+        assert.equal(row.duel_id,duel.id);
+        assert.equal(row.player_slot,'maciek');
+        savedHabits.push(row.data); writes.push({id:row.id,player:row.player_slot});
+      }
+      return route.fulfill({status:201,contentType:'application/json',body:''});
+    }
+    const data=table==='duel_habits'?savedHabits.map(data=>({data})):[];
+    await route.fulfill({ status: 200, headers: { 'content-type':'application/json', 'content-range':data.length?`0-${data.length-1}/${data.length}`:'*/0', 'access-control-allow-origin':'*', 'access-control-expose-headers':'content-range' }, body: JSON.stringify(data) });
+  });
+  return {savedHabits,writes};
+  await page.routeWebSocket('ws://127.0.0.1:54321/**', socket => {
+    socket.onMessage(raw => {
+      const [joinRef, ref, topic, event, payload] = JSON.parse(String(raw));
+      if (event === 'phx_join') {
+        const filters = (payload.config?.postgres_changes ?? []).map((filter,index) => ({ ...filter, id:index+1 }));
+        socket.send(JSON.stringify([joinRef,ref,topic,'phx_reply',{status:'ok',response:{postgres_changes:filters}}]));
+      } else if (event === 'heartbeat' || event === 'phx_leave') socket.send(JSON.stringify([joinRef,ref,topic,'phx_reply',{status:'ok',response:{}}]));
+    });
+  });
+}
+
+(async () => {
+  const browser = await chromium.launch({ headless:true, ...(values.chrome ? {executablePath:values.chrome} : {}) });
+  results.browser = browser.version();
+  try {
+    for (const [name,url] of [['baseline',values.baseline],['current',values.current]]) {
+      results.variants[name] = {};
+      for (const mode of ['account-entry','onboarding']) {
+        const context = await browser.newContext({ viewport:{width:1280,height:800}, timezoneId:'Europe/London', reducedMotion:'reduce' });
+        const page = await context.newPage();
+        const errors=[]; page.on('pageerror',error => errors.push(error.message));
+        const fixture=await prepare(page,mode);
+        const heading = mode === 'account-entry' ? 'Create your account' : 'Choose your habits.';
+        await page.goto(url); await page.getByRole('heading',{name:heading,exact:true}).waitFor();
+        const samples=[];
+        for(let sample=1;sample<=5;sample++) {
+          await page.goto(url,{waitUntil:'domcontentloaded'});
+          const ms=await page.evaluate(async heading => {
+            await new Promise((resolve,reject) => {
+              const deadline = performance.now()+10000;
+              function probe() {
+                const ready=Array.from(document.querySelectorAll('h1')).some(h=>h.textContent.trim()===heading && h.getClientRects().length>0);
+                if(ready) resolve();
+                else if(performance.now()>deadline) reject(new Error('Heading timeout '+heading));
+                else setTimeout(probe,5);
+              }
+              probe();
+            });
+            await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+            return performance.now();
+          },heading);
+          samples.push({sample,ms});
+        }
+        assert.deepEqual(errors,[]);
+        let smoke;
+        if(after && name==='current') {
+          if(mode==='account-entry') {
+            await page.getByRole('button',{name:'Already have an account? Sign in',exact:true}).click();
+            await page.getByRole('heading',{name:'Welcome back',exact:true}).waitFor();
+            await page.getByRole('button',{name:'Need an account? Sign up',exact:true}).click();
+            await page.getByRole('heading',{name:'Create your account',exact:true}).waitFor();
+            smoke={modeSwitch:true};
+          } else {
+            await page.getByRole('textbox',{name:'New habit name',exact:true}).fill('Timing smoke habit');
+            await page.getByRole('button',{name:'Add',exact:true}).click();
+            await page.getByRole('button',{name:'Start with these habits',exact:true}).click();
+            await page.getByRole('heading',{name:'Daily Ritual',exact:true}).waitFor();
+            assert.ok(fixture.savedHabits.some(h=>h.title==='Timing smoke habit' && h.playerId==='maciek'));
+            smoke={savedPlan:true,ownerWrites:fixture.writes.length};
+          }
+        }
+        assert.deepEqual(errors,[]);
+        results.variants[name][mode] = { samples,errors,smoke };
+        await context.close();
+      }
+      fs.writeFileSync(resultPath,JSON.stringify(results,null,2));
+      console.log(JSON.stringify({name,passed:true}));
+    }
+  } catch(error) {results.failure=error.message;throw error;}
+  finally {fs.writeFileSync(resultPath,JSON.stringify(results,null,2));await browser.close();}
+})().catch(error => {console.error(error);process.exitCode=1;});
diff --git a/src/app/page.tsx b/src/app/page.tsx
index a574015..5a66329 100644
--- a/src/app/page.tsx
+++ b/src/app/page.tsx
@@ -34,9 +34,9 @@ function preloadTab(tab: TabType) {
   if (tab === 'duel') preloadDuel();
   if (tab === 'progress') preloadProgress();
 }
-const MultiplayerGate = dynamic(() => loadCurrentPage(() => import('@/components/MultiplayerGate')).then(module => module.MultiplayerGate), { loading: ViewLoading });
+const { View: MultiplayerGate } = createDeferredView(() => import('@/components/MultiplayerGate').then(module => module.MultiplayerGate));
 const ExistingDuelInviteGate = dynamic(() => loadCurrentPage(() => import('@/components/ExistingDuelInviteGate')).then(module => module.ExistingDuelInviteGate), { loading: ViewLoading });
-const HabitOnboarding = dynamic(() => loadCurrentPage(() => import('@/components/HabitOnboarding')).then(module => module.HabitOnboarding), { loading: ViewLoading });
+const { View: HabitOnboarding } = createDeferredView(() => import('@/components/HabitOnboarding').then(module => module.HabitOnboarding));
 const { View: KeyboardShortcutsModal } = createDeferredView(() => import('@/components/KeyboardShortcutsModal').then(module => module.KeyboardShortcutsModal), null);
 
 function AppContent() {

From 69d22fec95f64efdc9eeba574d2a05f0e3d80420 Mon Sep 17 00:00:00 2001
From: Maseeek <maseeekyt@gmail.com>
Date: Mon, 12 Oct 2026 06:50:28 +0100
Subject: [PATCH 08/10] perf(sync): load known history pages concurrently

Limit known-count Duel history reads to three concurrent requests. Preserve ordered complete history with serial fallback when server page limits change, while unavailable totals still read through an empty page.

Verify fixed and changing limits through the actual Supabase client, including growth in the final batch slot. Extend the production browser harness to measure complete authenticated loading with 14,600 records.
---
 docs/performance/2026-10-12/README.md         |    4 +
 docs/performance/2026-10-12/decisions.tsv     |   13 +
 .../2026-10-12/duel-loading-cap400.json       | 3434 +++++++++++++++++
 scripts/verify-duel-performance.cjs           |   61 +-
 src/lib/duel-sync.test.ts                     |  175 +-
 src/lib/duel-sync.ts                          |   88 +-
 6 files changed, 3723 insertions(+), 52 deletions(-)
 create mode 100644 docs/performance/2026-10-12/duel-loading-cap400.json

diff --git a/docs/performance/2026-10-12/README.md b/docs/performance/2026-10-12/README.md
index 8ca9d41..561723d 100644
--- a/docs/performance/2026-10-12/README.md
+++ b/docs/performance/2026-10-12/README.md
@@ -40,11 +40,14 @@ npm test
 NODE_PATH="$PWD/.scratch/browser-tools/node_modules" node scripts/verify-duel-performance.cjs --page-cap 1000 --output .scratch/duel-reload.json
 NODE_PATH="$PWD/.scratch/browser-tools/node_modules" node scripts/verify-duel-performance.cjs --page-cap 400 --output .scratch/duel-cap400.json
 NODE_PATH="$PWD/.scratch/browser-tools/node_modules" node scripts/verify-duel-performance.cjs --race --output .scratch/duel-race.json
+NODE_PATH="$PWD/.scratch/browser-tools/node_modules" node scripts/verify-duel-performance.cjs --loading-only --history-days 730 --samples 5 --page-cap 400 --output .scratch/duel-loading-cap400.json
 NODE_PATH="$PWD/.scratch/browser-tools/node_modules" node scripts/verify-entry-performance.cjs --smoke --output .scratch/entry-performance.json
 ```
 
 The reload checks assert full history, counts, filtered queries, twenty-event bursts, one follow-up for events during loading, actual Check-in/undo writes, and unchanged local history. The race check observes the Habit button while a read overlaps a local write: the baseline becomes unchecked temporarily; the current build remains checked. These tests verify client behavior and request amplification against a mock. They do not establish hosted database latency or server-side authorization.
 
+Known-count history now loads in batches of at most three requests. Responses retain their requested order; a changed page size discards later speculative responses and resumes serial reads from the contiguous prefix. Unknown totals remain serial through an empty page. The loading-only scenario uses 14,600 records and five alternating samples in fresh browser contexts. Its browser-local probe ends when Daily Ritual and the Check-in control appear, followed by two animation frames; Activity then verifies the complete record count. This includes localhost JavaScript loading and rendering with 50 ms mock responses.
+
 The entry check uses empty auth for the default account screen, then a synthetic account with an empty Duel for first-run onboarding. It measures the heading with a browser-local probe and two animation frames after document navigation. `--smoke` also switches signup/sign-in modes and saves a new habit plan through the mock. No real account is created.
 
 ## Recorded artifacts
@@ -57,6 +60,7 @@ The entry check uses empty auth for the default account screen, then a synthetic
 - [Duel reloads with a 400-row cap](duel-cap400.json): no history truncation with a lower server limit.
 - [Read/write race](duel-race.json): the same UI reproduction on baseline and current source.
 - [Account entry and onboarding](entry-performance.json): five navigation samples per flow and build, plus mode switching and a saved first plan.
+- [Large authenticated history loading](duel-loading-cap400.json): five samples per build, full 14,600-record history, and a 400-row server cap.
 
 Earlier instrumentation that polled and parsed the entire stored state inside the timed interaction was superseded. The accepted interaction artifact observes one real storage write and parses its value after timing. The mock also exposes `Content-Range` to the browser and waits for quiescence across pagination gaps. These corrections are recorded in the decision trail.
 
diff --git a/docs/performance/2026-10-12/decisions.tsv b/docs/performance/2026-10-12/decisions.tsv
index 22c6207..90aeb7f 100644
--- a/docs/performance/2026-10-12/decisions.tsv
+++ b/docs/performance/2026-10-12/decisions.tsv
@@ -40,3 +40,16 @@ ts	phase	decision	why	evidence	result
 2026-10-12T03:24:55Z	entry-loader	Use guarded deferred views for account entry and first-run onboarding	Corrected production probes show380ms and497ms on the remaining lazy gates; SSR response contains only the existing CSR fallback	.scratch/performance-overnight/entry-gates-before.json; .scratch/performance-overnight/auth-ssr.html; src/app/page.tsx	implemented; same components and props; build and verification running
 2026-10-12T03:24:55Z	audit	Preserve the Activity habit-ID mapping after checking the baseline	The baseline already uses a last-value Map, so changing it to first-match would change established behavior	.scratch/performance-overnight/baseline-app/src/components/ActivityFeed.tsx:96; src/lib/activity-timeline.ts:76	no source change
 2026-10-12T03:40:03Z	entry-verification	Verify faster account entry and onboarding plus their loaded interactions	The same guarded loader should remove the measured delay without changing account controls or plan saving	docs/performance/2026-10-12/entry-performance.json; scripts/verify-entry-performance.cjs; .scratch/performance-overnight/entry-check.log; .scratch/performance-overnight/entry-build.log	account379.7 to80.6ms; onboarding496.9 to197.1ms; mode switch and plan save passed;165 tests and build passed
+2026-10-12T03:43:32Z	ci-review	Use the REST update path after the installed gh PR editor hits the classic-Projects deprecation	The PR body needs the entry measurements and current preview-access limitation	https://github.com/Maseeek/do-it/pull/64; .scratch/performance-overnight/pr-edit.json	REST update submitted; latest implementation remains a draft awaiting final Gemini review
+2026-10-12T03:53:40Z	pagination-prototype	Measure three bounded remaining-page reads after a known first-page count	Serial authenticated history pages are a remaining loading bottleneck	.scratch/performance-overnight/pagination-prototype.cjs; .scratch/performance-overnight/pagination-prototype.json	stationary datasets preserve14600 ordered rows; prototype only; changing caps, cancellation, errors, and writes still require proof
+2026-10-12T03:59:47Z	trail-review-context	Capture this T3 run with an indexed full timeline and compact conversation transcript	The final cross-model audit needs actual decisions and tool receipts; recursive transcript-read events add no evidence	.scratch/performance-overnight/parent-transcript-snapshot.json; .scratch/performance-overnight/parent-conversation.md; .scratch/performance-overnight/parent-timeline-index.tsv	1171 pre-collection activities captured without truncation; transcript files remain local
+2026-10-12T04:07:59Z	prototype-rejection	Reject the simple parallel prototype when the server cap shrinks between pages	A known total does not make fixed offsets safe after an unexpected short response	.scratch/performance-overnight/pagination-prototype.json; .scratch/performance-overnight/pagination-prototype-r2.log	serial retained1250 rows; naive parallel returned850; production code unchanged
+2026-10-12T04:12:46Z	prototype-fallback	Test a contiguous-prefix fallback after an unexpected short speculative page	The naive parallel version lost400 rows when the cap shrank; later speculative pages must not skip gaps	.scratch/performance-overnight/pagination-prototype.cjs; .scratch/performance-overnight/pagination-prototype-r3.log	throwaway fallback retained1250 unique rows; errors, unknown totals, cancellation, and app integration remain unproven
+2026-10-12T04:15:18Z	review-setup	Pin the two-axis review to the recorded pre-run baseline and current400fbfe	Standards and spec need independent checks against a stable diff while later work continues	.scratch/performance-overnight/review-round4-plan.md; .scratch/performance-overnight/gemini-round4-brief.md; https://github.com/Maseeek/do-it/issues/63	review setup ready; waiting for Gemini quota reset04:20UTC
+2026-10-12T04:18:58Z	trail-audit	Supersede the removed calculations-r2 test pointer in the00:24:40 row	That quota-era test imported ignored baseline files; it was moved to scratch and portable expected-value tests replaced it	.scratch/performance-overnight/calculations-r2-differential.test.ts; .scratch/performance-overnight/repair-differential.log; src/lib/calculation-regressions.test.ts	47-row local evidence audit found one removed historical pointer; replacement artifacts resolve; history retained
+2026-10-12T04:23:40Z	gemini-resume	Resume two pinned reviews and delegate bounded paging implementation after quota reset	Actual Gemini read/command activity confirms available service; the prototype needs cap/error/order proof before app use	.scratch/performance-overnight/round4-tasks.json; .scratch/performance-overnight/pagination-r4-task.json; .scratch/performance-overnight/gemini-round4-brief.md	Gemini3.8Flash standards,3.7Flash spec,3.1Pro paging running with separate ownership
+2026-10-12T04:29:27Z	review	Read completed independent Standards and Spec reviews at 400fbfe	Separate hard coding rules from optional cleanup and unverified infrastructure	.scratch/performance-overnight/standards-r4.md; .scratch/performance-overnight/spec-r4.md; src/app/api/sync/apple-health/route.ts	No hard standards violations; serial paging and cancellation remain open; hosted and physical mobile evidence unavailable
+2026-10-12T04:32:48Z	pagination	Build and independently check bounded history paging before browser acceptance	Three concurrent requests may reduce a measured serial bottleneck while fallback protects complete history	src/lib/duel-sync.ts; src/lib/duel-sync.test.ts; .scratch/performance-overnight/pagination-parent-check.log; .scratch/performance-overnight/pagination-parent-build.log; .scratch/performance-overnight/pagination-auth-build.log	169 tests, typecheck, lint and both production builds pass; browser timing and adversarial review pending
+2026-10-12T05:49:48Z	paging-review	Fix final-slot page growth and share the local range builder	Independent Gemini review found two avoidable speculative requests after a cap grows	.scratch/performance-overnight/pagination-review-r5.md; src/lib/duel-sync.ts; src/lib/duel-sync.test.ts	Added ordered full-history regression; integer count validation; final checks running
+2026-10-12T05:49:48Z	loading	Measure complete authenticated screen loading after bounded pagination	Accept app improvement only from a production browser reproduction	.scratch/performance-overnight/duel-loading-before-pagination.json; docs/performance/2026-10-12/duel-loading-cap400.json; scripts/verify-duel-performance.cjs	Five samples: baseline2385.8ms current1034.4ms; all14600 records retained; final-source rerun pending
+2026-10-12T05:49:48Z	scope	Leave cancellation and additional calculation proposals for later work	Remaining deadline allows verification of accepted paging; cancellation needs read/write lifecycle tests	.scratch/performance-overnight/cancellation-audit-r4.md; .scratch/performance-overnight/hotpaths-r5.md	No cancellation or further calculator change; estimated cancellation savings are hypotheses, not measured app results
diff --git a/docs/performance/2026-10-12/duel-loading-cap400.json b/docs/performance/2026-10-12/duel-loading-cap400.json
new file mode 100644
index 0000000..76f49b1
--- /dev/null
+++ b/docs/performance/2026-10-12/duel-loading-cap400.json
@@ -0,0 +1,3434 @@
+{
+  "measuredAt": "2026-10-12T04:32:55.332Z",
+  "pageCap": 400,
+  "historyCount": 14600,
+  "samples": 5,
+  "method": "Production copies configured only for a Playwright-routed localhost Supabase mock. 14600 CheckIns, 50ms per HTTP response, real Phoenix subscriptions/events, no live database or auth. New browser context per sample. Initial rendering measured inside the page from navigation start to Daily Ritual and a Check-in control, followed by two animation frames. Counts verify reload amplification; loading times include localhost JS and rendering, not hosted latency.",
+  "variants": {
+    "baseline": [
+      {
+        "initialRitualMs": 2473.199999988079,
+        "initialQueries": [
+          {
+            "phase": "initial",
+            "table": "duel_habits",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 20
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_stakes",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_reactions",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_rest_days",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 200
+          }
+        ],
+        "peakByTable": {
+          "duel_habits": 1,
+          "duel_check_ins": 1,
+          "duel_stakes": 1,
+          "duel_reactions": 1,
+          "duel_rest_days": 1
+        },
+        "visibleHistory": 14600,
+        "errors": []
+      },
+      {
+        "initialRitualMs": 2385.7999999970198,
+        "initialQueries": [
+          {
+            "phase": "initial",
+            "table": "duel_habits",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 20
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_stakes",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_reactions",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_rest_days",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 200
+          }
+        ],
+        "peakByTable": {
+          "duel_habits": 1,
+          "duel_check_ins": 1,
+          "duel_stakes": 1,
+          "duel_reactions": 1,
+          "duel_rest_days": 1
+        },
+        "visibleHistory": 14600,
+        "errors": []
+      },
+      {
+        "initialRitualMs": 2388.4000000059605,
+        "initialQueries": [
+          {
+            "phase": "initial",
+            "table": "duel_habits",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 20
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_stakes",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_reactions",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_rest_days",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 200
+          }
+        ],
+        "peakByTable": {
+          "duel_habits": 1,
+          "duel_check_ins": 1,
+          "duel_stakes": 1,
+          "duel_reactions": 1,
+          "duel_rest_days": 1
+        },
+        "visibleHistory": 14600,
+        "errors": []
+      },
+      {
+        "initialRitualMs": 2371,
+        "initialQueries": [
+          {
+            "phase": "initial",
+            "table": "duel_habits",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 20
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_stakes",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_reactions",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_rest_days",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 200
+          }
+        ],
+        "peakByTable": {
+          "duel_habits": 1,
+          "duel_check_ins": 1,
+          "duel_stakes": 1,
+          "duel_reactions": 1,
+          "duel_rest_days": 1
+        },
+        "visibleHistory": 14600,
+        "errors": []
+      },
+      {
+        "initialRitualMs": 2379.2000000029802,
+        "initialQueries": [
+          {
+            "phase": "initial",
+            "table": "duel_habits",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 20
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_stakes",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_reactions",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_rest_days",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12800,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13200,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13600,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14000,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14400,
+            "limit": 1000,
+            "exact": true,
+            "rows": 200
+          }
+        ],
+        "peakByTable": {
+          "duel_habits": 1,
+          "duel_check_ins": 1,
+          "duel_stakes": 1,
+          "duel_reactions": 1,
+          "duel_rest_days": 1
+        },
+        "visibleHistory": 14600,
+        "errors": []
+      }
+    ],
+    "current": [
+      {
+        "initialRitualMs": 1094,
+        "initialQueries": [
+          {
+            "phase": "initial",
+            "table": "duel_habits",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 20
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_stakes",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_reactions",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_rest_days",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 200
+          }
+        ],
+        "peakByTable": {
+          "duel_habits": 1,
+          "duel_check_ins": 3,
+          "duel_stakes": 1,
+          "duel_reactions": 1,
+          "duel_rest_days": 1
+        },
+        "visibleHistory": 14600,
+        "errors": []
+      },
+      {
+        "initialRitualMs": 1034.4000000059605,
+        "initialQueries": [
+          {
+            "phase": "initial",
+            "table": "duel_habits",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 20
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_stakes",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_reactions",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_rest_days",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 200
+          }
+        ],
+        "peakByTable": {
+          "duel_habits": 1,
+          "duel_check_ins": 3,
+          "duel_stakes": 1,
+          "duel_reactions": 1,
+          "duel_rest_days": 1
+        },
+        "visibleHistory": 14600,
+        "errors": []
+      },
+      {
+        "initialRitualMs": 1047.1000000089407,
+        "initialQueries": [
+          {
+            "phase": "initial",
+            "table": "duel_habits",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 20
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_stakes",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_reactions",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_rest_days",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 200
+          }
+        ],
+        "peakByTable": {
+          "duel_habits": 1,
+          "duel_check_ins": 3,
+          "duel_stakes": 1,
+          "duel_reactions": 1,
+          "duel_rest_days": 1
+        },
+        "visibleHistory": 14600,
+        "errors": []
+      },
+      {
+        "initialRitualMs": 1028.7999999970198,
+        "initialQueries": [
+          {
+            "phase": "initial",
+            "table": "duel_habits",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 20
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_stakes",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_reactions",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_rest_days",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 200
+          }
+        ],
+        "peakByTable": {
+          "duel_habits": 1,
+          "duel_check_ins": 3,
+          "duel_stakes": 1,
+          "duel_reactions": 1,
+          "duel_rest_days": 1
+        },
+        "visibleHistory": 14600,
+        "errors": []
+      },
+      {
+        "initialRitualMs": 1024.2999999970198,
+        "initialQueries": [
+          {
+            "phase": "initial",
+            "table": "duel_habits",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 20
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_stakes",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_reactions",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_rest_days",
+            "start": 0,
+            "limit": 1000,
+            "exact": true,
+            "rows": 0
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 1600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 2800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 3600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 4800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 5600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 6800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 7600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 8800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 9600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 10800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 11600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 12800,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13200,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 13600,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14000,
+            "limit": 1000,
+            "exact": false,
+            "rows": 400
+          },
+          {
+            "phase": "initial",
+            "table": "duel_check_ins",
+            "start": 14400,
+            "limit": 1000,
+            "exact": false,
+            "rows": 200
+          }
+        ],
+        "peakByTable": {
+          "duel_habits": 1,
+          "duel_check_ins": 3,
+          "duel_stakes": 1,
+          "duel_reactions": 1,
+          "duel_rest_days": 1
+        },
+        "visibleHistory": 14600,
+        "errors": []
+      }
+    ]
+  },
+  "browser": "148.0.7778.178"
+}
\ No newline at end of file
diff --git a/scripts/verify-duel-performance.cjs b/scripts/verify-duel-performance.cjs
index 1bc5d29..b1079a9 100644
--- a/scripts/verify-duel-performance.cjs
+++ b/scripts/verify-duel-performance.cjs
@@ -9,6 +9,9 @@ const { values } = parseArgs({ options: {
   output: { type: 'string', default: '.scratch/duel-performance.json' },
   chrome: { type: 'string' },
   'page-cap': { type: 'string', default: '1000' },
+  'history-days': { type: 'string', default: '125' },
+  'loading-only': { type: 'boolean', default: false },
+  samples: { type: 'string', default: '1' },
   race: { type: 'boolean', default: false },
 } });
 const resultPath = path.resolve(values.output);
@@ -17,6 +20,11 @@ fs.mkdirSync(root, { recursive: true });
 const pageCap = Number(values['page-cap']);
 assert.ok(Number.isInteger(pageCap) && pageCap > 0);
 const raceOnly = values.race;
+const historyDays = Number(values['history-days']);
+const samples = Number(values.samples);
+assert.ok(Number.isInteger(historyDays) && historyDays > 0);
+assert.ok(Number.isInteger(samples) && samples > 0);
+assert.ok(samples === 1 || values['loading-only'], 'Repeated samples require loading-only mode');
 
 const initial = require(path.resolve('.scratch/test-build/seed.js')).getInitialState();
 const owner = '11111111-1111-4111-8111-111111111111';
@@ -24,12 +32,13 @@ const guest = '22222222-2222-4222-8222-222222222222';
 const duelId = '33333333-3333-4333-8333-333333333333';
 const user = { id: owner, email: 'performance-owner@local.test', aud: 'authenticated', role: 'authenticated', app_metadata: {}, user_metadata: {}, created_at: '2026-01-01T00:00:00Z' };
 const duel = { id: duelId, owner_id: owner, guest_id: guest, owner_name: 'Perf Owner', guest_name: 'Perf Guest', owner_color: 'blue', guest_color: 'purple', invite_code: '44444444-4444-4444-8444-444444444444' };
-const results = { measuredAt: new Date().toISOString(), pageCap, method: 'Production copies configured only for a Playwright-routed localhost Supabase mock. 2500 CheckIns, 50ms per HTTP response, real Phoenix subscriptions/events, no live database or auth. Counts verify reload amplification, not hosted latency.', variants: {} };
+const historyCount = initial.habits.length * historyDays;
+const results = { measuredAt: new Date().toISOString(), pageCap, historyCount, samples, method: `Production copies configured only for a Playwright-routed localhost Supabase mock. ${historyCount} CheckIns, 50ms per HTTP response, real Phoenix subscriptions/events, no live database or auth. New browser context per sample. Initial rendering measured inside the page from navigation start to Daily Ritual and a Check-in control, followed by two animation frames. Counts verify reload amplification; loading times include localhost JS and rendering, not hosted latency.`, variants: {} };
 
 function makeRows() {
   const checks = [];
   const today = new Date();
-  for (let day = 1; day <= 125; day++) {
+  for (let day = 1; day <= historyDays; day++) {
     const d = new Date(today); d.setDate(d.getDate() - day);
     const date = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
     for (const h of initial.habits) checks.push({ id: `${h.id}-${date}`, habitId: h.id, playerId: h.playerId, date, pointsEarned: h.points, completedAt: `${date}T12:00:00Z` });
@@ -55,12 +64,22 @@ async function verify(browser, name, url) {
   const errors = [];
   let phase = 'initial';
   let active = 0;
+  const activeByTable = {};
+  const peakByTable = {};
   let lastQueryAt = 0;
   page.on('pageerror', error => errors.push(error.message));
   await page.addInitScript(({ user, token }) => {
     localStorage.setItem('sb-127-auth-token', JSON.stringify({ access_token: token, refresh_token: 'local-mock-refresh', token_type: 'bearer', expires_in: 86400, expires_at: Math.floor(Date.now()/1000)+86400, user }));
     localStorage.setItem('do_it_sound_enabled', 'false');
     localStorage.setItem('do_it_app_data_v2', 'local-history-sentinel');
+    let scheduled = false;
+    const observer = new MutationObserver(() => {
+      if (scheduled || !document.body?.innerText.includes('Daily Ritual') || !document.querySelector('button[aria-label="Mark Gym & Strength completed"]')) return;
+      scheduled = true;
+      observer.disconnect();
+      requestAnimationFrame(() => requestAnimationFrame(() => { window.initialRitualMs = performance.now(); }));
+    });
+    observer.observe(document, { subtree: true, childList: true, attributes: true });
   }, { user, token: 'eyJhbGciOiJub25lIn0.' + Buffer.from(JSON.stringify({ sub: owner, exp: Math.floor(Date.now()/1000)+86400, role: 'authenticated' })).toString('base64url') + '.local-mock' });
 
   await page.route('http://127.0.0.1:54321/**', async route => {
@@ -99,11 +118,13 @@ async function verify(browser, name, url) {
     queries.push({ phase, table, start, limit, exact, rows: selected.length });
     lastQueryAt = Date.now();
     active++;
+    activeByTable[table] = (activeByTable[table] ?? 0) + 1;
+    peakByTable[table] = Math.max(peakByTable[table] ?? 0, activeByTable[table]);
     try {
       await new Promise(resolve => setTimeout(resolve, 50));
       headers['content-range'] = `${start}-${Math.max(start, start + selected.length - 1)}/${exact ? sorted.length : '*'}`;
       await route.fulfill({ status: 200, headers, body: JSON.stringify(selected) });
-    } finally { active--; }
+    } finally { active--; activeByTable[table]--; }
   });
 
   await page.routeWebSocket('ws://127.0.0.1:54321/**', socket => {
@@ -134,11 +155,21 @@ async function verify(browser, name, url) {
     await page.getByText('Daily Ritual', { exact: true }).waitFor();
     await until(page, () => active === 0 && Date.now() - lastQueryAt > 250 && subscriptions.some(s => s.topic === 'realtime:duel-' + duelId), 'initial load');
     const initialQueries = queries.filter(q => q.phase === 'initial');
-    const checkPages = Math.ceil(2500 / pageCap);
+    const checkPages = Math.ceil(historyCount / pageCap);
     assert.equal(initialQueries.filter(q => q.table === 'duel_check_ins').length, checkPages);
     assert.equal(initialQueries.filter(q => q.exact).length, name === 'current' ? 5 : checkPages + 4);
     assert.equal(await page.evaluate(() => localStorage.getItem('do_it_app_data_v2')), 'local-history-sentinel');
 
+    if (values['loading-only']) {
+      await page.waitForFunction(() => typeof window.initialRitualMs === 'number');
+      const initialRitualMs = await page.evaluate(() => window.initialRitualMs);
+      await page.getByRole('tab', { name: 'Activity', exact: true }).click();
+      await page.waitForFunction(() => document.body.innerText.includes('The timeline'), null, { timeout: 5000 });
+      assert.equal(await page.getByText(String(historyCount), { exact: true }).count() > 0, true);
+      assert.deepEqual(errors, []);
+      return { initialRitualMs, initialQueries, peakByTable, visibleHistory: historyCount, errors };
+    }
+
     if (raceOnly) {
       phase = 'race';
       await page.evaluate(() => {
@@ -160,7 +191,7 @@ async function verify(browser, name, url) {
       notify(1);
       await until(page, () => active === 0 && Date.now() - lastQueryAt > 250, 'race quiescence');
       const trace = await page.evaluate(() => { window.raceObserver.disconnect(); return window.raceTrace; });
-      assert.equal(rows.duel_check_ins.length, 2501);
+      assert.equal(rows.duel_check_ins.length, historyCount + 1);
       const finalChecked = await page.getByRole('button', { name: 'Mark Gym & Strength uncompleted for today', exact: true }).count() === 1;
       assert.equal(finalChecked, true);
       assert.equal(trace.some(entry => !entry.checked), name === 'baseline');
@@ -192,16 +223,16 @@ async function verify(browser, name, url) {
     assert.equal(entry?.pointsEarned, 40);
     await page.getByRole('button', { name: 'Mark Gym & Strength uncompleted for today', exact: true }).click();
     await until(page, () => writes.some(w => w.method === 'DELETE'), 'undo write');
-    assert.equal(rows.duel_check_ins.length, 2500);
+    assert.equal(rows.duel_check_ins.length, historyCount);
     assert.equal(await page.evaluate(() => localStorage.getItem('do_it_app_data_v2')), 'local-history-sentinel');
 
     fs.writeFileSync(path.join(root, `authenticated-${name}-before-activity.txt`), await page.locator('body').innerText());
     await page.screenshot({ path: path.join(root, `authenticated-${name}-before-activity.png`), fullPage: true });
     await page.getByRole('tab', { name: 'Activity', exact: true }).click({ timeout: 5000 });
     await page.waitForFunction(() => document.body.innerText.includes('The timeline'), null, { timeout: 5000 });
-    assert.equal(await page.getByText('2500', { exact: true }).count() > 0, true);
+    assert.equal(await page.getByText(String(historyCount), { exact: true }).count() > 0, true);
     assert.deepEqual(errors, []);
-    return { initialQueries, burst, during, writes: writes.map(w => ({ table: w.table, method: w.method })), errors, localHistoryUntouched: true, visibleHistory: 2500 };
+    return { initialQueries, burst, during, writes: writes.map(w => ({ table: w.table, method: w.method })), errors, localHistoryUntouched: true, visibleHistory: historyCount };
   } finally { await context.close(); }
 }
 
@@ -209,10 +240,16 @@ async function verify(browser, name, url) {
   const browser = await chromium.launch({ headless: true, ...(values.chrome ? { executablePath: values.chrome } : {}) });
   results.browser = browser.version();
   try {
-    for (const [name, url] of [['baseline', values.baseline], ['current', values.current]]) {
-      results.variants[name] = await verify(browser, name, url);
-      console.log(JSON.stringify({ name, passed: true }));
-      fs.writeFileSync(resultPath, JSON.stringify(results, null, 2));
+    for (let sample = 0; sample < samples; sample++) {
+      const variants = [['baseline', values.baseline], ['current', values.current]];
+      if (sample % 2) variants.reverse();
+      for (const [name, url] of variants) {
+        const result = await verify(browser, name, url);
+        if (samples === 1) results.variants[name] = result;
+        else (results.variants[name] ??= []).push(result);
+        console.log(JSON.stringify({ name, sample: sample + 1, passed: true, initialRitualMs: result.initialRitualMs }));
+        fs.writeFileSync(resultPath, JSON.stringify(results, null, 2));
+      }
     }
   } catch (error) { results.failure = error.message; throw error; }
   finally { fs.writeFileSync(resultPath, JSON.stringify(results, null, 2)); await browser.close(); }
diff --git a/src/lib/duel-sync.test.ts b/src/lib/duel-sync.test.ts
index a8af178..e3e8e3b 100644
--- a/src/lib/duel-sync.test.ts
+++ b/src/lib/duel-sync.test.ts
@@ -28,6 +28,10 @@ describe('Duel history pagination', () => {
   function createClientFixture(options: {
     totalRows: number;
     pageCap?: number;
+    laterPageCap?: number;
+    capByOffset?: Record<number, number>;
+    delayByOffset?: Record<number, number>;
+    constantDelayMs?: number;
     omitCount?: boolean;
     omitCountHeader?: boolean;
     failAtOffset?: number;
@@ -37,56 +41,75 @@ describe('Duel history pagination', () => {
       data: { id: 'item-' + index, name: 'Item ' + index },
     }));
     const queries: { offset: number; exactCount: boolean }[] = [];
+    let inFlight = 0;
+    let peakInFlight = 0;
+
     const client = createClient('http://localhost:54321', 'mock-publishable-key', {
       auth: { persistSession: false, autoRefreshToken: false, detectSessionInUrl: false },
       realtime: { transport: HttpOnlyTransport },
       global: {
         fetch: async (input, init) => {
-          const url = new URL(typeof input === 'string' ? input : input instanceof URL ? input.href : input.url);
-          assert.ok(['/rest/v1/duel_habits', '/rest/v1/duel_check_ins'].includes(url.pathname));
-          assert.equal(init?.method, 'GET');
-          assert.equal(url.searchParams.get('select'), 'data');
-          assert.equal(url.searchParams.get('duel_id'), 'eq.duel-test');
-          assert.equal(url.searchParams.get('order'), 'id.asc');
-          const offset = Number(url.searchParams.get('offset') ?? 0);
-          const limit = Number(url.searchParams.get('limit'));
-          assert.equal(limit, 1000);
-          const exactCount = new Headers(init?.headers).get('prefer')?.includes('count=exact') ?? false;
-          queries.push({ offset, exactCount });
-          if (offset === options.failAtOffset) {
-            return new Response(JSON.stringify({ message: 'Database unavailable', code: 'MOCK_FAILURE' }), { status: 400 });
+          inFlight++;
+          peakInFlight = Math.max(peakInFlight, inFlight);
+          try {
+            const url = new URL(typeof input === 'string' ? input : input instanceof URL ? input.href : input.url);
+            assert.ok(['/rest/v1/duel_habits', '/rest/v1/duel_check_ins'].includes(url.pathname));
+            assert.equal(init?.method, 'GET');
+            assert.equal(url.searchParams.get('select'), 'data');
+            assert.equal(url.searchParams.get('duel_id'), 'eq.duel-test');
+            assert.equal(url.searchParams.get('order'), 'id.asc');
+            const offset = Number(url.searchParams.get('offset') ?? 0);
+            const limit = Number(url.searchParams.get('limit'));
+            assert.equal(limit, 1000);
+            const exactCount = new Headers(init?.headers).get('prefer')?.includes('count=exact') ?? false;
+            queries.push({ offset, exactCount });
+
+            if (options.delayByOffset && typeof options.delayByOffset[offset] === 'number') {
+              await new Promise(resolve => setTimeout(resolve, options.delayByOffset![offset]));
+            } else if (options.constantDelayMs) {
+              await new Promise(resolve => setTimeout(resolve, options.constantDelayMs));
+            }
+
+            if (offset === options.failAtOffset) {
+              return new Response(JSON.stringify({ message: 'Database unavailable', code: 'MOCK_FAILURE' }), { status: 400 });
+            }
+            const cap = options.capByOffset?.[offset] ?? (offset === 0 ? (options.pageCap ?? limit) : (options.laterPageCap ?? options.pageCap ?? limit));
+            const page = data.slice(offset, offset + Math.min(limit, cap));
+            const total = exactCount && !options.omitCount ? String(data.length) : '*';
+            const range = page.length ? offset + '-' + (offset + page.length - 1) : '*';
+            const headers = new Headers({ 'content-type': 'application/json' });
+            if (!options.omitCountHeader) headers.set('content-range', range + '/' + total);
+            return new Response(JSON.stringify(page), {
+              headers,
+            });
+          } finally {
+            inFlight--;
           }
-          const page = data.slice(offset, offset + Math.min(limit, options.pageCap ?? limit));
-          const total = exactCount && !options.omitCount ? String(data.length) : '*';
-          const range = page.length ? offset + '-' + (offset + page.length - 1) : '*';
-          const headers = new Headers({ 'content-type': 'application/json' });
-          if (!options.omitCountHeader) headers.set('content-range', range + '/' + total);
-          return new Response(JSON.stringify(page), {
-            headers,
-          });
         },
       },
     });
-    return { client, queries };
+    return { client, queries, getPeakInFlight: () => peakInFlight };
   }
 
   it('loads an empty history with one exact-count request', async () => {
-    const { client, queries } = createClientFixture({ totalRows: 0 });
+    const { client, queries, getPeakInFlight } = createClientFixture({ totalRows: 0 });
     assert.deepEqual(await fetchDuelRows(client, 'duel_habits', 'duel-test'), []);
     assert.deepEqual(queries, [{ offset: 0, exactCount: true }]);
+    assert.equal(getPeakInFlight(), 1);
   });
 
   it('stops at the known count for exactly one full page', async () => {
-    const { client, queries } = createClientFixture({ totalRows: 1000 });
+    const { client, queries, getPeakInFlight } = createClientFixture({ totalRows: 1000 });
     const rows = await fetchDuelRows<{ id: string }>(client, 'duel_habits', 'duel-test');
     assert.equal(rows.length, 1000);
     assert.equal(rows[0].id, 'item-0');
     assert.equal(rows[999].id, 'item-999');
     assert.deepEqual(queries, [{ offset: 0, exactCount: true }]);
+    assert.equal(getPeakInFlight(), 1);
   });
 
   it('loads all pages while requesting the exact count only once', async () => {
-    const { client, queries } = createClientFixture({ totalRows: 2500 });
+    const { client, queries, getPeakInFlight } = createClientFixture({ totalRows: 2500, constantDelayMs: 5 });
     const rows = await fetchDuelRows<{ id: string }>(client, 'duel_check_ins', 'duel-test');
     assert.equal(rows.length, 2500);
     assert.equal(rows[0].id, 'item-0');
@@ -96,10 +119,11 @@ describe('Duel history pagination', () => {
       { offset: 1000, exactCount: false },
       { offset: 2000, exactCount: false },
     ]);
+    assert.equal(getPeakInFlight(), 2);
   });
 
   it('retains full history when the backend caps each page below the requested limit', async () => {
-    const { client, queries } = createClientFixture({ totalRows: 1250, pageCap: 400 });
+    const { client, queries, getPeakInFlight } = createClientFixture({ totalRows: 1250, pageCap: 400, constantDelayMs: 5 });
     const rows = await fetchDuelRows<{ id: string }>(client, 'duel_check_ins', 'duel-test');
     assert.equal(rows.length, 1250);
     assert.equal(rows[0].id, 'item-0');
@@ -110,10 +134,11 @@ describe('Duel history pagination', () => {
       { offset: 800, exactCount: false },
       { offset: 1200, exactCount: false },
     ]);
+    assert.equal(getPeakInFlight(), 3);
   });
 
   it('treats a nonnumeric total as unavailable and reads through the empty page', async () => {
-    const { client, queries } = createClientFixture({ totalRows: 2500, omitCount: true });
+    const { client, queries, getPeakInFlight } = createClientFixture({ totalRows: 2500, omitCount: true });
     const rows = await fetchDuelRows<{ id: string }>(client, 'duel_check_ins', 'duel-test');
     assert.equal(rows.length, 2500);
     assert.deepEqual(queries, [
@@ -122,16 +147,18 @@ describe('Duel history pagination', () => {
       { offset: 2000, exactCount: true },
       { offset: 2500, exactCount: true },
     ]);
+    assert.equal(getPeakInFlight(), 1);
   });
 
   it('retains capped history when count headers are missing', async () => {
-    const { client, queries } = createClientFixture({ totalRows: 1250, pageCap: 400, omitCountHeader: true });
+    const { client, queries, getPeakInFlight } = createClientFixture({ totalRows: 1250, pageCap: 400, omitCountHeader: true });
     const rows = await fetchDuelRows<{ id: string }>(client, 'duel_check_ins', 'duel-test');
     assert.equal(rows.length, 1250);
     assert.equal(new Set(rows.map(row => row.id)).size, 1250);
     assert.equal(rows[1249].id, 'item-1249');
     assert.deepEqual(queries.map(query => query.offset), [0, 400, 800, 1200, 1250]);
     assert.ok(queries.every(query => query.exactCount));
+    assert.equal(getPeakInFlight(), 1);
   });
 
   it('propagates a later page failure instead of returning partial history', async () => {
@@ -139,6 +166,96 @@ describe('Duel history pagination', () => {
     await assert.rejects(fetchDuelRows(client, 'duel_check_ins', 'duel-test'), {
       message: 'Database unavailable', code: 'MOCK_FAILURE',
     });
-    assert.equal(queries.length, 2);
+    assert.deepEqual(queries.map(q => q.offset), [0, 1000, 2000]);
+  });
+
+  it('preserves strictly ordered output when parallel page responses arrive out of order', async () => {
+    // Delay offset 1000 by 20ms and offset 2000 by 2ms, so offset 2000 arrives first
+    const { client, queries, getPeakInFlight } = createClientFixture({
+      totalRows: 2500,
+      delayByOffset: { 1000: 20, 2000: 2 },
+    });
+    const rows = await fetchDuelRows<{ id: string; name: string }>(client, 'duel_check_ins', 'duel-test');
+    assert.equal(rows.length, 2500);
+    assert.equal(rows[0].id, 'item-0');
+    assert.equal(rows[999].id, 'item-999');
+    assert.equal(rows[1000].id, 'item-1000');
+    assert.equal(rows[1999].id, 'item-1999');
+    assert.equal(rows[2000].id, 'item-2000');
+    assert.equal(rows[2499].id, 'item-2499');
+    // Ensure all items are in exact monotonic index order
+    for (let i = 0; i < 2500; i++) {
+      assert.equal(rows[i].id, 'item-' + i);
+    }
+    assert.equal(getPeakInFlight(), 2);
+    assert.equal(queries.filter(q => q.exactCount).length, 1);
+  });
+
+  it('enforces max inflight bound of 3 concurrent requests during large pagination', async () => {
+    const { client, queries, getPeakInFlight } = createClientFixture({
+      totalRows: 6000,
+      constantDelayMs: 5,
+    });
+    const rows = await fetchDuelRows<{ id: string }>(client, 'duel_check_ins', 'duel-test');
+    assert.equal(rows.length, 6000);
+    assert.equal(rows[0].id, 'item-0');
+    assert.equal(rows[5999].id, 'item-5999');
+    assert.equal(getPeakInFlight(), 3);
+    assert.deepEqual(queries.map(q => q.offset), [0, 1000, 2000, 3000, 4000, 5000]);
+    assert.equal(queries.filter(q => q.exactCount).length, 1);
+  });
+
+  it('safely recovers from a shrinking server cap by discarding speculative pages and continuing serially', async () => {
+    // Initial page returns 400 rows, then cap drops to 200 rows.
+    // Speculative batch fired for offsets 400, 800, 1200.
+    // Offset 400 returns 200 rows. Offsets 800 and 1200 are discarded.
+    // Fallback continues serially from 600: 600, 800, 1000, 1200.
+    const { client, queries } = createClientFixture({
+      totalRows: 1250,
+      pageCap: 400,
+      laterPageCap: 200,
+    });
+    const rows = await fetchDuelRows<{ id: string }>(client, 'duel_check_ins', 'duel-test');
+    assert.equal(rows.length, 1250);
+    assert.equal(new Set(rows.map(r => r.id)).size, 1250);
+    for (let i = 0; i < 1250; i++) {
+      assert.equal(rows[i].id, 'item-' + i);
+    }
+    assert.deepEqual(queries.map(q => q.offset), [0, 400, 800, 1200, 600, 800, 1000, 1200]);
+    assert.equal(queries.length, 8);
+    // Exact count only requested on first page
+    assert.deepEqual(queries.filter(q => q.exactCount).map(q => q.offset), [0]);
+  });
+
+  it('uses serial fallback immediately when the last speculative page grows', async () => {
+    const { client, queries } = createClientFixture({
+      totalRows: 2000, pageCap: 200, laterPageCap: 500,
+      capByOffset: { 200: 200, 400: 200 },
+    });
+    const rows = await fetchDuelRows<{ id: string }>(client, 'duel_check_ins', 'duel-test');
+    assert.deepEqual(rows.map(row => row.id), Array.from({ length: 2000 }, (_, i) => 'item-' + i));
+    assert.deepEqual(queries.map(query => query.offset), [0, 200, 400, 600, 1100, 1600]);
+  });
+
+  it('safely recovers from a growing server cap by discarding overlapping speculative pages and continuing serially', async () => {
+    // Initial page returns 200 rows, then cap increases to 400 rows.
+    // Speculative batch fired for offsets 200, 400, 600.
+    // Offset 200 returns 400 rows (items 200..599).
+    // Speculative pages at 400 and 600 would overlap, so they are discarded.
+    // Fallback continues serially from 600: 600, 1000.
+    const { client, queries } = createClientFixture({
+      totalRows: 1250,
+      pageCap: 200,
+      laterPageCap: 400,
+    });
+    const rows = await fetchDuelRows<{ id: string }>(client, 'duel_check_ins', 'duel-test');
+    assert.equal(rows.length, 1250);
+    assert.equal(new Set(rows.map(r => r.id)).size, 1250);
+    for (let i = 0; i < 1250; i++) {
+      assert.equal(rows[i].id, 'item-' + i);
+    }
+    assert.deepEqual(queries.map(q => q.offset), [0, 200, 400, 600, 600, 1000]);
+    assert.equal(queries.length, 6);
+    assert.deepEqual(queries.filter(q => q.exactCount).map(q => q.offset), [0]);
   });
 });
diff --git a/src/lib/duel-sync.ts b/src/lib/duel-sync.ts
index d36bd07..0270b16 100644
--- a/src/lib/duel-sync.ts
+++ b/src/lib/duel-sync.ts
@@ -5,21 +5,87 @@ export async function fetchDuelRows<T>(client: SupabaseClient, table: string, du
   const rows: T[] = [];
   const pageSize = 1000;
   let totalCount: number | null = null;
-  for (let offset = 0; ;) {
-    const selectOptions: { count?: 'exact' } = totalCount === null ? { count: 'exact' } : {};
-    const { data, count, error } = await client
-      .from(table)
-      .select('data', selectOptions)
-      .eq('duel_id', duelId)
-      .order('id')
-      .range(offset, offset + pageSize - 1);
+  let offset = 0;
+
+  function queryRange(start: number, countExact = false) {
+    const options: { count?: 'exact' } = countExact ? { count: 'exact' } : {};
+    return client.from(table).select('data', options).eq('duel_id', duelId)
+      .order('id').range(start, start + pageSize - 1);
+  }
+
+  while (true) {
+    const { data, count, error } = await queryRange(offset, totalCount === null);
     if (error) throw error;
-    if (totalCount === null && typeof count === 'number' && Number.isFinite(count) && count >= 0) {
+    if (totalCount === null && typeof count === 'number' && Number.isInteger(count) && count >= 0) {
       totalCount = count;
     }
-    rows.push(...(data || []).map(row => row.data as T));
-    if (!data?.length || (totalCount !== null && rows.length >= totalCount)) return rows;
+    const pageRows = (data || []).map(row => row.data as T);
+    rows.push(...pageRows);
+    if (!data?.length || (totalCount !== null && rows.length >= totalCount)) {
+      return rows;
+    }
     offset += data.length;
+
+    // Once the exact count is known, read remaining pages in bounded parallel batches of up to 3.
+    if (totalCount !== null) {
+      const stride = data.length;
+      let fellBackToSerial = false;
+
+      while (offset < totalCount && !fellBackToSerial) {
+        const batchStarts: number[] = [];
+        for (let slot = 0; slot < 3 && offset + slot * stride < totalCount; slot++) {
+          batchStarts.push(offset + slot * stride);
+        }
+        if (batchStarts.length === 0) break;
+
+        const responses = await Promise.all(
+          batchStarts.map(async start => {
+            const res = await queryRange(start);
+            if (res.error) throw res.error;
+            return res;
+          })
+        );
+
+        for (let i = 0; i < responses.length; i++) {
+          const start = batchStarts[i];
+          if (start !== offset) {
+            // Unexpected gap or overlap: discard this and later speculative pages.
+            fellBackToSerial = true;
+            break;
+          }
+          const batchData = responses[i].data;
+          if (!batchData?.length) {
+            return rows;
+          }
+          rows.push(...batchData.map(row => row.data as T));
+          offset += batchData.length;
+          if (rows.length >= totalCount) {
+            return rows;
+          }
+          if (batchData.length !== Math.min(stride, totalCount - start)) {
+            // Changed page size: discard later speculative pages and fall back.
+            fellBackToSerial = true;
+            break;
+          }
+        }
+      }
+
+      // If an unexpected short page or gap occurred, complete remaining rows serially.
+      while (offset < totalCount) {
+        const { data: serialData, error: serialError } = await queryRange(offset);
+        if (serialError) throw serialError;
+        if (!serialData?.length) {
+          return rows;
+        }
+        rows.push(...serialData.map(row => row.data as T));
+        offset += serialData.length;
+        if (rows.length >= totalCount) {
+          return rows;
+        }
+      }
+
+      return rows;
+    }
   }
 }
 

From 3ec516954c4eeec5e07db446283091a6a3f80883 Mon Sep 17 00:00:00 2001
From: Maseeek <maseeekyt@gmail.com>
Date: Mon, 12 Oct 2026 06:56:41 +0100
Subject: [PATCH 09/10] docs(performance): record final verification and Gemini
 reviews

Refresh final-source loading, pagination and write-race evidence. Preserve separate Standards, Spec and trail reports with parent responses, sample provenance and explicit hosted/mobile limitations.
---
 docs/performance/2026-10-12/README.md         | 12 +++++
 docs/performance/2026-10-12/decisions.tsv     |  4 ++
 docs/performance/2026-10-12/duel-cap400.json  |  6 ++-
 .../2026-10-12/duel-loading-cap400.json       | 22 ++++----
 docs/performance/2026-10-12/duel-race.json    | 14 ++---
 docs/performance/2026-10-12/duel-reload.json  |  6 ++-
 docs/performance/2026-10-12/spec-review.md    | 14 +++++
 .../2026-10-12/standards-review.md            | 41 +++++++++++++++
 .../2026-10-12/trail-review-before-paging.md  | 51 +++++++++++++++++++
 docs/performance/2026-10-12/trail-review.md   | 44 ++++++++++++++++
 10 files changed, 193 insertions(+), 21 deletions(-)
 create mode 100644 docs/performance/2026-10-12/spec-review.md
 create mode 100644 docs/performance/2026-10-12/standards-review.md
 create mode 100644 docs/performance/2026-10-12/trail-review-before-paging.md
 create mode 100644 docs/performance/2026-10-12/trail-review.md

diff --git a/docs/performance/2026-10-12/README.md b/docs/performance/2026-10-12/README.md
index 561723d..7194597 100644
--- a/docs/performance/2026-10-12/README.md
+++ b/docs/performance/2026-10-12/README.md
@@ -62,6 +62,18 @@ The entry check uses empty auth for the default account screen, then a synthetic
 - [Account entry and onboarding](entry-performance.json): five navigation samples per flow and build, plus mode switching and a saved first plan.
 - [Large authenticated history loading](duel-loading-cap400.json): five samples per build, full 14,600-record history, and a 400-row server cap.
 
+Final source `69d22fe` passes 170 tests, type checking, lint, and anonymous/configured production builds. The final loading repeat measures medians of 2,365.4 ms before and 1,018.5 ms after. Final Duel fixtures also retain 2,500 records under both caps, reduce normal bursts from 140 to 7 requests and capped bursts from 220 to 11, and keep optimistic Check-ins checked during an overlapping read.
+
+## Independent review and remaining work
+
+[Standards](standards-review.md) and [Spec](spec-review.md) independently review source `69d22fe`. The [final trail review](trail-review.md) extends the [earlier trail review](trail-review-before-paging.md). Reports are retained with their original findings; the parent responses below explain the disposition.
+
+No hard standards or demonstrated correctness failures were reported. Optional code cleanup remains deferred. Two independent deferred wrappers share the JavaScript module cache; moving a wrapper into the imported modal would need care to preserve its lazy boundary. Pointer/focus warming directly supports the authorized loading goal and retains the deployment guard. The removed Apple Health poll always received HTTP 410 at baseline and exited before changing state; functioning wearable paths remain intact.
+
+Hosted database/RLS and physical mobile testing remain unavailable. Mobile measurements use emulation. In-flight read cancellation and further calculation proposals remain follow-up work; their suggested savings are unimplemented estimates. Existing offset pagination does not promise a consistent database snapshot during concurrent remote inserts or deletions.
+
+The final trail reviewer checked the refreshed browser artifact but attributed its newer medians to historical row 53. That row records the earlier 2,385.8→1,034.4 ms sample; row 55 records the final 2,365.4→1,018.5 ms repeat. The append-only trail preserves both measurements. Documentation packaging and final handoff actions follow the source review boundary.
+
 Earlier instrumentation that polled and parsed the entire stored state inside the timed interaction was superseded. The accepted interaction artifact observes one real storage write and parses its value after timing. The mock also exposes `Content-Range` to the browser and waits for quiescence across pagination gaps. These corrections are recorded in the decision trail.
 
 The [decision trail](decisions.tsv) records accepted and abandoned work. Earlier diagnosis logs and quota-interrupted child reports remain local under `.scratch/performance-overnight`; the accepted measurements above and their reusable harnesses are committed here.
diff --git a/docs/performance/2026-10-12/decisions.tsv b/docs/performance/2026-10-12/decisions.tsv
index 90aeb7f..51c86ec 100644
--- a/docs/performance/2026-10-12/decisions.tsv
+++ b/docs/performance/2026-10-12/decisions.tsv
@@ -53,3 +53,7 @@ ts	phase	decision	why	evidence	result
 2026-10-12T05:49:48Z	paging-review	Fix final-slot page growth and share the local range builder	Independent Gemini review found two avoidable speculative requests after a cap grows	.scratch/performance-overnight/pagination-review-r5.md; src/lib/duel-sync.ts; src/lib/duel-sync.test.ts	Added ordered full-history regression; integer count validation; final checks running
 2026-10-12T05:49:48Z	loading	Measure complete authenticated screen loading after bounded pagination	Accept app improvement only from a production browser reproduction	.scratch/performance-overnight/duel-loading-before-pagination.json; docs/performance/2026-10-12/duel-loading-cap400.json; scripts/verify-duel-performance.cjs	Five samples: baseline2385.8ms current1034.4ms; all14600 records retained; final-source rerun pending
 2026-10-12T05:49:48Z	scope	Leave cancellation and additional calculation proposals for later work	Remaining deadline allows verification of accepted paging; cancellation needs read/write lifecycle tests	.scratch/performance-overnight/cancellation-audit-r4.md; .scratch/performance-overnight/hotpaths-r5.md	No cancellation or further calculator change; estimated cancellation savings are hypotheses, not measured app results
+2026-10-12T05:53:00Z	final-verify	Repeat authenticated loading on fresh final-source production builds	Verify the actual committed paging changes after review fixes	.scratch/performance-overnight/final-check.log; .scratch/performance-overnight/final-build.log; .scratch/performance-overnight/final-auth-build.log; docs/performance/2026-10-12/duel-loading-cap400.json	170 tests/typecheck/lint/builds pass; five samples baseline2365.4ms current1018.5ms, all14600 records retained
+2026-10-12T05:54:26Z	final-behavior	Repeat Duel burst, lower-cap history and optimistic Check-in race on final source	Parallel loading must preserve local writes and complete records	.scratch/performance-overnight/final-duel-cap1000.json; .scratch/performance-overnight/final-duel-cap400.json; .scratch/performance-overnight/final-duel-race.json	All pass with no page errors; burst140to7 normal and220to11 capped;2500records retained; current Check-in never becomes unchecked
+2026-10-12T05:54:26Z	review	Read final independent Standards and Spec reports on69d22fe	Preserve review findings and record parent responses without inventing new requirements	.scratch/performance-overnight/standards-final-r6.md; .scratch/performance-overnight/spec-final-r6.md; src/app/api/sync/apple-health/route.ts	No hard standards or correctness failures; hosted/physical limits and cancellation deferred; hover preload authorized by speed goal; removed poll already410 atbaseline
+2026-10-12T05:55:54Z	trail-audit	Keep final review and correct its historical sample attribution	Reviewer followed the refreshed evidence but assigned newer medians to an earlier row	docs/performance/2026-10-12/trail-review.md; docs/performance/2026-10-12/decisions.tsv:54; docs/performance/2026-10-12/README.md	Row53 retains earlier2385.8to1034.4ms; row55 verifies final2365.4to1018.5ms; source review covers69d22fe; later changes documentation only
diff --git a/docs/performance/2026-10-12/duel-cap400.json b/docs/performance/2026-10-12/duel-cap400.json
index 5ea9c13..1492d8d 100644
--- a/docs/performance/2026-10-12/duel-cap400.json
+++ b/docs/performance/2026-10-12/duel-cap400.json
@@ -1,7 +1,9 @@
 {
-  "measuredAt": "2026-10-12T02:01:49.858Z",
+  "measuredAt": "2026-10-12T05:52:59.158Z",
   "pageCap": 400,
-  "method": "Production copies configured only for a Playwright-routed localhost Supabase mock. 2500 CheckIns, 50ms per HTTP response, real Phoenix subscriptions/events, no live database or auth. Counts verify reload amplification, not hosted latency.",
+  "historyCount": 2500,
+  "samples": 1,
+  "method": "Production copies configured only for a Playwright-routed localhost Supabase mock. 2500 CheckIns, 50ms per HTTP response, real Phoenix subscriptions/events, no live database or auth. New browser context per sample. Initial rendering measured inside the page from navigation start to Daily Ritual and a Check-in control, followed by two animation frames. Counts verify reload amplification; loading times include localhost JS and rendering, not hosted latency.",
   "variants": {
     "baseline": {
       "initialQueries": [
diff --git a/docs/performance/2026-10-12/duel-loading-cap400.json b/docs/performance/2026-10-12/duel-loading-cap400.json
index 76f49b1..1b90748 100644
--- a/docs/performance/2026-10-12/duel-loading-cap400.json
+++ b/docs/performance/2026-10-12/duel-loading-cap400.json
@@ -1,5 +1,5 @@
 {
-  "measuredAt": "2026-10-12T04:32:55.332Z",
+  "measuredAt": "2026-10-12T05:51:52.524Z",
   "pageCap": 400,
   "historyCount": 14600,
   "samples": 5,
@@ -7,7 +7,7 @@
   "variants": {
     "baseline": [
       {
-        "initialRitualMs": 2473.199999988079,
+        "initialRitualMs": 2492.5999999940395,
         "initialQueries": [
           {
             "phase": "initial",
@@ -349,7 +349,7 @@
         "errors": []
       },
       {
-        "initialRitualMs": 2385.7999999970198,
+        "initialRitualMs": 2371.3999999910593,
         "initialQueries": [
           {
             "phase": "initial",
@@ -691,7 +691,7 @@
         "errors": []
       },
       {
-        "initialRitualMs": 2388.4000000059605,
+        "initialRitualMs": 2365.3999999910593,
         "initialQueries": [
           {
             "phase": "initial",
@@ -1033,7 +1033,7 @@
         "errors": []
       },
       {
-        "initialRitualMs": 2371,
+        "initialRitualMs": 2358.4000000059605,
         "initialQueries": [
           {
             "phase": "initial",
@@ -1375,7 +1375,7 @@
         "errors": []
       },
       {
-        "initialRitualMs": 2379.2000000029802,
+        "initialRitualMs": 2363.8999999910593,
         "initialQueries": [
           {
             "phase": "initial",
@@ -1719,7 +1719,7 @@
     ],
     "current": [
       {
-        "initialRitualMs": 1094,
+        "initialRitualMs": 1059.699999988079,
         "initialQueries": [
           {
             "phase": "initial",
@@ -2061,7 +2061,7 @@
         "errors": []
       },
       {
-        "initialRitualMs": 1034.4000000059605,
+        "initialRitualMs": 1017.1000000089407,
         "initialQueries": [
           {
             "phase": "initial",
@@ -2403,7 +2403,7 @@
         "errors": []
       },
       {
-        "initialRitualMs": 1047.1000000089407,
+        "initialRitualMs": 1018.5,
         "initialQueries": [
           {
             "phase": "initial",
@@ -2745,7 +2745,7 @@
         "errors": []
       },
       {
-        "initialRitualMs": 1028.7999999970198,
+        "initialRitualMs": 1017.0999999940395,
         "initialQueries": [
           {
             "phase": "initial",
@@ -3087,7 +3087,7 @@
         "errors": []
       },
       {
-        "initialRitualMs": 1024.2999999970198,
+        "initialRitualMs": 1024.8999999910593,
         "initialQueries": [
           {
             "phase": "initial",
diff --git a/docs/performance/2026-10-12/duel-race.json b/docs/performance/2026-10-12/duel-race.json
index 83553c5..b34edfd 100644
--- a/docs/performance/2026-10-12/duel-race.json
+++ b/docs/performance/2026-10-12/duel-race.json
@@ -1,7 +1,9 @@
 {
-  "measuredAt": "2026-10-12T02:41:43.860Z",
+  "measuredAt": "2026-10-12T05:52:59.164Z",
   "pageCap": 1000,
-  "method": "Production copies configured only for a Playwright-routed localhost Supabase mock. 2500 CheckIns, 50ms per HTTP response, real Phoenix subscriptions/events, no live database or auth. Counts verify reload amplification, not hosted latency.",
+  "historyCount": 2500,
+  "samples": 1,
+  "method": "Production copies configured only for a Playwright-routed localhost Supabase mock. 2500 CheckIns, 50ms per HTTP response, real Phoenix subscriptions/events, no live database or auth. New browser context per sample. Initial rendering measured inside the page from navigation start to Daily Ritual and a Check-in control, followed by two animation frames. Counts verify reload amplification; loading times include localhost JS and rendering, not hosted latency.",
   "variants": {
     "baseline": {
       "queries": [
@@ -121,15 +123,15 @@
       "trace": [
         {
           "checked": true,
-          "ms": 616.3999999985099
+          "ms": 641.0999999940395
         },
         {
           "checked": false,
-          "ms": 757.1999999955297
+          "ms": 780.7000000029802
         },
         {
           "checked": true,
-          "ms": 823.5
+          "ms": 845.7000000029802
         }
       ],
       "finalChecked": true,
@@ -253,7 +255,7 @@
       "trace": [
         {
           "checked": true,
-          "ms": 638.7000000029802
+          "ms": 592.4000000059605
         }
       ],
       "finalChecked": true,
diff --git a/docs/performance/2026-10-12/duel-reload.json b/docs/performance/2026-10-12/duel-reload.json
index 646369b..e6b4933 100644
--- a/docs/performance/2026-10-12/duel-reload.json
+++ b/docs/performance/2026-10-12/duel-reload.json
@@ -1,7 +1,9 @@
 {
-  "measuredAt": "2026-10-12T02:10:42.388Z",
+  "measuredAt": "2026-10-12T05:52:59.159Z",
   "pageCap": 1000,
-  "method": "Production copies configured only for a Playwright-routed localhost Supabase mock. 2500 CheckIns, 50ms per HTTP response, real Phoenix subscriptions/events, no live database or auth. Counts verify reload amplification, not hosted latency.",
+  "historyCount": 2500,
+  "samples": 1,
+  "method": "Production copies configured only for a Playwright-routed localhost Supabase mock. 2500 CheckIns, 50ms per HTTP response, real Phoenix subscriptions/events, no live database or auth. New browser context per sample. Initial rendering measured inside the page from navigation start to Daily Ritual and a Check-in control, followed by two animation frames. Counts verify reload amplification; loading times include localhost JS and rendering, not hosted latency.",
   "variants": {
     "baseline": {
       "initialQueries": [
diff --git a/docs/performance/2026-10-12/spec-review.md b/docs/performance/2026-10-12/spec-review.md
new file mode 100644
index 0000000..c58d977
--- /dev/null
+++ b/docs/performance/2026-10-12/spec-review.md
@@ -0,0 +1,14 @@
+# Spec Review: Issue #63 (69d22fe vs e7b284e)
+
+### 1. Missing or Partial Requirements
+- **Physical mobile and hosted infrastructure verification**: Spec requires: *"Capture production loading and representative large-history interaction measurements before changing code"* and *"Document measurements, remaining limits, and review findings"*. Verification was conducted exclusively on localhost Chromium using synthetic 4× CPU throttling, responsive viewport emulation, and 50ms mock HTTP delays. Hosted database latency/RLS and physical mobile hardware remain unverified due to infrastructure constraints (connector 403, CLI unauthenticated). This is recorded as an acknowledged boundary in [`docs/performance/2026-10-12/README.md`](file:///home/maciek/Documents/do-it/docs/performance/2026-10-12/README.md).
+- **In-flight query cancellation**: Spec requires: *"Fix measured bottlenecks with before/after evidence and preserve observable product behavior."* While bounded 3-wide parallel pagination is implemented in `69d22fe`, aborting in-flight history reads on unmount was intentionally deferred ([`decisions.tsv`](file:///home/maciek/Documents/do-it/docs/performance/2026-10-12/decisions.tsv)). Queries run to completion without `AbortSignal` propagation.
+
+### 2. Scope Creep
+- **Apple Health polling removal**: Spec mandates *"...preserving scoring, offline persistence, Duel isolation, wearable behavior, and both appearance modes"* and brief notes: *"Existing assigned issues 32(health)... are out of scope."* Commit `fbc0c76` deleted `pullAppleHealthPending` polling in [`src/lib/store.tsx`](file:///home/maciek/Documents/do-it/src/lib/store.tsx). Although `/api/sync/apple-health` returned HTTP 410 Gone at baseline (confirming no reachable wearable regression), touching health sync touched an assigned out-of-scope domain.
+- **Intent preloading**: Spec asked to: *"Make loading, navigation, and Check-ins faster"*. Pre-warming chunk imports on hover/focus (`Header`, `DesktopSidebar`, `BottomNav`) in `f8d7837` represents unrequested proactive preloading, though it preserves deployment guards.
+
+### 3. Implementation Correctness & Preserved Invariants
+- **Pagination & history preservation**: Spec mandates: *"...preserving scoring, offline persistence, Duel isolation... and complete history."* Proven correct. `69d22fe` in [`src/lib/duel-sync.ts`](file:///home/maciek/Documents/do-it/src/lib/duel-sync.ts) implements bounded 3-wide batching with contiguous-prefix serial fallback on cap shifts, integer count validation (`Number.isInteger(count)`), and full query ranges. Verified across 14,600 rows ([`duel-loading-cap400.json`](file:///home/maciek/Documents/do-it/docs/performance/2026-10-12/duel-loading-cap400.json): 2385.8ms to 1034.4ms; 170 tests passing).
+- **Duel isolation & write barriers**: Overlapping reads during local writes are rejected via `duelQueueRef` ([`src/lib/store.tsx`](file:///home/maciek/Documents/do-it/src/lib/store.tsx)), eliminating optimistic Check-in flicker ([`duel-race.json`](file:///home/maciek/Documents/do-it/docs/performance/2026-10-12/duel-race.json)).
+- **Core scoring & persistence**: Duplicate-first streak precedence, rest bridging, and 365-day caps are preserved via `checkInIndex` ([`src/lib/score-calculator.ts`](file:///home/maciek/Documents/do-it/src/lib/score-calculator.ts)). LocalStorage durability remains strictly synchronous.
diff --git a/docs/performance/2026-10-12/standards-review.md b/docs/performance/2026-10-12/standards-review.md
new file mode 100644
index 0000000..070b47a
--- /dev/null
+++ b/docs/performance/2026-10-12/standards-review.md
@@ -0,0 +1,41 @@
+# Standards Review (Commit 69d22fe)
+
+## Documented Standards
+**0 hard violations.** The diff strictly follows repository guidelines:
+- **`AGENTS.md` & `docs/agent-workflow.md`**: No prohibited mutations, lockfile modifications, or credential leaks. Scoped strictly to authorized performance requirements.
+- **`ts-best-practices`**: Strongly typed. Count validation in `src/lib/duel-sync.ts:18` uses `Number.isInteger(count) && count >= 0` rather than loose truthiness. External Supabase responses preserve proper error handling (`if (error) throw error`). Unboxing via `row.data as T` preserves existing generic interface consistency.
+- **`react-best-practices`**: Deferred views (`src/components/DeferredView.tsx`) consume stable immutable snapshots via `useSyncExternalStore` without effect synchronization anti-patterns.
+- **`principle-laziness-protocol`**: The concurrency enhancement in `duel-sync.ts` implements bounded parallel requests (batch limit 3) directly without inventing an unneeded generic task scheduler. Shared `queryRange` helper deduplicates range query construction.
+
+---
+
+## Smell Baseline (Judgement Calls)
+
+### 1. Duplicated Code
+- **`src/lib/duel-sync.ts:59-62, 79-82`**
+  ```ts
+  rows.push(...batchData.map(row => row.data as T));
+  offset += batchData.length;
+  if (rows.length >= totalCount) return rows;
+  ```
+  The row unwrapping, offset advance, and completion threshold checks are duplicated verbatim across the parallel batch collector and serial fallback loop. A small local helper (e.g. `appendPage(data)`) would centralize pagination termination and buffer appending.
+- **`src/components/HabitCard.tsx:28` & `src/components/TodayView.tsx:27`**
+  `createDeferredView` is invoked independently in both modules for `ProofGalleryModal`. Creating and exporting a shared deferred component directly in `ProofGalleryModal.tsx` would consolidate loading and cache state.
+
+### 2. Mysterious Name
+- **`src/lib/duel-sync.ts:29`**
+  ```ts
+  const stride = data.length;
+  ```
+  `stride` stores the discovered first-page size. `effectivePageSize` or `pageSizeStride` would more accurately describe its semantic role in speculative offset calculations.
+
+### 3. Speculative Generality
+- **`src/lib/deferred-resource.ts:10`**
+  ```ts
+  activate: (load: () => Promise<T>) => Promise<T> = loadCurrentPage
+  ```
+  The `activate` strategy parameter exists solely for test mocking and is unused in production callers.
+
+### 4. Data Clumps
+- **`src/lib/score-calculator.ts:379-385`**
+  `calculateHabitStreak` accepts `(checkIns, restDays, today, indexed)` as a clump where `checkIns` is bypassed when `indexed` is present.
diff --git a/docs/performance/2026-10-12/trail-review-before-paging.md b/docs/performance/2026-10-12/trail-review-before-paging.md
new file mode 100644
index 0000000..4d1f1ee
--- /dev/null
+++ b/docs/performance/2026-10-12/trail-review-before-paging.md
@@ -0,0 +1,51 @@
+# Overnight Performance Run Decision Trail Review (Round 4)
+
+**Reviewer Model**: `gemini-3.7-flash-high`  
+**Parent Agent**: `gpt-6.1-sol` (T3 Thread `f680d6b6-ccda-4e69-b783-001f03f4f08e`)  
+**Coverage Boundary**: Baseline `e7b284e` through commit `400fbfe` (`main`); `decisions.tsv` Rows 1–50 (`00:07:36Z`–`04:29:27Z`).  
+**Scope Notice**: Evaluates accepted changes only. Does not grant blanket approval for concurrent or subsequent edits (e.g., in-flight `duel-sync.ts` parallel pagination).
+
+---
+
+### 1. Audit of Claims vs. Durable Receipts
+
+All 50 rows in `docs/performance/2026-10-12/decisions.tsv` were audited against repository artifacts and the parent timeline. All 118 evidence file pointers resolve. Row 48 (`04:18:58Z`) correctly superseded the removed `calculations-r2.test.ts` from Row 10 with `calculation-regressions.test.ts`.
+
+| Row & Timestamp | Phase | Claimed Metric / Action | Verified Receipt | Status / Severity |
+|---|---|---|---|---|
+| **13** `00:47:17Z` | `loading` | First open: Progress ~33ms, Duel ~40ms, Settings ~30ms | `deferred-first-navigation.json` | Verified (Low) |
+| **20, 24** `01:38:59Z` | `sync` | 20-event burst coalesced to 1 reload; 5 exact counts | `authenticated-reload.json` | Verified (Low) |
+| **24** `01:43:00Z` | `interact` | Check-in median 48.6→41.4ms; Undo 53.3→45.4ms | `interleaved-interactions.json` | Verified (Low) |
+| **27** `01:53:18Z` | `race` | Check-in stays checked across overlapping read/write | `authenticated-race-after.json` | Verified (Low) |
+| **28** `01:53:18Z` | `cap` | Retains full 2,500 records under 400-row cap | `authenticated-reload-cap400.json` | Verified (Low) |
+| **37** `03:13:41Z` | `preview` | Protected Vercel preview blocked by MCP 403 / unauthenticated CLI | `vercel-whoami.json`, `whoami.log` | Access limitation (Medium) |
+| **39, 41** `03:24:55Z` | `entry` | Account 380→81ms; Onboarding 497→197ms; plan saved | `entry-performance.json` | Verified (Low) |
+| **45** `04:07:59Z` | `prototype` | Naive parallel dropped 400 rows (850/1250) on shrinking cap; rejected | `pagination-prototype.json` | Verified (Low) |
+
+---
+
+### 2. Methodological Rigor & Bias Corrections
+
+The trail shows exceptional discipline in discarding compromised metrics:
+1. **Persistence Polling Bias (Row 22, `01:39:00Z`)**: Discarded timings polluted by repeated 2.3MB JSON state parsing; replaced with one-write observation.
+2. **Mock Content-Range (Row 23, `01:43:00Z`)**: Exposed missing headers to eliminate spurious unknown-count fallbacks.
+3. **Pagination Quiescence (Row 25, `01:44:24Z`)**: Fixed premature completion checks across 400-row query gaps.
+4. **Locator Quantization (Row 38, `03:20:56Z`)**: Replaced 864ms locator retry waits with in-browser readiness probes.
+5. **Short-Page Invariant (Row 45, `04:07:59Z`)**: Promptly rejected naive parallel fetching when shrinking server caps exposed silent data loss.
+
+---
+
+### 3. Acceptance Gaps and Residual Risks
+
+1. **Hosted Infrastructure Limitation vs. Failure (Row 37)**: Preview testing failed due to team SSO/403 and unauthenticated CLI credentials (`vercel-whoami.json`). This is an external access barrier, not code failure, but leaves real-world database latency and RLS unmeasured.
+2. **Synthetic Hardware Constraints**: Mobile verification relied on headless Chromium with synthetic 4× CPU throttling and viewport resizing (`repro-interactions-mobile.json`); physical mobile hardware and touch events remain unverified.
+3. **Apple Health Removal (Commit `fbc0c76`)**: Deleting the `pullAppleHealthPending` hook was flagged as scope creep, but baseline inspection confirms `/api/sync/apple-health` already returned HTTP 410 at `e7b284e`. Removing dead network traffic preserves wearable invariants while eliminating polling overhead.
+
+---
+
+## Attention
+
+reviewed by gemini-3.7-flash-high
+- Row 37 (`03:13:41Z`): Hosted preview remains unverified due to team 403 / CLI credentials; RLS and network latency depend solely on local mock validation.
+- Rows 24 & 29: Mobile validation is synthetic (4× CPU throttling, viewport emulation); physical device behavior unmeasured.
+- Commit `400fbfe` boundary: Accepted changes are sound, but serial history loading and in-flight cancellation remain open until the concurrent `duel-sync.ts` task finishes and passes separate review.
diff --git a/docs/performance/2026-10-12/trail-review.md b/docs/performance/2026-10-12/trail-review.md
new file mode 100644
index 0000000..254a3fc
--- /dev/null
+++ b/docs/performance/2026-10-12/trail-review.md
@@ -0,0 +1,44 @@
+# Overnight Performance Run Decision Trail Review (Final Round 6)
+
+**Reviewer Model**: `gemini-3.7-flash-high`  
+**Parent Agent**: `gpt-6.1-sol` (T3 Thread `f680d6b6-ccda-4e69-b783-001f03f4f08e`)  
+**Coverage Boundary**: Commit `69d22fe` (`main`); `decisions.tsv` Rows 51–54 (`04:32:48Z`–`05:49:48Z`). Extends `trail-review-r4.md` (Rows 1–50, `400fbfe`).  
+
+---
+
+### 1. Audit of Rows 51–54 vs. Durable Receipts
+
+All evidence pointers in Rows 51–54 resolve to durable artifacts. Pinned commit `69d22fe` contains clean source and verification receipts.
+
+| Row & Timestamp | Phase | Claimed Metric / Action | Verified Receipt | Status / Severity |
+|---|---|---|---|---|
+| **51** `04:32:48Z` | `pagination` | Bounded (max 3) parallel history paging with serial fallback | `src/lib/duel-sync.ts`, `pagination-parent-check.log` | Verified (Low) |
+| **52** `05:49:48Z` | `paging-review` | Fix final-slot cap growth, validate integer counts, share range builder | `pagination-review-r5.md`, `src/lib/duel-sync.test.ts`, `final-check.log` | Verified (Low) |
+| **53** `05:49:48Z` | `loading` | Authenticated load 2365.4ms→1018.5ms (median 5 samples); 14,600 rows retained | `duel-loading-cap400.json`, `verify-duel-performance.cjs` | Verified (Low) |
+| **54** `05:49:48Z` | `scope` | Defer in-flight cancellation and hotpath CPU micro-opts; reject 94% savings claim | `cancellation-audit-r4.md`, `hotpaths-r5.md` | Verified (Low) |
+
+---
+
+### 2. Methodological Rigor & Verification of Receipts
+
+1. **Paging Correctness & Adversarial Defense (Rows 51–52)**:
+   - Parent incorporated adversarial SDK review (`pagination-review-r5.md`), fixing avoidable speculative queries when server caps grow (`batchData.length !== Math.min(stride, totalCount - start)`).
+   - Added unit regressions covering offsets `[0, 200, 400, 600, 1100, 1600]`.
+   - Verified in `final-check.log`: 170 tests pass (0 failures), clean typecheck, lint, and production builds (`final-build.log`, `final-auth-build.log`).
+2. **Browser Loading Verification (Row 53)**:
+   - Evaluated 14,600 check-ins under a 400-row cap in fresh browser contexts across 5 alternating samples (`scripts/verify-duel-performance.cjs`).
+   - Prior to pagination, `duel-loading-before-pagination.json` recorded baseline median 2363.0ms vs current 2363.1ms.
+   - Post-pagination (`duel-loading-cap400.json`): baseline median 2365.4ms vs current median 1018.5ms (57% reduction).
+   - Trace verifies exact count requested only once (`start: 0, exact: true`), concurrency strictly bounded to 3 (`peakByTable.duel_check_ins: 3`), and Activity feed verified all 14,600 items (`visibleHistory: 14600`).
+3. **Scope Discipline (Row 54)**:
+   - Rejected unsubstantiated claims: `cancellation-audit-r4.md` proposed aborting in-flight reads with a speculative ~94% reload bandwidth/CPU saving. Parent rightly treated this as a hypothesis and deferred implementation to avoid risking write-pipeline stability. No cancellation code or false claims entered the tree.
+
+---
+
+## Attention
+
+reviewed by gemini-3.7-flash-high
+- **Coverage & Baseline**: Commits `400fbfe` to `69d22fe`; `decisions.tsv` Rows 51–54. Verified against parent T3 activity (positions 1171–2043) and test/build logs.
+- **Hosted Environment (Row 37)**: Hosted Vercel preview unverified due to team 403 / CLI credentials; validation relies on production builds with localhost mock.
+- **Mobile Hardware (Rows 24, 29)**: Mobile figures reflect Chromium emulation with 4× CPU throttling; physical mobile devices remain unmeasured.
+- **Cancellation Claims (Row 54)**: The ~94% cancellation gain from `cancellation-audit-r4.md` is an unverified hypothesis and correctly omitted from reported achievements.

From 9ee71f99039159352db2304f1592ffdbd9f92f34 Mon Sep 17 00:00:00 2001
From: Maseeek <maseeekyt@gmail.com>
Date: Mon, 12 Oct 2026 06:59:05 +0100
Subject: [PATCH 10/10] docs(performance): record review handoff

Record the verified source, passing checks and human review boundary before the fixed overnight deadline. Remaining infrastructure limitations and deferred optimizations are documented in the evidence.
---
 docs/performance/2026-10-12/decisions.tsv | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/performance/2026-10-12/decisions.tsv b/docs/performance/2026-10-12/decisions.tsv
index 51c86ec..a3a6aa3 100644
--- a/docs/performance/2026-10-12/decisions.tsv
+++ b/docs/performance/2026-10-12/decisions.tsv
@@ -57,3 +57,4 @@ ts	phase	decision	why	evidence	result
 2026-10-12T05:54:26Z	final-behavior	Repeat Duel burst, lower-cap history and optimistic Check-in race on final source	Parallel loading must preserve local writes and complete records	.scratch/performance-overnight/final-duel-cap1000.json; .scratch/performance-overnight/final-duel-cap400.json; .scratch/performance-overnight/final-duel-race.json	All pass with no page errors; burst140to7 normal and220to11 capped;2500records retained; current Check-in never becomes unchecked
 2026-10-12T05:54:26Z	review	Read final independent Standards and Spec reports on69d22fe	Preserve review findings and record parent responses without inventing new requirements	.scratch/performance-overnight/standards-final-r6.md; .scratch/performance-overnight/spec-final-r6.md; src/app/api/sync/apple-health/route.ts	No hard standards or correctness failures; hosted/physical limits and cancellation deferred; hover preload authorized by speed goal; removed poll already410 atbaseline
 2026-10-12T05:55:54Z	trail-audit	Keep final review and correct its historical sample attribution	Reviewer followed the refreshed evidence but assigned newer medians to an earlier row	docs/performance/2026-10-12/trail-review.md; docs/performance/2026-10-12/decisions.tsv:54; docs/performance/2026-10-12/README.md	Row53 retains earlier2385.8to1034.4ms; row55 verifies final2365.4to1018.5ms; source review covers69d22fe; later changes documentation only
+2026-10-12T05:59:05Z	handoff	Freeze verified source and make PR64 ready for human review before the fixed7am stop	Final source checks and independent reviews pass; merge waits for human review	commit69d22fe; commit3ec5169; https://github.com/Maseeek/do-it/pull/64; docs/performance/2026-10-12/README.md	170 tests/builds/browserchecks pass; CI/Vercel green at3ec5169; all20delegatedtasks terminal; no further app work; deadline cleanup pending