diff --git a/tests/unit/README_RaceConditionTest.md b/tests/unit/README_RaceConditionTest.md
new file mode 100644
index 00000000..f0deee3a
--- /dev/null
+++ b/tests/unit/README_RaceConditionTest.md
@@ -0,0 +1,141 @@
+# Onyx sourceValue issues
+
+These tests demonstrate and prove multiple issues with Onyx sourceValue handling:
+1. **Race Condition**: Multiple discrete updates batched → only first `sourceValue` visible
+2. **Logic Bug**: `useSidebarOrderedReports` conditional logic ignores available `sourceValues`
+3. **Stale sourceValues**: `sourceValue` preserves the keys of the latest onyx update during unrelated rerenders
+
+See the thread in [#quality](https://expensify.slack.com/archives/C05LX9D6E07/p1755792968968239?thread_ts=1755543034.080259&cid=C05LX9D6E07) for more info
+
+## Test Files
+
+**`simpleSourceValueRaceConditionDemo.ts`** - Pure race condition test proving batching loses intermediate `sourceValues`
+**`useSidebarOrderedReportsVulnerability.ts`** - Logic bug and compound issue tests replicating production patterns
+**`staleSourceValueTest`** - Test demonstrating that sourceValue persists during unrelated renders, leading to unnecessary cache busing
+
+## How to Run the Tests
+
+```bash
+# Run the race condition test
+npm test -- tests/unit/simpleSourceValueRaceConditionDemo.ts
+
+# Run the useSidebarOrderedReports display bug tests
+npm test -- tests/unit/useSidebarOrderedReportsDisplayBug.ts
+
+# Run the staleSourceValueTest tests
+npm test -- tests/unit/staleSourceValueTest.ts
+
+# Or run all 3 at once
+npm test -- tests/unit/simpleSourceValueRaceConditionDemo.ts tests/unit/useSidebarOrderedReportsDisplayBug.ts tests/unit/staleSourceValueTest.ts
+```
+
+# The race condition test and what it proves
+
+### The Race Condition Mechanism
+
+1. **Multiple Discrete Updates**: The test performs 3 separate Onyx operations:
+   - `Onyx.merge(collection_item1)` - Add first collection item
+   - `Onyx.merge(collection_item2)` - Add second collection item  
+   - `Onyx.merge(collection_item3)` - Add third collection item
+
+2. **React Batching**: Due to `unstable_batchedUpdates` and setTimeout-based batching in Onyx, all updates get batched into a single render
+
+   **How this works internally:**
+   - When Onyx updates occur, they're queued in `batchUpdatesQueue` (in `OnyxUtils.ts`)
+   - `maybeFlushBatchUpdates()` uses `setTimeout(0)` to defer processing to the next event loop tick
+   - Inside that timeout, `unstable_batchedUpdates(() => { updatesCopy.forEach(applyUpdates) })` wraps all queued updates
+   - This forces React to treat all updates as a single batch, triggering only one render
+   - The `sourceValue` gets set by the first update, then overwritten by subsequent updates, but only the final state is visible to the component
+
+3. **Lost sourceValue Information**: Only the first `sourceValue` is visible to the component, losing information about subsequent updates
+
+### Expected vs Actual Behavior
+
+**Expected** (without race condition):
+```
+Update 1: sourceValue = {test_items_item1: {step: 1, status: 'started'}}
+Update 2: sourceValue = {test_items_item2: {step: 2, status: 'processing'}} 
+Update 3: sourceValue = {test_items_item3: {step: 3, status: 'completed'}}
+```
+
+**Actual** (with race condition):
+```
+Single Render: sourceValue = {test_items_item1: {step: 1, status: 'started'}}
+// Lost: step 2 and step 3 information!
+```
+
+## Test Output Example
+
+When you run the simple demo test, you'll see output like:
+
+```
+=== Starting the race condition test ===
+About to perform 3 discrete updates that should be batched...
+
+=== RESULTS ===
+Expected: 3 discrete updates → 3 different sourceValues
+Actual: 1 sourceValue(s) received
+Renders: 1 (due to React batching)
+
+SourceValues received: [
+  {
+    renderCount: 3,
+    sourceValue: { test_items_item1: { step: 1, status: 'started', message: 'First update' } },
+    timestamp: 1703123456789
+  }
+]
+Final data: {
+  test_items_item1: { step: 1, status: 'started', message: 'First update' },
+  test_items_item2: { step: 2, status: 'processing', message: 'Second update' },
+  test_items_item3: { step: 3, status: 'completed', message: 'Third update' }
+}
+Final sourceValue: { test_items_item1: { step: 1, status: 'started', message: 'First update' } }
+
+🚨 RACE CONDITION CONFIRMED:
+• Expected to see 3 sourceValues
+• Actually received 1 sourceValue(s)
+• Lost 2 intermediate updates
+• Only the FIRST update is visible in sourceValue due to batching!
+
+This means components cannot reliably track state transitions when updates are batched!
+```
+
+## Technical Deep Dive: The Batching Mechanism
+
+### Where `unstable_batchedUpdates` is Called
+
+The race condition is caused by Onyx's internal batching mechanism in `lib/OnyxUtils.ts`:
+
+```typescript
+// In OnyxUtils.ts, lines ~203-226
+function maybeFlushBatchUpdates(): Promise<void> {
+    if (batchUpdatesPromise) {
+        return batchUpdatesPromise;
+    }
+    batchUpdatesPromise = new Promise((resolve) => {
+        setTimeout(() => {  // ⚠️ Key: Delays execution to next tick
+            const updatesCopy = batchUpdatesQueue;
+            batchUpdatesQueue = [];
+            batchUpdatesPromise = null;
+            
+            unstable_batchedUpdates(() => {  // ⚠️ React batching starts here
+                updatesCopy.forEach((applyUpdates) => {
+                    applyUpdates(); // All updates execute together
+                });
+            });
+            resolve();
+        }, 0); // Next tick of event loop
+    });
+    return batchUpdatesPromise;
+}
+```
+
+### Why This Causes the Race Condition
+
+1. **Multiple Updates Queued**: Each `Onyx.merge()` call adds an update to `batchUpdatesQueue`
+2. **setTimeout Delay**: All updates wait for the next event loop tick
+3. **Batch Execution**: `unstable_batchedUpdates` executes all updates synchronously within React's batching context
+4. **Single Render**: React sees all state changes as one update, triggering only one render
+5. **Lost sourceValues**: Only the first `sourceValue` assignment survives the batching process
+
+This is why the test demonstrates that 3 discrete updates result in only 1 `sourceValue` being visible to components.
diff --git a/tests/unit/proveFastOnyxUpdatesArePossible.ts b/tests/unit/proveFastOnyxUpdatesArePossible.ts
new file mode 100644
index 00000000..20809a0e
--- /dev/null
+++ b/tests/unit/proveFastOnyxUpdatesArePossible.ts
@@ -0,0 +1,263 @@
+/* eslint-disable no-console, @typescript-eslint/no-explicit-any */
+
+/**
+ * Test to prove that multiple Onyx updates can arrive rapidly enough to trigger batching.
+ * This disproves the "single threaded network queue" theory.
+ */
+
+import {act, renderHook} from '@testing-library/react-native';
+import Onyx, {useOnyx} from '../../lib';
+import waitForPromisesToResolve from '../utils/waitForPromisesToResolve';
+
+const ONYXKEYS = {
+    COLLECTION: {
+        FAST_UPDATES: 'fast_updates_',
+    },
+};
+
+Onyx.init({
+    keys: ONYXKEYS,
+});
+
+beforeEach(async () => {
+    await Onyx.clear();
+});
+
+describe('Prove Fast Onyx Updates Are Possible', () => {
+    it('should prove that multiple update sources can fire simultaneously (NOT single threaded)', async () => {
+        let renderCount = 0;
+        const allSourceValues: any[] = [];
+
+        const {result} = renderHook(() => {
+            renderCount++;
+            const [data, metadata] = useOnyx(ONYXKEYS.COLLECTION.FAST_UPDATES);
+
+            if (metadata.sourceValue !== undefined) {
+                allSourceValues.push({
+                    timestamp: Date.now(),
+                    sourceValue: metadata.sourceValue,
+                    renderCount,
+                });
+            }
+
+            return [data, metadata];
+        });
+
+        await act(async () => waitForPromisesToResolve());
+
+        const initialRenderCount = renderCount;
+        allSourceValues.length = 0;
+
+        console.log('\n🚀 DEMONSTRATING MULTIPLE SIMULTANEOUS UPDATE SOURCES');
+        console.log('This disproves the "single threaded network queue" theory\n');
+
+        // ⚡ PROOF 1: Direct Onyx calls can happen in rapid succession
+        await act(async () => {
+            console.log('🔥 Firing multiple direct Onyx updates synchronously...');
+
+            // These execute immediately, no network queue involved
+            Onyx.merge(`${ONYXKEYS.COLLECTION.FAST_UPDATES}direct1`, {source: 'direct', order: 1, timestamp: Date.now()});
+            Onyx.merge(`${ONYXKEYS.COLLECTION.FAST_UPDATES}direct2`, {source: 'direct', order: 2, timestamp: Date.now()});
+            Onyx.merge(`${ONYXKEYS.COLLECTION.FAST_UPDATES}direct3`, {source: 'direct', order: 3, timestamp: Date.now()});
+
+            await waitForPromisesToResolve();
+        });
+
+        const directUpdatesRenderCount = renderCount - initialRenderCount;
+        console.log(`✅ Direct updates: ${allSourceValues.length} sourceValue(s), ${directUpdatesRenderCount} render(s)`);
+
+        // ⚡ PROOF 2: Onyx.update() with multiple operations executes immediately
+        allSourceValues.length = 0;
+        const beforeBatchRender = renderCount;
+
+        await act(async () => {
+            console.log('🔥 Firing Onyx.update() with multiple operations...');
+
+            // This bypasses ANY network queue and applies multiple updates at once
+            Onyx.update([
+                {onyxMethod: 'merge', key: `${ONYXKEYS.COLLECTION.FAST_UPDATES}batch1`, value: {source: 'batch', order: 1}},
+                {onyxMethod: 'merge', key: `${ONYXKEYS.COLLECTION.FAST_UPDATES}batch2`, value: {source: 'batch', order: 2}},
+                {onyxMethod: 'merge', key: `${ONYXKEYS.COLLECTION.FAST_UPDATES}batch3`, value: {source: 'batch', order: 3}},
+            ]);
+
+            await waitForPromisesToResolve();
+        });
+
+        const batchUpdatesRenderCount = renderCount - beforeBatchRender;
+        console.log(`✅ Batch updates: ${allSourceValues.length} sourceValue(s), ${batchUpdatesRenderCount} render(s)`);
+
+        // ⚡ PROOF 3: mergeCollection executes immediately
+        allSourceValues.length = 0;
+        const beforeCollectionRender = renderCount;
+
+        await act(async () => {
+            console.log('🔥 Firing Onyx.mergeCollection() with multiple items...');
+
+            // Collection merges also bypass network queues
+            Onyx.mergeCollection(ONYXKEYS.COLLECTION.FAST_UPDATES, {
+                [`${ONYXKEYS.COLLECTION.FAST_UPDATES}collection1`]: {source: 'collection', order: 1},
+                [`${ONYXKEYS.COLLECTION.FAST_UPDATES}collection2`]: {source: 'collection', order: 2},
+                [`${ONYXKEYS.COLLECTION.FAST_UPDATES}collection3`]: {source: 'collection', order: 3},
+            } as any);
+
+            await waitForPromisesToResolve();
+        });
+
+        const collectionUpdatesRenderCount = renderCount - beforeCollectionRender;
+        console.log(`✅ Collection updates: ${allSourceValues.length} sourceValue(s), ${collectionUpdatesRenderCount} render(s)`);
+
+        console.log('\n📊 FINAL RESULTS:');
+        console.log('All update types resulted in ≤1 render due to React batching');
+        console.log('This proves updates can arrive faster than the network queue can process them');
+
+        console.log('\n🏆 CONCLUSION: "Single threaded network queue" theory is FALSE');
+        console.log('• Direct Onyx calls execute immediately');
+        console.log('• Batch operations execute immediately');
+        console.log('• Collection merges execute immediately');
+        console.log('• Only API WRITE requests go through SequentialQueue');
+        console.log('• READ requests process immediately');
+        console.log('• Pusher events process in parallel to API requests');
+
+        // All these operations should have been batched by React
+        expect(directUpdatesRenderCount).toBeLessThanOrEqual(1);
+        expect(batchUpdatesRenderCount).toBeLessThanOrEqual(1);
+        expect(collectionUpdatesRenderCount).toBeLessThanOrEqual(1);
+
+        // Data should contain all updates
+        expect(Object.keys(result.current[0] || {}).length).toBeGreaterThan(0);
+    });
+
+    it('should prove that API response phases can trigger multiple rapid updates', async () => {
+        let renderCount = 0;
+        const allSourceValues: any[] = [];
+
+        const {result} = renderHook(() => {
+            renderCount++;
+            const [data, metadata] = useOnyx(ONYXKEYS.COLLECTION.FAST_UPDATES);
+
+            if (metadata.sourceValue !== undefined) {
+                allSourceValues.push({
+                    timestamp: Date.now(),
+                    sourceValue: metadata.sourceValue,
+                });
+            }
+
+            return [data, metadata];
+        });
+
+        await act(async () => waitForPromisesToResolve());
+
+        const initialRenderCount = renderCount;
+        allSourceValues.length = 0;
+
+        // Simulate the 3-phase API response pattern: onyxData → successData → finallyData
+        // This mimics what happens in real API responses with optimistic updates
+        await act(async () => {
+            // Phase 1: Simulate response.onyxData (server data)
+            Onyx.update([{onyxMethod: 'merge', key: `${ONYXKEYS.COLLECTION.FAST_UPDATES}server1`, value: {phase: 'onyxData', source: 'server'}}]);
+
+            // Phase 2: Simulate request.successData (optimistic data completion)
+            Onyx.update([{onyxMethod: 'merge', key: `${ONYXKEYS.COLLECTION.FAST_UPDATES}success1`, value: {phase: 'successData', source: 'optimistic'}}]);
+
+            // Phase 3: Simulate request.finallyData (cleanup)
+            Onyx.update([{onyxMethod: 'merge', key: `${ONYXKEYS.COLLECTION.FAST_UPDATES}finally1`, value: {phase: 'finallyData', source: 'cleanup'}}]);
+
+            await waitForPromisesToResolve();
+        });
+
+        const apiPhaseRenderCount = renderCount - initialRenderCount;
+
+        // Prove that multiple API phases get batched into single render
+        expect(apiPhaseRenderCount).toBeLessThanOrEqual(1);
+
+        // Prove that we only see one sourceValue despite multiple phases
+        expect(allSourceValues.length).toBeLessThanOrEqual(1);
+
+        // Prove that all data was applied despite batching
+        const finalData = result.current[0] || {};
+        expect(Object.keys(finalData).length).toBe(3); // All 3 phases should be present
+        expect((finalData as any)[`${ONYXKEYS.COLLECTION.FAST_UPDATES}server1`]).toEqual({phase: 'onyxData', source: 'server'});
+        expect((finalData as any)[`${ONYXKEYS.COLLECTION.FAST_UPDATES}success1`]).toEqual({phase: 'successData', source: 'optimistic'});
+        expect((finalData as any)[`${ONYXKEYS.COLLECTION.FAST_UPDATES}finally1`]).toEqual({phase: 'finallyData', source: 'cleanup'});
+    });
+
+    it('should prove that timing allows multiple updates within a single React render cycle', async () => {
+        let renderCount = 0;
+        const renderTimestamps: number[] = [];
+        const allSourceValues: any[] = [];
+
+        const {result} = renderHook(() => {
+            renderCount++;
+            const timestamp = Date.now();
+            renderTimestamps.push(timestamp);
+
+            const [data, metadata] = useOnyx(ONYXKEYS.COLLECTION.FAST_UPDATES);
+
+            if (metadata.sourceValue !== undefined) {
+                allSourceValues.push({
+                    timestamp,
+                    sourceValue: metadata.sourceValue,
+                });
+            }
+
+            return [data, metadata];
+        });
+
+        await act(async () => waitForPromisesToResolve());
+
+        const initialRenderCount = renderCount;
+        renderTimestamps.length = 0;
+        allSourceValues.length = 0;
+
+        // Measure timing of rapid-fire updates
+        const updateStartTime = Date.now();
+
+        await act(async () => {
+            // Fire multiple updates in quick succession (simulating real-world rapid updates)
+            const updates = [];
+            for (let i = 0; i < 10; i++) {
+                updates.push({
+                    onyxMethod: 'merge' as const,
+                    key: `${ONYXKEYS.COLLECTION.FAST_UPDATES}rapid${i}`,
+                    value: {id: i, timestamp: Date.now(), source: 'rapid-fire'},
+                });
+            }
+
+            // Apply all updates at once (simulates how multiple sources can update simultaneously)
+            Onyx.update(updates);
+
+            await waitForPromisesToResolve();
+        });
+
+        const updateEndTime = Date.now();
+        const totalUpdateTime = updateEndTime - updateStartTime;
+        const updatesRenderCount = renderCount - initialRenderCount;
+
+        // Prove that timing supports batching
+        expect(totalUpdateTime).toBeLessThan(100); // Updates complete in <100ms (very fast)
+        expect(updatesRenderCount).toBeLessThanOrEqual(1); // But only trigger 1 render due to batching
+
+        // Prove that despite 10 updates, we only see one sourceValue
+        expect(allSourceValues.length).toBeLessThanOrEqual(1);
+
+        // Prove that all data was successfully applied
+        const finalData = result.current[0] || {};
+        expect(Object.keys(finalData).length).toBe(10); // All 10 updates should be present
+
+        // Prove the data is correct
+        for (let i = 0; i < 10; i++) {
+            expect((finalData as any)[`${ONYXKEYS.COLLECTION.FAST_UPDATES}rapid${i}`]).toEqual({
+                id: i,
+                timestamp: expect.any(Number),
+                source: 'rapid-fire',
+            });
+        }
+
+        console.log(`\n⚡ TIMING PROOF:`);
+        console.log(`• 10 updates completed in ${totalUpdateTime}ms`);
+        console.log(`• Only ${updatesRenderCount} render(s) occurred`);
+        console.log(`• Only ${allSourceValues.length} sourceValue(s) visible`);
+        console.log(`• React batching window (~16ms) easily contains multiple updates`);
+        console.log(`• This proves the race condition timing is realistic in production`);
+    });
+});
diff --git a/tests/unit/simpleSourceValueRaceConditionDemo.ts b/tests/unit/simpleSourceValueRaceConditionDemo.ts
new file mode 100644
index 00000000..eea960ac
--- /dev/null
+++ b/tests/unit/simpleSourceValueRaceConditionDemo.ts
@@ -0,0 +1,203 @@
+/* eslint-disable no-console, @typescript-eslint/no-explicit-any, no-else-return */
+/**
+ * Simple test to demonstrate the sourceValue race condition.
+ *
+ * This test proves that when multiple Onyx updates are batched together,
+ * the sourceValue only reflects the first update, not all the discrete
+ * updates that actually occurred.
+ */
+
+import {act, renderHook} from '@testing-library/react-native';
+import Onyx, {useOnyx} from '../../lib';
+import waitForPromisesToResolve from '../utils/waitForPromisesToResolve';
+
+const ONYXKEYS = {
+    COLLECTION: {
+        TEST_ITEMS: 'test_items_',
+        PRIMER_COLLECTION: 'primer_collection_',
+        REPORTS: 'reports_',
+        POLICIES: 'policies_',
+        TRANSACTIONS: 'transactions_',
+    },
+};
+
+Onyx.init({
+    keys: ONYXKEYS,
+});
+
+beforeEach(async () => {
+    // Clear Onyx data and wait for it to complete
+    await Onyx.clear();
+
+    // Wait for any pending async operations to complete
+    await waitForPromisesToResolve();
+});
+
+afterEach(async () => {
+    // Wait for pending operations to complete
+    await waitForPromisesToResolve();
+
+    // Add a small delay to ensure the setTimeout(0) batching mechanism fully completes
+    // This prevents flakiness where the second test gets 0 renders due to timing issues
+    // eslint-disable-next-line no-promise-executor-return
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    // Wait again after the sleep to ensure all async operations are truly done
+    await waitForPromisesToResolve();
+});
+
+describe('Simple sourceValue Race Condition Demo', () => {
+    it('should demonstrate that only the first sourceValue is visible when updates are batched', async () => {
+        // Track all sourceValues we receive during the test
+        const receivedSourceValues: any[] = [];
+        let renderCount = 0;
+
+        const {result} = renderHook(() => {
+            renderCount++;
+            const [data, metadata] = useOnyx(ONYXKEYS.COLLECTION.TEST_ITEMS);
+
+            // Log every sourceValue we see (excluding undefined/initial state)
+            if (metadata.sourceValue !== undefined) {
+                receivedSourceValues.push({
+                    renderCount,
+                    sourceValue: metadata.sourceValue,
+                    timestamp: Date.now(),
+                });
+            }
+
+            return [data, metadata];
+        });
+
+        // Wait for initial connection
+        await act(async () => waitForPromisesToResolve());
+
+        // ⚠️ PRIMER UPDATE REQUIRED FOR TEST STABILITY ⚠️
+        // This primer is CRITICAL for preventing test flakiness. Here's why:
+        //
+        // 1. TIMING-DEPENDENT BATCHING: Onyx uses setTimeout(0) in maybeFlushBatchUpdates(),
+        //    which makes the batching mechanism timing-sensitive
+        //
+        // 2. COLD START ISSUES: Without the primer, the first rapid-fire updates sometimes occur
+        //    before Onyx's batching infrastructure is fully exercised, specifically:
+        //    - The batchUpdatesPromise in OnyxUtils may not be properly initialized
+        //    - The useOnyx hook's sourceValueRef may not have gone through a full update cycle
+        //    - Connection callbacks may not have established their timing patterns
+        //
+        // 3. OBSERVABLE SYMPTOMS: When not primed, the test exhibits flaky behavior:
+        //    - 0 renders instead of 1 (updates don't trigger React re-render)
+        //    - 0 sourceValues instead of 1 (metadata tracking fails)
+        //    - undefined final data instead of expected data (connection issues)
+        //
+        // 4. PRIMER FUNCTION: This single update exercises the full Onyx update pipeline once,
+        //    ensuring subsequent rapid updates behave consistently and predictably
+        await act(async () => {
+            Onyx.merge(`${ONYXKEYS.COLLECTION.PRIMER_COLLECTION}warmup`, {primed: true});
+            await waitForPromisesToResolve();
+        });
+
+        // Clear counters after initial setup and primer
+        const initialRenderCount = renderCount;
+        receivedSourceValues.length = 0;
+
+        console.log('\n=== Starting the race condition test ===');
+        console.log('About to perform 3 discrete updates that should be batched...\n');
+
+        // ⚠️  THE RACE CONDITION SCENARIO ⚠️
+        // Perform multiple discrete updates in rapid succession
+        // These SHOULD be treated as 3 separate updates, but React batches them
+        // https://github.com/reactwg/react-18/discussions/21
+        await act(async () => {
+            // Update 1: Add first item
+            Onyx.merge(`${ONYXKEYS.COLLECTION.TEST_ITEMS}item1`, {
+                step: 1,
+                status: 'started',
+                message: 'First update',
+            });
+
+            // Update 2: Add second item
+            Onyx.merge(`${ONYXKEYS.COLLECTION.TEST_ITEMS}item2`, {
+                step: 2,
+                status: 'processing',
+                message: 'Second update',
+            });
+
+            // Update 3: Add third item
+            Onyx.merge(`${ONYXKEYS.COLLECTION.TEST_ITEMS}item3`, {
+                step: 3,
+                status: 'completed',
+                message: 'Third update',
+            });
+
+            await waitForPromisesToResolve();
+        });
+
+        const updatesRenderCount = renderCount - initialRenderCount;
+
+        console.log('=== RESULTS ===');
+        console.log(`Expected: 3 discrete updates → 3 different sourceValues`);
+        console.log(`Actual: ${receivedSourceValues.length} sourceValue(s) received`);
+        console.log(`Renders: ${updatesRenderCount} (due to React batching)\n`);
+
+        console.log('SourceValues received:', receivedSourceValues);
+        console.log('Final data:', result.current[0]);
+        // @ts-expect-error - sourceValue exists on the metadata object but TS doesn't know the type
+        console.log('Final sourceValue:', result.current[1]?.sourceValue);
+
+        // ✅ PROOF OF THE RACE CONDITION:
+
+        // 1. We performed 3 discrete updates
+        const expectedUpdates = 3;
+
+        // 2. But due to batching, we only get 1 render and 1 sourceValue
+        expect(updatesRenderCount).toBe(1); // Only 1 render due to batching
+        expect(receivedSourceValues.length).toBe(1); // Only 1 sourceValue received
+
+        // 3. The final data contains all changes (no data loss)
+        expect(result.current[0]).toEqual({
+            [`${ONYXKEYS.COLLECTION.TEST_ITEMS}item1`]: {
+                step: 1,
+                status: 'started',
+                message: 'First update',
+            },
+            [`${ONYXKEYS.COLLECTION.TEST_ITEMS}item2`]: {
+                step: 2,
+                status: 'processing',
+                message: 'Second update',
+            },
+            [`${ONYXKEYS.COLLECTION.TEST_ITEMS}item3`]: {
+                step: 3,
+                status: 'completed',
+                message: 'Third update',
+            },
+        });
+
+        // 4. But sourceValue only shows the FIRST update that triggered the batch!
+        // @ts-expect-error - sourceValue exists on the metadata object but TS doesn't know the type
+        if (result.current[1]?.sourceValue) {
+            // sourceValue contains data from the FIRST update, not the last!
+            // This is because it gets set when the first callback fires, then gets
+            // overwritten during batching but the component only renders once.
+            // @ts-expect-error - sourceValue exists on the metadata object but TS doesn't know the type
+            expect(result.current[1].sourceValue).toEqual({
+                [`${ONYXKEYS.COLLECTION.TEST_ITEMS}item1`]: {
+                    step: 1,
+                    status: 'started',
+                    message: 'First update',
+                },
+            });
+        }
+
+        // 🚨 THE PROBLEM:
+        // We lost information about the "processing" and "completed" states!
+        // A component using sourceValue to track state transitions would miss:
+        // - step: 2, status: 'processing' (never visible in sourceValue)
+        // - step: 3, status: 'completed' (never visible in sourceValue)
+
+        console.log('\n🚨 RACE CONDITION CONFIRMED:');
+        console.log(`• Expected to see ${expectedUpdates} sourceValues`);
+        console.log(`• Actually received ${receivedSourceValues.length} sourceValue(s)`);
+        console.log(`• Lost ${expectedUpdates - receivedSourceValues.length} intermediate updates`);
+        console.log('• Only the FIRST update is visible in sourceValue due to batching!');
+        console.log('\nThis means components cannot reliably track state transitions when updates are batched!');
+    });
+});
diff --git a/tests/unit/staleSourceValueTest.ts b/tests/unit/staleSourceValueTest.ts
new file mode 100644
index 00000000..6388718c
--- /dev/null
+++ b/tests/unit/staleSourceValueTest.ts
@@ -0,0 +1,118 @@
+/* eslint-disable no-console, @typescript-eslint/no-explicit-any */
+/**
+ * Test to prove that useOnyx sourceValue persists across unrelated renders,
+ * making it unsound for cache invalidation logic.
+ */
+
+import {act, renderHook} from '@testing-library/react-native';
+import {useState} from 'react';
+import Onyx, {useOnyx} from '../../lib';
+import waitForPromisesToResolve from '../utils/waitForPromisesToResolve';
+
+const ONYXKEYS = {
+    COLLECTION: {
+        REPORTS: 'reports_',
+        POLICIES: 'policies_',
+    },
+};
+
+Onyx.init({
+    keys: ONYXKEYS,
+});
+
+beforeEach(async () => {
+    await Onyx.clear();
+    await waitForPromisesToResolve();
+});
+
+afterEach(async () => {
+    await waitForPromisesToResolve();
+    // eslint-disable-next-line no-promise-executor-return
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    await waitForPromisesToResolve();
+});
+
+describe('Stale sourceValue Test', () => {
+    it('should demonstrate that sourceValue persists across unrelated renders, making cache invalidation unsound', async () => {
+        const sourceValueHistory: any[] = [];
+
+        // Create a component that can re-render for reasons unrelated to Onyx
+        const {result, rerender} = renderHook(
+            ({externalState}: {externalState: number}) => {
+                const [localState, setLocalState] = useState(0);
+                const [reports, {sourceValue: reportsSourceValue}] = useOnyx(ONYXKEYS.COLLECTION.REPORTS);
+                const [policies, {sourceValue: policiesSourceValue}] = useOnyx(ONYXKEYS.COLLECTION.POLICIES);
+
+                // Track every sourceValue we see
+                const currentSourceValues = {
+                    externalState,
+                    localState,
+                    reportsSourceValue: reportsSourceValue ? Object.keys(reportsSourceValue) : undefined,
+                    policiesSourceValue: policiesSourceValue ? Object.keys(policiesSourceValue) : undefined,
+                };
+                sourceValueHistory.push(currentSourceValues);
+
+                return {
+                    reports,
+                    policies,
+                    reportsSourceValue,
+                    policiesSourceValue,
+                    localState,
+                    setLocalState,
+                    triggerUnrelatedRerender: () => setLocalState((prev) => prev + 1),
+                };
+            },
+            {initialProps: {externalState: 1}},
+        );
+
+        await act(async () => waitForPromisesToResolve());
+
+        console.log('\n=== Testing sourceValue persistence across unrelated renders ===');
+
+        // Trigger an Onyx update
+        await act(async () => {
+            Onyx.merge(`${ONYXKEYS.COLLECTION.REPORTS}123`, {
+                reportID: '123',
+                lastMessage: 'Test message',
+            });
+            await waitForPromisesToResolve();
+        });
+
+        const afterOnyxUpdate = sourceValueHistory[sourceValueHistory.length - 1];
+
+        // Trigger unrelated re-renders
+        rerender({externalState: 2});
+        await act(async () => waitForPromisesToResolve());
+        const afterPropsChange = sourceValueHistory[sourceValueHistory.length - 1];
+
+        await act(async () => {
+            result.current.triggerUnrelatedRerender();
+            await waitForPromisesToResolve();
+        });
+        const afterStateChange = sourceValueHistory[sourceValueHistory.length - 1];
+
+        // Check sourceValue persistence
+        const hasSourceAfterOnyx = afterOnyxUpdate.reportsSourceValue !== undefined;
+        const hasSourceAfterProps = afterPropsChange.reportsSourceValue !== undefined;
+        const hasSourceAfterState = afterStateChange.reportsSourceValue !== undefined;
+
+        console.log(`After Onyx update: sourceValue ${hasSourceAfterOnyx ? 'present' : 'missing'}`);
+        console.log(`After props change: sourceValue ${hasSourceAfterProps ? 'PERSISTS' : 'cleared'}`);
+        console.log(`After state change: sourceValue ${hasSourceAfterState ? 'PERSISTS' : 'cleared'}`);
+
+        if (hasSourceAfterProps || hasSourceAfterState) {
+            console.log('Result: sourceValue persists across unrelated renders (unsound for cache invalidation)');
+        }
+
+        // Expected behavior: sourceValue present after actual Onyx update
+        expect(hasSourceAfterOnyx).toBe(true);
+
+        // BUG: sourceValue incorrectly persists after unrelated renders
+        expect(hasSourceAfterProps).toBe(true); // PROVES BUG: sourceValue should be undefined here
+        expect(hasSourceAfterState).toBe(true); // PROVES BUG: sourceValue should be undefined here
+
+        // For contrast: in a correct implementation, these should be false
+        // expect(hasSourceAfterProps).toBe(false); // What SHOULD happen
+        // expect(hasSourceAfterState).toBe(false); // What SHOULD happen
+    });
+});
diff --git a/tests/unit/useSidebarOrderedReportsDisplayBug.ts b/tests/unit/useSidebarOrderedReportsDisplayBug.ts
new file mode 100644
index 00000000..30fca894
--- /dev/null
+++ b/tests/unit/useSidebarOrderedReportsDisplayBug.ts
@@ -0,0 +1,374 @@
+/* eslint-disable no-console, @typescript-eslint/no-explicit-any, no-else-return */
+/**
+ * Tests demonstrating the useSidebarOrderedReports display bug.
+ *
+ * This file contains two tests:
+ * 1. Pure conditional logic bug - else-if chain ignores available sourceValues
+ * 2. Compound issue - race condition + logic bug occurring simultaneously
+ */
+
+import {act, renderHook} from '@testing-library/react-native';
+import Onyx, {useOnyx} from '../../lib';
+import waitForPromisesToResolve from '../utils/waitForPromisesToResolve';
+
+const ONYXKEYS = {
+    COLLECTION: {
+        TEST_ITEMS: 'test_items_',
+        PRIMER_COLLECTION: 'primer_collection_',
+        REPORTS: 'reports_',
+        POLICIES: 'policies_',
+        TRANSACTIONS: 'transactions_',
+    },
+};
+
+Onyx.init({
+    keys: ONYXKEYS,
+});
+
+beforeEach(async () => {
+    // Clear Onyx data and wait for it to complete
+    await Onyx.clear();
+
+    // Wait for any pending async operations to complete
+    await waitForPromisesToResolve();
+});
+
+afterEach(async () => {
+    // Wait for pending operations to complete
+    await waitForPromisesToResolve();
+
+    // Add a small delay to ensure the setTimeout(0) batching mechanism fully completes
+    // This prevents flakiness where the second test gets 0 renders due to timing issues
+    // eslint-disable-next-line no-promise-executor-return
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    // Wait again after the sleep to ensure all async operations are truly done
+    await waitForPromisesToResolve();
+});
+
+describe('useSidebarOrderedReports Display Bug Tests', () => {
+    it('should demonstrate useSidebarOrderedReports conditional logic bug when sourceValues from multiple collections are available', async () => {
+        // This test demonstrates a LOGIC BUG (not race condition) in useSidebarOrderedReports.tsx:
+        // When batching provides multiple sourceValues simultaneously, the else-if chain
+        // only processes the FIRST condition and ignores available updates from other collections
+
+        let renderCount = 0;
+        const allUpdatesReceived: string[] = [];
+
+        // Replicate the pattern from useSidebarOrderedReports.tsx lines 65-69
+        const {result} = renderHook(() => {
+            renderCount++;
+            const [chatReports, {sourceValue: reportUpdates}] = useOnyx(ONYXKEYS.COLLECTION.REPORTS);
+            const [policies, {sourceValue: policiesUpdates}] = useOnyx(ONYXKEYS.COLLECTION.POLICIES);
+            const [transactions, {sourceValue: transactionsUpdates}] = useOnyx(ONYXKEYS.COLLECTION.TRANSACTIONS);
+
+            if (reportUpdates !== undefined) {
+                allUpdatesReceived.push(`reports_${renderCount}`);
+            }
+            if (policiesUpdates !== undefined) {
+                allUpdatesReceived.push(`policies_${renderCount}`);
+            }
+            if (transactionsUpdates !== undefined) {
+                allUpdatesReceived.push(`transactions_${renderCount}`);
+            }
+
+            // Replicate the problematic else-if logic from useSidebarOrderedReports.tsx
+            const getUpdatedReports = () => {
+                let reportsToUpdate: string[] = [];
+                // This else-if chain creates the logic bug
+                if (reportUpdates) {
+                    reportsToUpdate = Object.keys(reportUpdates);
+                    return {source: 'reports', updates: reportsToUpdate};
+                } else if (policiesUpdates) {
+                    const updatedPolicies = Object.keys(policiesUpdates);
+                    reportsToUpdate = updatedPolicies.map((key) => `affected_by_policy_${key.replace(ONYXKEYS.COLLECTION.POLICIES, '')}`);
+                    return {source: 'policies', updates: reportsToUpdate};
+                } else if (transactionsUpdates) {
+                    const transactionReports = Object.values(transactionsUpdates).map((txn: any) => `report_${txn?.reportID}`);
+                    reportsToUpdate = transactionReports;
+                    return {source: 'transactions', updates: reportsToUpdate};
+                }
+                return {source: 'none', updates: []};
+            };
+
+            return {
+                chatReports,
+                policies,
+                transactions,
+                reportUpdates,
+                policiesUpdates,
+                transactionsUpdates,
+                getUpdatedReports: getUpdatedReports(),
+            };
+        });
+
+        await act(async () => waitForPromisesToResolve());
+
+        // Add a primer update to ensure batching mechanism is warmed up (helps with test isolation)
+        await act(async () => {
+            Onyx.merge(`${ONYXKEYS.COLLECTION.PRIMER_COLLECTION}warmup`, {primed: true});
+            await waitForPromisesToResolve();
+        });
+
+        const initialRenderCount = renderCount;
+        allUpdatesReceived.length = 0;
+
+        console.log('\n=== useSidebarOrderedReports Conditional Logic Bug Test ===');
+        console.log('Simulating simultaneous updates that get batched together...');
+
+        // Simulate the scenario where an API response updates multiple collections simultaneously
+        await act(async () => {
+            // Update 1: New report
+            Onyx.merge(`${ONYXKEYS.COLLECTION.REPORTS}123`, {
+                reportID: '123',
+                lastMessage: 'New message',
+                participantAccountIDs: [1, 2],
+            });
+
+            // Update 2: Policy change
+            Onyx.merge(`${ONYXKEYS.COLLECTION.POLICIES}policy456`, {
+                id: 'policy456',
+                name: 'Updated Expense Policy',
+                employeeList: {1: {}, 2: {}},
+            });
+
+            // Update 3: Transaction update
+            Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTIONS}txn789`, {
+                transactionID: 'txn789',
+                reportID: '123',
+                amount: 2500,
+            });
+
+            await waitForPromisesToResolve();
+        });
+
+        const totalRenders = renderCount - initialRenderCount;
+        const updateDecision = result.current.getUpdatedReports;
+
+        console.log('=== RESULTS ===');
+        console.log(`Total renders: ${totalRenders}`);
+        console.log(`Updates received: [${allUpdatesReceived.join(', ')}]`);
+        console.log(`Decision made: ${updateDecision.source} → ${updateDecision.updates.length} reports to update`);
+
+        console.log('\n🎯 CONDITIONAL LOGIC ANALYSIS:');
+        const hasReportUpdates = result.current.reportUpdates !== undefined;
+        const hasPolicyUpdates = result.current.policiesUpdates !== undefined;
+        const hasTransactionUpdates = result.current.transactionsUpdates !== undefined;
+
+        console.log(`• Reports sourceValue: ${hasReportUpdates ? '✅ Available' : '❌ Missing'}`);
+        console.log(`• Policies sourceValue: ${hasPolicyUpdates ? '✅ Available' : '❌ Missing'}`);
+        console.log(`• Transactions sourceValue: ${hasTransactionUpdates ? '✅ Available' : '❌ Missing'}`);
+
+        // Check if the else-if logic caused updates to be ignored
+        const collectionsWithUpdates = [hasReportUpdates, hasPolicyUpdates, hasTransactionUpdates].filter(Boolean).length;
+        const collectionsProcessed = updateDecision.source !== 'none' ? 1 : 0;
+
+        if (collectionsWithUpdates > collectionsProcessed) {
+            console.log('\n🚨 CONDITIONAL LOGIC BUG CONFIRMED:');
+            console.log(`• ${collectionsWithUpdates} collections had sourceValues available (due to batching)`);
+            console.log(`• Only ${collectionsProcessed} collection was processed: "${updateDecision.source}"`);
+            console.log(`• ${collectionsWithUpdates - collectionsProcessed} collection(s) were IGNORED by else-if logic!`);
+            console.log('\n💥 BUG IMPACT: Available updates are lost due to conditional logic design');
+            console.log('💡 SOLUTION: Replace else-if chain with parallel if statements');
+        }
+
+        // Verify the conditional logic bug occurred
+        expect(totalRenders).toBeLessThanOrEqual(2); // Updates should be batched together
+        expect(collectionsWithUpdates).toBeGreaterThan(collectionsProcessed); // Bug: Available sourceValues ignored by else-if logic
+        expect(updateDecision.source).not.toBe('none'); // At least one collection should be processed
+
+        // Verify no actual data loss (the bug affects logic, not data integrity)
+        expect(result.current.chatReports).toBeDefined();
+        expect(result.current.policies).toBeDefined();
+        expect(result.current.transactions).toBeDefined();
+    });
+
+    it('should demonstrate BOTH race condition AND logic bug occurring simultaneously', async () => {
+        // This test combines BOTH problems to show the worst-case scenario:
+        // 1. RACE CONDITION: Multiple updates to one collection → only first sourceValue visible
+        // 2. LOGIC BUG: Available sourceValues from other collections → ignored by else-if chain
+        // RESULT: Maximum possible missed cache updates from both issues compounding
+
+        let renderCount = 0;
+        const allUpdatesReceived: string[] = [];
+
+        const {result} = renderHook(() => {
+            renderCount++;
+            const [chatReports, {sourceValue: reportUpdates}] = useOnyx(ONYXKEYS.COLLECTION.REPORTS);
+            const [policies, {sourceValue: policiesUpdates}] = useOnyx(ONYXKEYS.COLLECTION.POLICIES);
+            const [transactions, {sourceValue: transactionsUpdates}] = useOnyx(ONYXKEYS.COLLECTION.TRANSACTIONS);
+
+            if (reportUpdates !== undefined) {
+                allUpdatesReceived.push(`reports_${renderCount}`);
+            }
+            if (policiesUpdates !== undefined) {
+                allUpdatesReceived.push(`policies_${renderCount}`);
+            }
+            if (transactionsUpdates !== undefined) {
+                allUpdatesReceived.push(`transactions_${renderCount}`);
+            }
+
+            // Replicate the problematic else-if logic from useSidebarOrderedReports.tsx
+            const getUpdatedReports = () => {
+                let reportsToUpdate: string[] = [];
+                // This else-if chain creates the logic bug
+                if (reportUpdates) {
+                    // PROBLEM: Only shows FIRST report update due to race condition
+                    reportsToUpdate = Object.keys(reportUpdates);
+                    return {source: 'reports', updates: reportsToUpdate, reportCount: Object.keys(reportUpdates).length};
+                } else if (policiesUpdates) {
+                    // PROBLEM: Never reached when reportUpdates exists (even if policies updated too)
+                    const updatedPolicies = Object.keys(policiesUpdates);
+                    reportsToUpdate = updatedPolicies.map((key) => `affected_by_policy_${key.replace(ONYXKEYS.COLLECTION.POLICIES, '')}`);
+                    return {source: 'policies', updates: reportsToUpdate, policyCount: Object.keys(policiesUpdates).length};
+                } else if (transactionsUpdates) {
+                    // PROBLEM: Never reached when reportUpdates OR policiesUpdates exist
+                    const transactionReports = Object.values(transactionsUpdates).map((txn: any) => `report_${txn?.reportID}`);
+                    reportsToUpdate = transactionReports;
+                    return {source: 'transactions', updates: reportsToUpdate, transactionCount: Object.keys(transactionsUpdates).length};
+                }
+                return {source: 'none', updates: [], reportCount: 0, policyCount: 0, transactionCount: 0};
+            };
+
+            return {
+                chatReports,
+                policies,
+                transactions,
+                reportUpdates,
+                policiesUpdates,
+                transactionsUpdates,
+                getUpdatedReports: getUpdatedReports(),
+            };
+        });
+
+        await act(async () => waitForPromisesToResolve());
+
+        // Add a tiny update to ensure batching mechanism is primed (helps with test isolation)
+        await act(async () => {
+            Onyx.merge(`${ONYXKEYS.COLLECTION.PRIMER_COLLECTION}warmup`, {primed: true});
+            await waitForPromisesToResolve();
+        });
+
+        // Extra timing buffer for this complex test (5 rapid updates can be timing-sensitive)
+        // eslint-disable-next-line no-promise-executor-return
+        await new Promise((resolve) => setTimeout(resolve, 25));
+
+        const initialRenderCount = renderCount;
+        allUpdatesReceived.length = 0;
+
+        console.log('\n=== COMBINED Race Condition + Logic Bug Test ===');
+        console.log('Simulating the WORST-CASE scenario:');
+        console.log('• Multiple rapid updates to reports (race condition)');
+        console.log('• Single updates to policies & transactions (logic bug)');
+
+        // The worst-case scenario: rapid updates + simultaneous cross-collection updates
+        await act(async () => {
+            // RACE CONDITION TARGET: Multiple rapid updates to reports collection
+            Onyx.merge(`${ONYXKEYS.COLLECTION.REPORTS}report1`, {
+                reportID: 'report1',
+                lastMessage: 'First report update',
+                step: 1,
+            });
+            Onyx.merge(`${ONYXKEYS.COLLECTION.REPORTS}report2`, {
+                reportID: 'report2',
+                lastMessage: 'Second report update',
+                step: 2,
+            });
+            Onyx.merge(`${ONYXKEYS.COLLECTION.REPORTS}report3`, {
+                reportID: 'report3',
+                lastMessage: 'Third report update',
+                step: 3,
+            });
+
+            // LOGIC BUG TARGETS: Single updates to other collections (will be ignored)
+            Onyx.merge(`${ONYXKEYS.COLLECTION.POLICIES}policy1`, {
+                id: 'policy1',
+                name: 'Updated Policy',
+                employeeCount: 15,
+            });
+            Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTIONS}txn1`, {
+                transactionID: 'txn1',
+                reportID: 'report1',
+                amount: 5000,
+                status: 'pending',
+            });
+
+            await waitForPromisesToResolve();
+        });
+
+        // Extra wait after complex batch to ensure all timing-sensitive operations complete
+        // eslint-disable-next-line no-promise-executor-return
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        await waitForPromisesToResolve();
+
+        const totalRenders = renderCount - initialRenderCount;
+        const updateDecision = result.current.getUpdatedReports;
+
+        console.log('\n=== DEVASTATING RESULTS ===');
+        console.log(`Total renders: ${totalRenders}`);
+        console.log(`Updates received: [${allUpdatesReceived.join(', ')}]`);
+        console.log(`Decision: ${updateDecision.source} → ${updateDecision.updates.length} reports to update`);
+        console.log(`Winning collection: "${updateDecision.source}" (due to else-if precedence and timing)`);
+
+        // Analyze the compound damage
+        const hasReportUpdates = result.current.reportUpdates !== undefined;
+        const hasPolicyUpdates = result.current.policiesUpdates !== undefined;
+        const hasTransactionUpdates = result.current.transactionsUpdates !== undefined;
+
+        console.log('\n🎯 DAMAGE ASSESSMENT:');
+        console.log(`• Reports sourceValue: ${hasReportUpdates ? '✅ Available' : '❌ Missing'}`);
+        console.log(`• Policies sourceValue: ${hasPolicyUpdates ? '✅ Available' : '❌ Missing'}`);
+        console.log(`• Transactions sourceValue: ${hasTransactionUpdates ? '✅ Available' : '❌ Missing'}`);
+
+        if (hasReportUpdates) {
+            console.log(`  → Reports keys: ${Object.keys(result.current.reportUpdates || {}).join(', ')}`);
+        }
+        if (hasPolicyUpdates) {
+            console.log(`  → Policies keys: ${Object.keys(result.current.policiesUpdates || {}).join(', ')}`);
+        }
+        if (hasTransactionUpdates) {
+            console.log(`  → Transactions keys: ${Object.keys(result.current.transactionsUpdates || {}).join(', ')}`);
+        }
+
+        // Check for race condition damage if reports won the else-if chain
+        if (updateDecision.source === 'reports' && hasReportUpdates && updateDecision.reportCount) {
+            console.log(`\n🚨 RACE CONDITION DAMAGE (Reports Collection):`);
+            console.log(`• Expected: 3 discrete report updates to be tracked`);
+            console.log(`• Actual: Only ${updateDecision.reportCount} report update(s) visible in sourceValue`);
+            console.log(`• Lost: ${3 - updateDecision.reportCount} report updates due to batching race condition`);
+        }
+
+        const availableCollections = [hasReportUpdates, hasPolicyUpdates, hasTransactionUpdates].filter(Boolean).length;
+        const processedCollections = updateDecision.source !== 'none' ? 1 : 0;
+
+        if (availableCollections > processedCollections) {
+            console.log(`\n🚨 LOGIC BUG DAMAGE (Conditional Chain):`);
+            console.log(`• Available: ${availableCollections} collections had sourceValues`);
+            console.log(`• Processed: Only ${processedCollections} collection processed`);
+            console.log(`• Ignored: ${availableCollections - processedCollections} collections ignored by else-if logic`);
+        }
+
+        console.log('\n💥 COMPOUND IMPACT:');
+        console.log('• Race condition causes loss of discrete report updates');
+        console.log('• Logic bug causes complete loss of policy & transaction updates');
+        console.log('• Combined: Maximum possible data loss in a single render cycle!');
+        console.log('\n💡 SOLUTIONS NEEDED:');
+        console.log('• Fix race condition: Accumulate all sourceValues during batching');
+        console.log('• Fix logic bug: Replace else-if with parallel if statements');
+
+        // Verify both problems occurred simultaneously
+        expect(totalRenders).toBeLessThanOrEqual(2); // Should be batched
+        expect(availableCollections).toBeGreaterThanOrEqual(2); // Multiple collections updated
+        expect(processedCollections).toBe(1); // But only one processed due to logic bug
+
+        // The else-if order determines which collection "wins" - could be any of them due to timing
+        // but it should be one of the collections that actually got updates
+        expect(['reports', 'policies', 'transactions']).toContain(updateDecision.source);
+        expect(updateDecision.source).not.toBe('none'); // Should have processed something
+
+        // Verify data integrity is maintained despite logic issues
+        expect(result.current.chatReports).toBeDefined();
+        expect(result.current.policies).toBeDefined();
+        expect(result.current.transactions).toBeDefined();
+    });
+});