diff --git a/src/CONST/index.ts b/src/CONST/index.ts
index 0c56e8ff9459..9b71882c1b85 100644
--- a/src/CONST/index.ts
+++ b/src/CONST/index.ts
@@ -3731,6 +3731,9 @@ const CONST = {
 
     LOCALES,
 
+    // Shared Intl.Collator options for locale-aware sorting of display names.
+    COLLATOR_OPTIONS: {usage: 'sort', sensitivity: 'variant', numeric: true, caseFirst: 'upper'} as Intl.CollatorOptions,
+
     PRONOUNS_LIST: [
         'coCos',
         'eEyEmEir',
diff --git a/src/ONYXKEYS.ts b/src/ONYXKEYS.ts
index ff79ebaa9adf..cdd6f9ec883f 100755
--- a/src/ONYXKEYS.ts
+++ b/src/ONYXKEYS.ts
@@ -1183,6 +1183,7 @@ const ONYXKEYS = {
         TODOS: 'todos',
         RAM_ONLY_SORTED_REPORT_ACTIONS: 'sortedReportActions',
         OPEN_AND_SUBMITTED_REPORTS_BY_POLICY_ID: 'openAndSubmittedReportsByPolicyID',
+        RAM_ONLY_SIDEBAR_ORDERED_REPORTS: 'sidebarOrderedReports',
     },
 
     /** Stores HybridApp specific state required to interoperate with OldDot */
@@ -1666,6 +1667,7 @@ type OnyxDerivedValuesMapping = {
     [ONYXKEYS.DERIVED.TODOS]: OnyxTypes.TodosDerivedValue;
     [ONYXKEYS.DERIVED.RAM_ONLY_SORTED_REPORT_ACTIONS]: OnyxTypes.SortedReportActionsDerivedValue;
     [ONYXKEYS.DERIVED.OPEN_AND_SUBMITTED_REPORTS_BY_POLICY_ID]: OnyxTypes.OpenAndSubmittedReportsByPolicyIDDerivedValue;
+    [ONYXKEYS.DERIVED.RAM_ONLY_SIDEBAR_ORDERED_REPORTS]: OnyxTypes.SidebarOrderedReportsDerivedValue;
 };
 
 type OnyxValues = OnyxValuesMapping & OnyxCollectionValuesMapping & OnyxFormValuesMapping & OnyxFormDraftValuesMapping & OnyxDerivedValuesMapping;
diff --git a/src/components/LHNOptionsList/LHNOptionsList.tsx b/src/components/LHNOptionsList/LHNOptionsList.tsx
index f97e0b457943..603f9dfd2d82 100644
--- a/src/components/LHNOptionsList/LHNOptionsList.tsx
+++ b/src/components/LHNOptionsList/LHNOptionsList.tsx
@@ -15,20 +15,19 @@ import getPlatform from '@libs/getPlatform';
 import variables from '@styles/variables';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
-import type {Report} from '@src/types/onyx';
 import LHNTooltipContextProvider from './LHNTooltipContextProvider';
 import OptionRowLHNData from './OptionRowLHN';
 import OptionRowRendererComponent from './OptionRowRendererComponent';
 import type {LHNOptionsListProps, RenderItemProps} from './types';
 
-const keyExtractor = (item: Report) => `report_${item.reportID}`;
+const keyExtractor = (item: string) => `report_${item}`;
 const platform = getPlatform();
 const isWeb = platform === CONST.PLATFORM.WEB;
 
 function LHNOptionsList({style, contentContainerStyles, data, onSelectRow, optionMode, shouldDisableFocusOptions = false, onFirstItemRendered = () => {}}: LHNOptionsListProps) {
     const {saveScrollOffset, getScrollOffset, saveScrollIndex, getScrollIndex} = useContext(ScrollOffsetContext);
     const {isOffline} = useNetwork();
-    const flashListRef = useRef<FlashListRef<Report>>(null);
+    const flashListRef = useRef<FlashListRef<string>>(null);
     const route = useRoute();
     const [reports] = useOnyx(ONYXKEYS.COLLECTION.REPORT);
     const reportAttributes = useReportAttributes();
@@ -57,29 +56,29 @@ function LHNOptionsList({style, contentContainerStyles, data, onSelectRow, optio
      * Function which renders a row in the list
      */
     const renderItem = useCallback(
-        ({item, index}: RenderItemProps): ReactElement | null => {
-            if (!item) {
+        ({item: reportID, index}: RenderItemProps): ReactElement | null => {
+            if (!reportID) {
                 return null;
             }
-            const reportID = item.reportID;
+            const fullReport = reports?.[`${ONYXKEYS.COLLECTION.REPORT}${reportID}`];
             const itemReportAttributes = reportAttributes?.[reportID];
-            const itemParentReport = reports?.[`${ONYXKEYS.COLLECTION.REPORT}${item.parentReportID}`];
+            const itemParentReport = reports?.[`${ONYXKEYS.COLLECTION.REPORT}${fullReport?.parentReportID}`];
             const itemOneTransactionThreadReport = reports?.[`${ONYXKEYS.COLLECTION.REPORT}${itemReportAttributes?.oneTransactionThreadReportID}`];
 
             let invoiceReceiverPolicyID = '-1';
-            if (item.invoiceReceiver && 'policyID' in item.invoiceReceiver) {
-                invoiceReceiverPolicyID = item.invoiceReceiver.policyID;
+            if (fullReport?.invoiceReceiver && 'policyID' in fullReport.invoiceReceiver) {
+                invoiceReceiverPolicyID = fullReport.invoiceReceiver.policyID;
             }
             if (itemParentReport?.invoiceReceiver && 'policyID' in itemParentReport.invoiceReceiver) {
                 invoiceReceiverPolicyID = itemParentReport.invoiceReceiver.policyID;
             }
             const itemInvoiceReceiverPolicy = policy?.[`${ONYXKEYS.COLLECTION.POLICY}${invoiceReceiverPolicyID}`];
-            const itemPolicy = policy?.[`${ONYXKEYS.COLLECTION.POLICY}${item.policyID}`];
+            const itemPolicy = policy?.[`${ONYXKEYS.COLLECTION.POLICY}${fullReport?.policyID}`];
 
             return (
                 <OptionRowLHNData
                     reportID={reportID}
-                    fullReport={item}
+                    fullReport={fullReport}
                     reportAttributes={itemReportAttributes}
                     reportAttributesDerived={reportAttributes}
                     oneTransactionThreadReport={itemOneTransactionThreadReport}
diff --git a/src/components/LHNOptionsList/LHNTooltipContextProvider.tsx b/src/components/LHNOptionsList/LHNTooltipContextProvider.tsx
index b1fee52092d8..952ff514b14e 100644
--- a/src/components/LHNOptionsList/LHNTooltipContextProvider.tsx
+++ b/src/components/LHNOptionsList/LHNTooltipContextProvider.tsx
@@ -5,12 +5,11 @@ import useReportAttributes from '@hooks/useReportAttributes';
 import useRootNavigationState from '@hooks/useRootNavigationState';
 import NAVIGATORS from '@src/NAVIGATORS';
 import ONYXKEYS from '@src/ONYXKEYS';
-import type {Report} from '@src/types/onyx';
 import {isEmptyObject} from '@src/types/utils/EmptyObject';
 import {LHNTooltipContext} from './LHNTooltipContext';
 
 type LHNTooltipContextProviderProps = {
-    data: Report[];
+    data: string[];
     children: React.ReactNode;
 };
 
@@ -20,14 +19,13 @@ function LHNTooltipContextProvider({data, children}: LHNTooltipContextProviderPr
     const [isFullscreenVisible] = useOnyx(ONYXKEYS.FULLSCREEN_VISIBILITY);
     const reportAttributes = useReportAttributes();
 
-    const firstReport = data.find((report) => {
-        const attrs = reportAttributes?.[report.reportID];
+    const firstReportIDWithGBRorRBR = data.find((reportID) => {
+        const attrs = reportAttributes?.[reportID];
         if (!isEmptyObject(attrs?.reportErrors)) {
             return true;
         }
         return attrs?.requiresAttention;
     });
-    const firstReportIDWithGBRorRBR = firstReport?.reportID;
 
     const isScreenFocused = useIsFocused();
     const isReportsSplitNavigatorLast = useRootNavigationState((state) => state?.routes?.at(-1)?.name === NAVIGATORS.REPORTS_SPLIT_NAVIGATOR);
diff --git a/src/components/LHNOptionsList/types.ts b/src/components/LHNOptionsList/types.ts
index 829de863508a..814079b72f0d 100644
--- a/src/components/LHNOptionsList/types.ts
+++ b/src/components/LHNOptionsList/types.ts
@@ -16,8 +16,8 @@ type CustomLHNOptionsListProps = {
     /** Extra styles for the section list container */
     contentContainerStyles?: StyleProp<ViewStyle>;
 
-    /** List of reports */
-    data: Report[];
+    /** List of report IDs to display, ordered for the LHN */
+    data: string[];
 
     /** Callback to fire when a row is selected */
     onSelectRow?: (optionItem: OptionData, popoverAnchor: RefObject<View | null>) => void;
@@ -97,6 +97,6 @@ type OptionRowLHNProps = {
     testID: number;
 };
 
-type RenderItemProps = {item: Report; index: number};
+type RenderItemProps = {item: string; index: number};
 
 export type {LHNOptionsListProps, OptionRowLHNDataProps, OptionRowLHNProps, RenderItemProps};
diff --git a/src/components/TestToolMenu.tsx b/src/components/TestToolMenu.tsx
index ffebc26007ff..6eed5d6ec797 100644
--- a/src/components/TestToolMenu.tsx
+++ b/src/components/TestToolMenu.tsx
@@ -4,7 +4,6 @@ import useBiometricRegistrationStatus, {REGISTRATION_STATUS} from '@hooks/useBio
 import useIsAuthenticated from '@hooks/useIsAuthenticated';
 import useLocalize from '@hooks/useLocalize';
 import useOnyx from '@hooks/useOnyx';
-import {useSidebarOrderedReportsActions} from '@hooks/useSidebarOrderedReports';
 import useSingleExecution from '@hooks/useSingleExecution';
 import useThemeStyles from '@hooks/useThemeStyles';
 import useWaitForNavigation from '@hooks/useWaitForNavigation';
@@ -32,7 +31,6 @@ function TestToolMenu() {
     const [shouldShowBranchNameInTitle = false] = useOnyx(ONYXKEYS.SHOULD_SHOW_BRANCH_NAME_IN_TITLE);
     const styles = useThemeStyles();
     const {translate} = useLocalize();
-    const {clearLHNCache} = useSidebarOrderedReportsActions();
     const [isMFARevokeLoading, setIsMFARevokeLoading] = useState(false);
     const {localCredentialID, isCurrentDeviceRegistered, otherDeviceCount, registrationStatus} = useBiometricRegistrationStatus();
 
@@ -120,15 +118,6 @@ function TestToolMenu() {
                         />
                     </TestToolRow>
 
-                    {/* Clears the useSidebarOrderedReports cache to re-compute from latest onyx values */}
-                    <TestToolRow title={translate('initialSettingsPage.troubleshoot.leftHandNavCache')}>
-                        <Button
-                            small
-                            text={translate('initialSettingsPage.troubleshoot.clearleftHandNavCache')}
-                            onPress={clearLHNCache}
-                        />
-                    </TestToolRow>
-
                     {/* Allows testing the biometric multifactor authentication flow */}
                     <TestToolRow title={biometricsTitle}>
                         <View style={[styles.flexRow, styles.gap2]}>
diff --git a/src/hooks/useSidebarOrderedReports.tsx b/src/hooks/useSidebarOrderedReports.tsx
index 2e4e31f13a0d..342b63e6a359 100644
--- a/src/hooks/useSidebarOrderedReports.tsx
+++ b/src/hooks/useSidebarOrderedReports.tsx
@@ -1,6 +1,4 @@
-import React, {createContext, useCallback, useContext, useEffect, useMemo, useRef, useState} from 'react';
-import type {OnyxEntry} from 'react-native-onyx';
-import Log from '@libs/Log';
+import React, {createContext, useContext, useEffect, useMemo, useRef} from 'react';
 import SidebarUtils from '@libs/SidebarUtils';
 import type {BrickRoad} from '@libs/WorkspacesSettingsUtils';
 import {getChatTabBrickRoad} from '@libs/WorkspacesSettingsUtils';
@@ -10,16 +8,14 @@ import type * as OnyxTypes from '@src/types/onyx';
 import {useCurrentReportIDState} from './useCurrentReportID';
 import useCurrentUserPersonalDetails from './useCurrentUserPersonalDetails';
 import useLocalize from './useLocalize';
-import useMappedPolicies from './useMappedPolicies';
 import useNetwork from './useNetwork';
 import useOnyx from './useOnyx';
-import usePrevious from './usePrevious';
 import useReportAttributes from './useReportAttributes';
 import useResponsiveLayout from './useResponsiveLayout';
 
 const componentsUsingHook = new Map<string, {renderDuration: number}>();
 
-type PartialPolicyForSidebar = Pick<OnyxTypes.Policy, 'type' | 'name' | 'avatarURL' | 'employeeList'>;
+const EMPTY_ORDERED_REPORT_IDS: string[] = [];
 
 type SidebarOrderedReportsContextProviderProps = {
     children: React.ReactNode;
@@ -27,37 +23,19 @@ type SidebarOrderedReportsContextProviderProps = {
 };
 
 type SidebarOrderedReportsStateContextValue = {
-    orderedReports: OnyxTypes.Report[];
     orderedReportIDs: string[];
     currentReportID: string | undefined;
     chatTabBrickRoad: BrickRoad;
 };
 
-type SidebarOrderedReportsActionsContextValue = {
-    clearLHNCache: () => void;
-};
-
 type ReportsToDisplayInLHN = Record<string, OnyxTypes.Report & {hasErrorsOtherThanFailedReceipt?: boolean; requiresAttention?: boolean}>;
 
 const SidebarOrderedReportsStateContext = createContext<SidebarOrderedReportsStateContextValue>({
-    orderedReports: [],
     orderedReportIDs: [],
     currentReportID: '',
     chatTabBrickRoad: undefined,
 });
 
-const SidebarOrderedReportsActionsContext = createContext<SidebarOrderedReportsActionsContextValue>({
-    clearLHNCache: () => {},
-});
-
-const policyMapper = (policy: OnyxEntry<OnyxTypes.Policy>): PartialPolicyForSidebar =>
-    (policy && {
-        type: policy.type,
-        name: policy.name,
-        avatarURL: policy.avatarURL,
-        employeeList: policy.employeeList,
-    }) as PartialPolicyForSidebar;
-
 function SidebarOrderedReportsContextProvider({
     children,
     /**
@@ -71,279 +49,94 @@ function SidebarOrderedReportsContextProvider({
     currentReportIDForTests,
 }: SidebarOrderedReportsContextProviderProps) {
     const {localeCompare} = useLocalize();
-    const [priorityMode = CONST.PRIORITY_MODE.DEFAULT] = useOnyx(ONYXKEYS.NVP_PRIORITY_MODE);
-    const [chatReports, {sourceValue: reportUpdates}] = useOnyx(ONYXKEYS.COLLECTION.REPORT);
-    const [, {sourceValue: policiesUpdates}] = useMappedPolicies(policyMapper);
-    const [transactions, {sourceValue: transactionsUpdates}] = useOnyx(ONYXKEYS.COLLECTION.TRANSACTION);
-    const [transactionViolations, {sourceValue: transactionViolationsUpdates}] = useOnyx(ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS);
-    const [reportNameValuePairs, {sourceValue: reportNameValuePairsUpdates}] = useOnyx(ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS);
-    const [reportsDrafts, {sourceValue: reportsDraftsUpdates}] = useOnyx(ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT);
+    const [derived] = useOnyx(ONYXKEYS.DERIVED.RAM_ONLY_SIDEBAR_ORDERED_REPORTS);
+    const [chatReports] = useOnyx(ONYXKEYS.COLLECTION.REPORT);
+    const [reportNameValuePairs] = useOnyx(ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS);
+    const [reportsDrafts] = useOnyx(ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT);
+    const [transactions] = useOnyx(ONYXKEYS.COLLECTION.TRANSACTION);
+    const [transactionViolations] = useOnyx(ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS);
     const [betas] = useOnyx(ONYXKEYS.BETAS);
+    const [priorityMode = CONST.PRIORITY_MODE.DEFAULT] = useOnyx(ONYXKEYS.NVP_PRIORITY_MODE);
     const reportAttributes = useReportAttributes();
-    const [currentReportsToDisplay, setCurrentReportsToDisplay] = useState<ReportsToDisplayInLHN>({});
     const {shouldUseNarrowLayout} = useResponsiveLayout();
     const {isOffline} = useNetwork();
     const {accountID, login: currentUserLogin} = useCurrentUserPersonalDetails();
     const {currentReportID: currentReportIDValue} = useCurrentReportIDState();
     const derivedCurrentReportID = currentReportIDForTests ?? currentReportIDValue;
-    const prevDerivedCurrentReportID = usePrevious(derivedCurrentReportID);
-
-    // we need to force reportsToDisplayInLHN to re-compute when we clear currentReportsToDisplay, but the way it currently works relies on not having currentReportsToDisplay as a memo dependency, so we just need something we can change to trigger it
-    // I don't like it either, but clearing the cache is only a hack for the debug modal and I will endeavor to make it better as I work to improve the cache correctness of the LHN more broadly
-    const [clearCacheDummyCounter, setClearCacheDummyCounter] = useState(0);
 
-    const prevBetas = usePrevious(betas);
-    const prevPriorityMode = usePrevious(priorityMode);
-    const prevIsOffline = usePrevious(isOffline);
+    const baseOrderedReportIDs = derived?.orderedReportIDs ?? EMPTY_ORDERED_REPORT_IDS;
+    const baseReportsToDisplay = derived?.reportsToDisplay;
 
-    const perfRef = useRef<{hookDuration: number}>({
-        hookDuration: 0,
-    });
-    const hookStartTime = useRef<number>(performance.now());
-
-    /**
-     * Find the reports that need to be updated in the LHN
-     */
-    const getUpdatedReports = useCallback(() => {
-        const reportsToUpdate = new Set<string>();
+    // Web parity: when the active report would not normally pass `shouldDisplayReportInLHN` we still
+    // need it to appear in the LHN. Recompute once with `currentReportID` set when that happens.
+    // Mobile (narrow layout) only triggers the recompute when the list is otherwise empty.
+    const orderedReportIDs = useMemo(() => {
+        const needsCurrentReportInjected =
+            (!shouldUseNarrowLayout || baseOrderedReportIDs.length === 0) &&
+            !!derivedCurrentReportID &&
+            derivedCurrentReportID !== '-1' &&
+            baseOrderedReportIDs.indexOf(derivedCurrentReportID) === -1;
 
-        if (betas !== prevBetas || priorityMode !== prevPriorityMode || isOffline !== prevIsOffline) {
-            for (const key of Object.keys(chatReports ?? {})) {
-                reportsToUpdate.add(key);
-            }
-        }
-        if (reportUpdates) {
-            for (const key of Object.keys(reportUpdates ?? {})) {
-                reportsToUpdate.add(key);
-            }
-        }
-        if (reportNameValuePairsUpdates) {
-            for (const key of Object.keys(reportNameValuePairsUpdates ?? {}).map((reportKey) => reportKey.replace(ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS, ONYXKEYS.COLLECTION.REPORT))) {
-                reportsToUpdate.add(key);
-            }
-        }
-        if (transactionsUpdates) {
-            for (const key of Object.values(transactionsUpdates ?? {}).map((transaction) => `${ONYXKEYS.COLLECTION.REPORT}${transaction?.reportID}`)) {
-                reportsToUpdate.add(key);
-            }
-        }
-        if (transactionViolationsUpdates) {
-            for (const key of Object.keys(transactionViolationsUpdates ?? {})
-                .map((violationKey) => violationKey.replace(ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS, ONYXKEYS.COLLECTION.TRANSACTION))
-                .map((transactionKey) => `${ONYXKEYS.COLLECTION.REPORT}${transactions?.[transactionKey]?.reportID}`)) {
-                reportsToUpdate.add(key);
-            }
-        }
-        if (reportsDraftsUpdates) {
-            for (const key of Object.keys(reportsDraftsUpdates).map((draftKey) => draftKey.replace(ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT, ONYXKEYS.COLLECTION.REPORT))) {
-                reportsToUpdate.add(key);
-            }
+        if (!needsCurrentReportInjected) {
+            return baseOrderedReportIDs;
         }
-        if (policiesUpdates) {
-            const updatedPolicies = new Set(Object.keys(policiesUpdates).map((policyKey) => policyKey.replace(ONYXKEYS.COLLECTION.POLICY, '')));
-            for (const key of Object.entries(chatReports ?? {})
-                .filter(([, value]) => {
-                    if (!value?.policyID) {
-                        return;
-                    }
 
-                    return updatedPolicies.has(value.policyID);
-                })
-                .map(([reportKey]) => reportKey)) {
-                reportsToUpdate.add(key);
+        const reportsToDisplay = SidebarUtils.updateReportsToDisplayInLHN({
+            displayedReports: baseReportsToDisplay ?? {},
+            reports: chatReports,
+            updatedReportsKeys: [`${ONYXKEYS.COLLECTION.REPORT}${derivedCurrentReportID}`],
+            currentReportId: derivedCurrentReportID,
+            isInFocusMode: priorityMode === CONST.PRIORITY_MODE.GSD,
+            betas,
+            transactionViolations,
+            reportNameValuePairs,
+            reportAttributes,
+            draftComments: reportsDrafts,
+            transactions,
+            isOffline,
+            currentUserLogin: currentUserLogin ?? '',
+            currentUserAccountID: accountID,
+        });
+
+        const hasDraftByReportID: Record<string, boolean> = {};
+        if (reportsDrafts) {
+            for (const [key, value] of Object.entries(reportsDrafts)) {
+                if (value) {
+                    hasDraftByReportID[key.replace(ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT, '')] = true;
+                }
             }
         }
 
-        // Make sure the previous and current reports are always included in the updates when we switch reports.
-        if (prevDerivedCurrentReportID !== derivedCurrentReportID) {
-            reportsToUpdate.add(`${ONYXKEYS.COLLECTION.REPORT}${prevDerivedCurrentReportID}`);
-            reportsToUpdate.add(`${ONYXKEYS.COLLECTION.REPORT}${derivedCurrentReportID}`);
-        }
-
-        return Array.from(reportsToUpdate);
+        return SidebarUtils.sortReportsToDisplayInLHN(reportsToDisplay, priorityMode, localeCompare, hasDraftByReportID, reportNameValuePairs, reportAttributes);
     }, [
-        reportUpdates,
-        reportNameValuePairsUpdates,
-        transactionsUpdates,
-        transactionViolationsUpdates,
-        reportsDraftsUpdates,
-        policiesUpdates,
-        chatReports,
-        transactions,
-        betas,
-        priorityMode,
-        prevBetas,
-        prevPriorityMode,
-        isOffline,
-        prevIsOffline,
-        prevDerivedCurrentReportID,
+        baseOrderedReportIDs,
+        baseReportsToDisplay,
+        shouldUseNarrowLayout,
         derivedCurrentReportID,
-    ]);
-
-    const reportsToDisplayInLHN = useMemo(() => {
-        const updatedReports = getUpdatedReports();
-        const hasCachedReports = Object.keys(currentReportsToDisplay).length > 0;
-
-        // When reportAttributes changes (e.g. on startup hydration) but no report-specific keys were
-        // updated, getUpdatedReports() returns []. Rather than falling through to a full scan of all
-        // reports, recheck only the already-displayed reports with the new reportAttributes.
-        const effectiveUpdatedReports = updatedReports.length === 0 && hasCachedReports ? Object.keys(currentReportsToDisplay) : updatedReports;
-        const shouldDoIncrementalUpdate = effectiveUpdatedReports.length > 0 && hasCachedReports;
-        let reportsToDisplay = {};
-        if (shouldDoIncrementalUpdate) {
-            reportsToDisplay = SidebarUtils.updateReportsToDisplayInLHN({
-                displayedReports: currentReportsToDisplay,
-                reports: chatReports,
-                updatedReportsKeys: effectiveUpdatedReports,
-                currentReportId: derivedCurrentReportID,
-                isInFocusMode: priorityMode === CONST.PRIORITY_MODE.GSD,
-                betas,
-                transactionViolations,
-                reportNameValuePairs,
-                reportAttributes,
-                draftComments: reportsDrafts,
-                transactions,
-                isOffline,
-                currentUserLogin: currentUserLogin ?? '',
-                currentUserAccountID: accountID,
-            });
-        } else {
-            Log.info('[useSidebarOrderedReports] building reportsToDisplay from scratch');
-            reportsToDisplay = SidebarUtils.getReportsToDisplayInLHN({
-                currentReportId: derivedCurrentReportID,
-                reports: chatReports,
-                betas,
-                priorityMode,
-                draftComments: reportsDrafts,
-                transactionViolations,
-                transactions,
-                isOffline,
-                currentUserLogin: currentUserLogin ?? '',
-                currentUserAccountID: accountID,
-                reportNameValuePairs,
-                reportAttributes,
-            });
-        }
-
-        return reportsToDisplay;
-        // Rule disabled intentionally — triggering a re-render on currentReportsToDisplay would cause an infinite loop
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [
-        getUpdatedReports,
         chatReports,
-        derivedCurrentReportID,
-        priorityMode,
         betas,
-        transactionViolations,
-        reportNameValuePairs,
-        reportAttributes,
+        priorityMode,
         reportsDrafts,
+        transactionViolations,
+        transactions,
         isOffline,
-        clearCacheDummyCounter,
         currentUserLogin,
         accountID,
+        reportNameValuePairs,
+        reportAttributes,
+        localeCompare,
     ]);
 
-    // Derive a stable boolean map indicating which reports have drafts.
-    const hasDraftByReportIDRef = useRef<Record<string, boolean>>({});
-    const hasDraftByReportID = useMemo(() => {
-        const result: Record<string, boolean> = {};
-        if (reportsDrafts) {
-            for (const [key, value] of Object.entries(reportsDrafts)) {
-                if (value) {
-                    result[key.replace(ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT, '')] = true;
-                }
-            }
-        }
-        const prev = hasDraftByReportIDRef.current;
-        const prevKeys = Object.keys(prev);
-        const newKeys = Object.keys(result);
-        if (prevKeys.length === newKeys.length && newKeys.every((k) => k in prev)) {
-            return prev;
-        }
-        hasDraftByReportIDRef.current = result;
-        return result;
-    }, [reportsDrafts]);
-
-    useEffect(() => {
-        setCurrentReportsToDisplay(reportsToDisplayInLHN);
-    }, [reportsToDisplayInLHN]);
-
-    const getOrderedReportIDs = useCallback(
-        () => SidebarUtils.sortReportsToDisplayInLHN(reportsToDisplayInLHN, priorityMode, localeCompare, hasDraftByReportID, reportNameValuePairs, reportAttributes),
-        // Rule disabled intentionally - reports should be sorted only when the reportsToDisplayInLHN changes
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-        [reportsToDisplayInLHN, localeCompare, hasDraftByReportID, reportAttributes],
-    );
-
-    const orderedReportIDs = useMemo(() => getOrderedReportIDs(), [getOrderedReportIDs]);
-
-    // Get the actual reports based on the ordered IDs
-    const getOrderedReports = useCallback(
-        (reportIDs: string[]): OnyxTypes.Report[] => {
-            if (!chatReports) {
-                return [];
-            }
-            return reportIDs.map((reportID) => chatReports[`${ONYXKEYS.COLLECTION.REPORT}${reportID}`]).filter(Boolean) as OnyxTypes.Report[];
-        },
-        [chatReports],
-    );
-
-    const orderedReports = useMemo(() => getOrderedReports(orderedReportIDs), [getOrderedReports, orderedReportIDs]);
-
-    const clearLHNCache = useCallback(() => {
-        Log.info('[useSidebarOrderedReports] Clearing sidebar cache manually via debug modal');
-        setCurrentReportsToDisplay({});
-        setClearCacheDummyCounter((current) => current + 1);
-    }, []);
-
-    const stateValue: SidebarOrderedReportsStateContextValue = useMemo(() => {
-        // We need to make sure the current report is in the list of reports, but we do not want
-        // to have to re-generate the list every time the currentReportID changes. To do that
-        // we first generate the list as if there was no current report, then we check if
-        // the current report is missing from the list, which should very rarely happen. In this
-        // case we re-generate the list a 2nd time with the current report included.
-
-        // We also execute the following logic if `shouldUseNarrowLayout` is false because this is
-        // requirement for web. Consider a case, where we have report with expenses and we click on
-        // any expense, a new LHN item is added in the list and is visible on web. But on mobile, we
-        // just navigate to the screen with expense details, so there seems no point to execute this logic on mobile.
-        if (
-            (!shouldUseNarrowLayout || orderedReportIDs.length === 0) &&
-            derivedCurrentReportID &&
-            derivedCurrentReportID !== '-1' &&
-            orderedReportIDs.indexOf(derivedCurrentReportID) === -1
-        ) {
-            const updatedReportIDs = getOrderedReportIDs();
-            const updatedReports = getOrderedReports(updatedReportIDs);
-            return {
-                orderedReports: updatedReports,
-                orderedReportIDs: updatedReportIDs,
-                currentReportID: derivedCurrentReportID,
-                chatTabBrickRoad: getChatTabBrickRoad(updatedReportIDs, reportAttributes),
-            };
-        }
-
-        return {
-            orderedReports,
+    const stateValue: SidebarOrderedReportsStateContextValue = useMemo(
+        () => ({
             orderedReportIDs,
             currentReportID: derivedCurrentReportID,
             chatTabBrickRoad: getChatTabBrickRoad(orderedReportIDs, reportAttributes),
-        };
-    }, [getOrderedReportIDs, orderedReportIDs, derivedCurrentReportID, shouldUseNarrowLayout, getOrderedReports, orderedReports, reportAttributes]);
-
-    const actionsValue: SidebarOrderedReportsActionsContextValue = useMemo(() => ({clearLHNCache}), [clearLHNCache]);
-
-    useEffect(() => {
-        const hookExecutionDuration = performance.now() - hookStartTime.current;
-        perfRef.current.hookDuration = hookExecutionDuration;
-    }, [stateValue]);
-
-    return (
-        <SidebarOrderedReportsStateContext.Provider value={stateValue}>
-            <SidebarOrderedReportsActionsContext.Provider value={actionsValue}>{children}</SidebarOrderedReportsActionsContext.Provider>
-        </SidebarOrderedReportsStateContext.Provider>
+        }),
+        [orderedReportIDs, derivedCurrentReportID, reportAttributes],
     );
+
+    return <SidebarOrderedReportsStateContext.Provider value={stateValue}>{children}</SidebarOrderedReportsStateContext.Provider>;
 }
 
 function useSidebarOrderedReportsState(componentName?: string) {
@@ -351,14 +144,8 @@ function useSidebarOrderedReportsState(componentName?: string) {
     return useContext(SidebarOrderedReportsStateContext);
 }
 
-function useSidebarOrderedReportsActions() {
-    return useContext(SidebarOrderedReportsActionsContext);
-}
-
 function useSidebarOrderedReports(componentName?: string) {
-    const state = useSidebarOrderedReportsState(componentName);
-    const actions = useSidebarOrderedReportsActions();
-    return {...state, ...actions};
+    return useSidebarOrderedReportsState(componentName);
 }
 
 function useSidebarOrderedReportsPerformance(componentName?: string) {
@@ -395,5 +182,5 @@ function useSidebarOrderedReportsPerformance(componentName?: string) {
     }, [componentName]);
 }
 
-export {SidebarOrderedReportsContextProvider, useSidebarOrderedReports, useSidebarOrderedReportsState, useSidebarOrderedReportsActions};
+export {SidebarOrderedReportsContextProvider, useSidebarOrderedReports, useSidebarOrderedReportsState};
 export type {ReportsToDisplayInLHN};
diff --git a/src/libs/actions/OnyxDerived/ONYX_DERIVED_VALUES.ts b/src/libs/actions/OnyxDerived/ONYX_DERIVED_VALUES.ts
index 161c7f72ecf8..aa46f60882f2 100644
--- a/src/libs/actions/OnyxDerived/ONYX_DERIVED_VALUES.ts
+++ b/src/libs/actions/OnyxDerived/ONYX_DERIVED_VALUES.ts
@@ -7,6 +7,7 @@ import outstandingReportsByPolicyIDConfig from './configs/outstandingReportsByPo
 import personalAndWorkspaceCardListConfig from './configs/personalAndWorkspaceCardList';
 import reportAttributesConfig from './configs/reportAttributes';
 import reportTransactionsAndViolationsConfig from './configs/reportTransactionsAndViolations';
+import sidebarOrderedReportsConfig from './configs/sidebarOrderedReports';
 import sortedReportActionsConfig from './configs/sortedReportActions';
 import todosConfig from './configs/todos';
 import visibleReportActionsConfig from './configs/visibleReportActions';
@@ -27,6 +28,7 @@ const ONYX_DERIVED_VALUES = {
     [ONYXKEYS.DERIVED.TODOS]: todosConfig,
     [ONYXKEYS.DERIVED.RAM_ONLY_SORTED_REPORT_ACTIONS]: sortedReportActionsConfig,
     [ONYXKEYS.DERIVED.OPEN_AND_SUBMITTED_REPORTS_BY_POLICY_ID]: openAndSubmittedReportsByPolicyIDConfig,
+    [ONYXKEYS.DERIVED.RAM_ONLY_SIDEBAR_ORDERED_REPORTS]: sidebarOrderedReportsConfig,
 } as const satisfies {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     [Key in ValueOf<typeof ONYXKEYS.DERIVED>]: OnyxDerivedValueConfig<Key, any>;
diff --git a/src/libs/actions/OnyxDerived/configs/sidebarOrderedReports.ts b/src/libs/actions/OnyxDerived/configs/sidebarOrderedReports.ts
new file mode 100644
index 000000000000..65c222e51453
--- /dev/null
+++ b/src/libs/actions/OnyxDerived/configs/sidebarOrderedReports.ts
@@ -0,0 +1,251 @@
+import {shallowEqual} from 'fast-equals';
+import {getIsOffline} from '@libs/NetworkState';
+import SidebarUtils from '@libs/SidebarUtils';
+import createOnyxDerivedValueConfig from '@userActions/OnyxDerived/createOnyxDerivedValueConfig';
+import CONST from '@src/CONST';
+import IntlStore from '@src/languages/IntlStore';
+import ONYXKEYS from '@src/ONYXKEYS';
+import type {ReportAttributesDerivedValue, Transaction} from '@src/types/onyx';
+import type {SidebarOrderedReportsDerivedValue, SidebarReportForLHN} from '@src/types/onyx/DerivedValues';
+
+const EMPTY_VALUE: SidebarOrderedReportsDerivedValue = {reportsToDisplay: {}, orderedReportIDs: []};
+
+// Cache the collator across computes so we only rebuild it when the locale actually changes.
+let cachedCollator: Intl.Collator | undefined;
+let cachedCollatorLocale: string | undefined;
+
+// Snapshot of the report attributes from the previous compute, used to diff which reports changed when an
+// attributes-only update triggers a recompute. The attributes derived value preserves object references for
+// unchanged reports, so a reference comparison cheaply identifies exactly the reports that changed.
+let previousReportAttributes: ReportAttributesDerivedValue['reports'] | undefined;
+
+// Returns the full report keys whose attributes entry changed between two attributes snapshots (added, removed, or
+// a different object reference). Attributes are keyed by bare reportID, so the keys are mapped to full report keys.
+function getChangedReportAttributeKeys(prev: ReportAttributesDerivedValue['reports'] | undefined, next: ReportAttributesDerivedValue['reports'] | undefined): string[] {
+    if (prev === next) {
+        return [];
+    }
+    const prevReports = prev ?? {};
+    const nextReports = next ?? {};
+    const changedKeys: string[] = [];
+    for (const [reportID, attributes] of Object.entries(nextReports)) {
+        if (prevReports[reportID] !== attributes) {
+            changedKeys.push(`${ONYXKEYS.COLLECTION.REPORT}${reportID}`);
+        }
+    }
+    for (const reportID of Object.keys(prevReports)) {
+        if (!(reportID in nextReports)) {
+            changedKeys.push(`${ONYXKEYS.COLLECTION.REPORT}${reportID}`);
+        }
+    }
+    return changedKeys;
+}
+
+function getLocaleCompare(locale: string): (a: string, b: string) => number {
+    if (!cachedCollator || cachedCollatorLocale !== locale) {
+        cachedCollator = new Intl.Collator(locale, CONST.COLLATOR_OPTIONS);
+        cachedCollatorLocale = locale;
+    }
+    const collator = cachedCollator;
+    return (a, b) => collator.compare(a, b);
+}
+
+const COLLECTION_DEP_KEYS = [
+    ONYXKEYS.COLLECTION.REPORT,
+    ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS,
+    ONYXKEYS.COLLECTION.TRANSACTION,
+    ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS,
+    ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT,
+    ONYXKEYS.COLLECTION.POLICY,
+] as const;
+
+function buildHasDraftMap(reportsDrafts: Record<string, string | null | undefined> | null | undefined): Record<string, boolean> {
+    const result: Record<string, boolean> = {};
+    if (!reportsDrafts) {
+        return result;
+    }
+    for (const [key, value] of Object.entries(reportsDrafts)) {
+        if (value) {
+            result[key.replace(ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT, '')] = true;
+        }
+    }
+    return result;
+}
+
+export default createOnyxDerivedValueConfig({
+    key: ONYXKEYS.DERIVED.RAM_ONLY_SIDEBAR_ORDERED_REPORTS,
+    dependencies: [
+        ONYXKEYS.COLLECTION.REPORT,
+        ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS,
+        ONYXKEYS.COLLECTION.TRANSACTION,
+        ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS,
+        ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT,
+        ONYXKEYS.COLLECTION.POLICY,
+        ONYXKEYS.NVP_PRIORITY_MODE,
+        ONYXKEYS.BETAS,
+        ONYXKEYS.NETWORK,
+        ONYXKEYS.NVP_PREFERRED_LOCALE,
+        ONYXKEYS.DERIVED.REPORT_ATTRIBUTES,
+        ONYXKEYS.SESSION,
+    ],
+    compute: (
+        [reports, reportNameValuePairs, transactions, transactionViolations, reportsDrafts, , priorityMode, betas, , locale, reportAttributesDerived, session],
+        {currentValue, sourceValues},
+    ): SidebarOrderedReportsDerivedValue => {
+        if (!reports || Object.keys(reports).length === 0) {
+            previousReportAttributes = undefined;
+            return EMPTY_VALUE;
+        }
+
+        const effectivePriorityMode = priorityMode ?? CONST.PRIORITY_MODE.DEFAULT;
+        const isInFocusMode = effectivePriorityMode === CONST.PRIORITY_MODE.GSD;
+        const isOffline = getIsOffline();
+        const reportAttributes = reportAttributesDerived?.reports;
+        const currentUserAccountID = session?.accountID ?? CONST.DEFAULT_NUMBER_ID;
+        const currentUserLogin = session?.email ?? '';
+
+        // Compute incremental updates when a collection dep changed, or when DERIVED.REPORT_ATTRIBUTES changed and we
+        // can diff it against the previous snapshot. Other scalar changes (BETAS, NVP_PRIORITY_MODE, NETWORK,
+        // NVP_PREFERRED_LOCALE) broadly affect which reports qualify, so they force a full recompute.
+        const collectionUpdates = sourceValues
+            ? COLLECTION_DEP_KEYS.reduce<Record<string, Record<string, unknown> | undefined>>((acc, collectionKey) => {
+                  const update = sourceValues[collectionKey];
+                  if (update) {
+                      acc[collectionKey] = update;
+                  }
+                  return acc;
+              }, {})
+            : {};
+        const hasCollectionUpdate = Object.keys(collectionUpdates).length > 0;
+
+        // An attributes-only trigger re-evaluates exactly the reports whose attributes changed. Diff against the
+        // previous snapshot before overwriting it; the first trigger (no snapshot) falls back to a full recompute.
+        const attributesTriggered = !!sourceValues?.[ONYXKEYS.DERIVED.REPORT_ATTRIBUTES];
+        const canDiffAttributes = attributesTriggered && previousReportAttributes !== undefined;
+        const attributeReportKeys = canDiffAttributes ? getChangedReportAttributeKeys(previousReportAttributes, reportAttributes) : [];
+        previousReportAttributes = reportAttributes;
+
+        const canIncremental = !!currentValue && (hasCollectionUpdate || canDiffAttributes) && Object.keys(currentValue.reportsToDisplay).length > 0;
+
+        let reportsToDisplay: Record<string, SidebarReportForLHN>;
+        if (canIncremental && currentValue) {
+            const updatedReportsKeys = new Set<string>();
+
+            const reportUpdates = collectionUpdates[ONYXKEYS.COLLECTION.REPORT];
+            if (reportUpdates) {
+                for (const key of Object.keys(reportUpdates)) {
+                    updatedReportsKeys.add(key);
+                }
+            }
+
+            const rnvpUpdates = collectionUpdates[ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS];
+            if (rnvpUpdates) {
+                for (const key of Object.keys(rnvpUpdates)) {
+                    updatedReportsKeys.add(key.replace(ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS, ONYXKEYS.COLLECTION.REPORT));
+                }
+            }
+
+            const transactionUpdates = collectionUpdates[ONYXKEYS.COLLECTION.TRANSACTION];
+            if (transactionUpdates) {
+                for (const transaction of Object.values(transactionUpdates)) {
+                    const txn = transaction as Transaction | null | undefined;
+                    if (!txn?.reportID) {
+                        continue;
+                    }
+                    updatedReportsKeys.add(`${ONYXKEYS.COLLECTION.REPORT}${txn.reportID}`);
+                }
+            }
+
+            const violationUpdates = collectionUpdates[ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS];
+            if (violationUpdates) {
+                for (const violationKey of Object.keys(violationUpdates)) {
+                    const transactionKey = violationKey.replace(ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS, ONYXKEYS.COLLECTION.TRANSACTION);
+                    const linkedReportID = transactions?.[transactionKey]?.reportID;
+                    if (linkedReportID) {
+                        updatedReportsKeys.add(`${ONYXKEYS.COLLECTION.REPORT}${linkedReportID}`);
+                    }
+                }
+            }
+
+            const draftUpdates = collectionUpdates[ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT];
+            if (draftUpdates) {
+                for (const draftKey of Object.keys(draftUpdates)) {
+                    updatedReportsKeys.add(draftKey.replace(ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT, ONYXKEYS.COLLECTION.REPORT));
+                }
+            }
+
+            const policyUpdates = collectionUpdates[ONYXKEYS.COLLECTION.POLICY];
+            if (policyUpdates) {
+                const updatedPolicyIDs = new Set(Object.keys(policyUpdates).map((policyKey) => policyKey.replace(ONYXKEYS.COLLECTION.POLICY, '')));
+                for (const [reportKey, report] of Object.entries(reports)) {
+                    if (report?.policyID && updatedPolicyIDs.has(report.policyID)) {
+                        updatedReportsKeys.add(reportKey);
+                    }
+                }
+            }
+
+            if (canDiffAttributes) {
+                for (const key of attributeReportKeys) {
+                    updatedReportsKeys.add(key);
+                }
+            }
+
+            reportsToDisplay = SidebarUtils.updateReportsToDisplayInLHN({
+                displayedReports: currentValue.reportsToDisplay,
+                reports,
+                updatedReportsKeys: Array.from(updatedReportsKeys),
+                currentReportId: undefined,
+                isInFocusMode,
+                betas,
+                transactionViolations,
+                reportNameValuePairs,
+                reportAttributes,
+                draftComments: reportsDrafts,
+                transactions,
+                isOffline,
+                currentUserLogin,
+                currentUserAccountID,
+            });
+        } else {
+            reportsToDisplay = SidebarUtils.getReportsToDisplayInLHN({
+                currentReportId: undefined,
+                reports,
+                betas,
+                priorityMode: effectivePriorityMode,
+                draftComments: reportsDrafts,
+                transactionViolations,
+                transactions,
+                isOffline,
+                currentUserLogin,
+                currentUserAccountID,
+                reportNameValuePairs,
+                reportAttributes,
+            });
+        }
+
+        const localeCompare = getLocaleCompare(locale ?? IntlStore.getCurrentLocale() ?? CONST.LOCALES.DEFAULT);
+        const hasDraftByReportID = buildHasDraftMap(reportsDrafts);
+
+        const nextOrderedReportIDs = SidebarUtils.sortReportsToDisplayInLHN(
+            reportsToDisplay,
+            effectivePriorityMode,
+            localeCompare,
+            hasDraftByReportID,
+            reportNameValuePairs,
+            reportAttributes,
+        );
+
+        // Preserve referential stability when nothing meaningful changed downstream.
+        const stableReportsToDisplay = currentValue && reportsToDisplay === currentValue.reportsToDisplay ? currentValue.reportsToDisplay : reportsToDisplay;
+        const stableOrderedReportIDs = currentValue && shallowEqual(nextOrderedReportIDs, currentValue.orderedReportIDs) ? currentValue.orderedReportIDs : nextOrderedReportIDs;
+
+        if (stableReportsToDisplay === currentValue?.reportsToDisplay && stableOrderedReportIDs === currentValue?.orderedReportIDs) {
+            return currentValue;
+        }
+
+        return {
+            reportsToDisplay: stableReportsToDisplay,
+            orderedReportIDs: stableOrderedReportIDs,
+        };
+    },
+});
diff --git a/src/libs/actions/OnyxDerived/types.ts b/src/libs/actions/OnyxDerived/types.ts
index a7b14999a9ba..5aae5ddd4714 100644
--- a/src/libs/actions/OnyxDerived/types.ts
+++ b/src/libs/actions/OnyxDerived/types.ts
@@ -13,7 +13,10 @@ type DerivedSourceValues<Deps extends readonly OnyxKey[]> = Partial<{
     [K in Deps[number]]: OnyxCollectionSourceValue<K>;
 }>;
 
-type DerivedValueContext<Key extends OnyxKey, Deps extends NonEmptyTuple<Exclude<OnyxKey, Key>>> = {
+// Deps is loosened to `readonly OnyxKey[]` here so the framework's init loop (which collapses all
+// configs' Key types into a union) doesn't have its `Exclude<OnyxKey, Key>` constraint reject every
+// derived key. Per-config self-reference is still prevented by `OnyxDerivedValueConfig` below.
+type DerivedValueContext<Key extends OnyxKey, Deps extends readonly OnyxKey[]> = {
     currentValue?: OnyxValue<Key>;
     sourceValues?: DerivedSourceValues<Deps>;
 };
diff --git a/src/pages/inbox/sidebar/SidebarLinks.tsx b/src/pages/inbox/sidebar/SidebarLinks.tsx
index a367a114ca02..6745f7f0b3ea 100644
--- a/src/pages/inbox/sidebar/SidebarLinks.tsx
+++ b/src/pages/inbox/sidebar/SidebarLinks.tsx
@@ -26,7 +26,7 @@ type SidebarLinksProps = {
     insets: EdgeInsets;
 
     /** List of options to display */
-    optionListItems: Report[];
+    optionListItems: string[];
 
     /** The chat priority mode */
     priorityMode?: OnyxEntry<ValueOf<typeof CONST.PRIORITY_MODE>>;
diff --git a/src/pages/inbox/sidebar/SidebarLinksData.tsx b/src/pages/inbox/sidebar/SidebarLinksData.tsx
index 1c4879c15884..592fb94494db 100644
--- a/src/pages/inbox/sidebar/SidebarLinksData.tsx
+++ b/src/pages/inbox/sidebar/SidebarLinksData.tsx
@@ -23,7 +23,7 @@ function SidebarLinksData({insets}: SidebarLinksDataProps) {
     const {translate} = useLocalize();
     const [priorityMode = CONST.PRIORITY_MODE.DEFAULT] = useOnyx(ONYXKEYS.NVP_PRIORITY_MODE);
 
-    const {orderedReports, currentReportID} = useSidebarOrderedReportsState('SidebarLinksData');
+    const {orderedReportIDs, currentReportID} = useSidebarOrderedReportsState('SidebarLinksData');
 
     const currentReportIDRef = useRef(currentReportID);
     currentReportIDRef.current = currentReportID;
@@ -80,7 +80,7 @@ function SidebarLinksData({insets}: SidebarLinksDataProps) {
                 priorityMode={priorityMode ?? CONST.PRIORITY_MODE.DEFAULT}
                 // Data props:
                 isActiveReport={isActiveReport}
-                optionListItems={orderedReports}
+                optionListItems={orderedReportIDs}
             />
         </View>
     );
diff --git a/src/setup/index.ts b/src/setup/index.ts
index 455c516cc730..877887faf34f 100644
--- a/src/setup/index.ts
+++ b/src/setup/index.ts
@@ -71,6 +71,7 @@ export default function () {
             ONYXKEYS.RAM_ONLY_MERGE_HR_LINK_TOKEN,
             ONYXKEYS.COLLECTION.RAM_ONLY_ISSUE_NEW_EXPENSIFY_CARD,
             ONYXKEYS.RAM_ONLY_DOMAIN_MEMBERS_SELECTED_FOR_MOVE,
+            ONYXKEYS.DERIVED.RAM_ONLY_SIDEBAR_ORDERED_REPORTS,
         ],
     });
 
diff --git a/src/types/onyx/DerivedValues.ts b/src/types/onyx/DerivedValues.ts
index bbcecb4f4d6f..1df5b4cc0d57 100644
--- a/src/types/onyx/DerivedValues.ts
+++ b/src/types/onyx/DerivedValues.ts
@@ -283,6 +283,27 @@ type SortedReportActionsDerivedValue = {
  */
 type PersonalAndWorkspaceCardListDerivedValue = CardList;
 
+/**
+ * A report enriched with LHN-only metadata used during sidebar filtering/sorting.
+ */
+type SidebarReportForLHN = Report & {
+    /** True when report has non-receipt errors surfaced in LHN. */
+    hasErrorsOtherThanFailedReceipt?: boolean;
+    /** True when report requires action from current user (GBR). */
+    requiresAttention?: boolean;
+};
+
+/**
+ * The derived value for the LHN sidebar ordering. Computed outside React to avoid React's
+ * batching dropping intermediate Onyx source-value updates.
+ */
+type SidebarOrderedReportsDerivedValue = {
+    /** Reports kept after LHN filtering, keyed by `reports_<id>` (the same shape as the REPORT collection). */
+    reportsToDisplay: Record<string, SidebarReportForLHN>;
+    /** Sorted report IDs (no `reports_` prefix) representing LHN row order. */
+    orderedReportIDs: string[];
+};
+
 export type {
     ReportAttributes,
     ReportAttributesDerivedValue,
@@ -301,4 +322,6 @@ export type {
     CardFeedErrorState,
     CardFeedErrors,
     CardErrors,
+    SidebarOrderedReportsDerivedValue,
+    SidebarReportForLHN,
 };
diff --git a/src/types/onyx/index.ts b/src/types/onyx/index.ts
index 2d530f190329..78adcaa875a7 100644
--- a/src/types/onyx/index.ts
+++ b/src/types/onyx/index.ts
@@ -54,6 +54,7 @@ import type {
     PersonalAndWorkspaceCardListDerivedValue,
     ReportAttributesDerivedValue,
     ReportTransactionsAndViolationsDerivedValue,
+    SidebarOrderedReportsDerivedValue,
     SortedReportActionsDerivedValue,
     TodoMetadata,
     TodosDerivedValue,
@@ -394,6 +395,7 @@ export type {
     OpenAndSubmittedReportsByPolicyIDDerivedValue,
     VisibleReportActionsDerivedValue,
     SortedReportActionsDerivedValue,
+    SidebarOrderedReportsDerivedValue,
     NonPersonalAndWorkspaceCardListDerivedValue,
     PersonalAndWorkspaceCardListDerivedValue,
     CardFeedErrorsDerivedValue,
diff --git a/tests/perf-test/SidebarLinks.perf-test.tsx b/tests/perf-test/SidebarLinks.perf-test.tsx
index 66f9493aa726..27ac27c5d14a 100644
--- a/tests/perf-test/SidebarLinks.perf-test.tsx
+++ b/tests/perf-test/SidebarLinks.perf-test.tsx
@@ -1,7 +1,9 @@
+import type * as reactNavigationNativeImport from '@react-navigation/native';
 import {fireEvent, screen, waitFor} from '@testing-library/react-native';
 import Onyx from 'react-native-onyx';
 import {measureRenders} from 'reassure';
 import {setHasRadio} from '@libs/NetworkState';
+import initOnyxDerivedValues from '@userActions/OnyxDerived';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
 import * as LHNTestUtils from '../utils/LHNTestUtils';
@@ -31,7 +33,14 @@ jest.mock('../../src/libs/Navigation/navigationRef', () => ({
     isReady: () => true,
 }));
 
-jest.mock('@react-navigation/native');
+jest.mock('@react-navigation/native', () => ({
+    ...jest.requireActual<typeof reactNavigationNativeImport>('@react-navigation/native'),
+    useNavigationState: () => undefined,
+    useIsFocused: () => true,
+    useRoute: () => ({name: 'Home'}),
+    useNavigation: () => undefined,
+    useFocusEffect: () => undefined,
+}));
 
 const getMockedReportsMap = (length = 100) => {
     const mockReports = Object.fromEntries(
@@ -56,6 +65,8 @@ describe('SidebarLinks', () => {
             keys: ONYXKEYS,
             evictableKeys: [ONYXKEYS.COLLECTION.REPORT_ACTIONS],
         });
+
+        initOnyxDerivedValues();
     });
 
     beforeEach(() => {
diff --git a/tests/perf-test/SidebarOrderedReportsDerivedValue.perf-test.ts b/tests/perf-test/SidebarOrderedReportsDerivedValue.perf-test.ts
new file mode 100644
index 000000000000..8502f32da82a
--- /dev/null
+++ b/tests/perf-test/SidebarOrderedReportsDerivedValue.perf-test.ts
@@ -0,0 +1,135 @@
+import {rand} from '@ngneat/falso';
+import type {OnyxCollection} from 'react-native-onyx';
+import Onyx from 'react-native-onyx';
+import {measureFunction} from 'reassure';
+import type {DerivedValueContext} from '@libs/actions/OnyxDerived/types';
+import CONST from '@src/CONST';
+import sidebarOrderedReportsConfig from '@src/libs/actions/OnyxDerived/configs/sidebarOrderedReports';
+import ONYXKEYS from '@src/ONYXKEYS';
+import type {Beta, Network, ReportAttributesDerivedValue} from '@src/types/onyx';
+import type PriorityMode from '@src/types/onyx/PriorityMode';
+import type Report from '@src/types/onyx/Report';
+import createCollection from '../utils/collections/createCollection';
+import {getRandomDate} from '../utils/collections/reportActions';
+import {createRandomReport} from '../utils/collections/reports';
+import waitForBatchedUpdates from '../utils/waitForBatchedUpdates';
+
+type ConfigArgs = Parameters<typeof sidebarOrderedReportsConfig.compute>[0];
+
+const REPORTS_COUNT = 15000;
+const REPORT_THRESHOLD = 5;
+const SOURCE_UPDATE_BATCH = 10;
+
+const allReports: OnyxCollection<Report> = createCollection<Report>(
+    (item) => `${ONYXKEYS.COLLECTION.REPORT}${item.reportID}`,
+    (index) => ({
+        ...createRandomReport(index, undefined),
+        type: rand(Object.values(CONST.REPORT.TYPE)),
+        lastVisibleActionCreated: getRandomDate(),
+        statusNum: index % REPORT_THRESHOLD ? 0 : CONST.REPORT.STATUS_NUM.CLOSED,
+        stateNum: index % REPORT_THRESHOLD ? 0 : CONST.REPORT.STATE_NUM.APPROVED,
+        isUnreadWithMention: false,
+    }),
+    REPORTS_COUNT,
+);
+
+const mockedBetas: Beta[] = Object.values(CONST.BETAS) as Beta[];
+const defaultPriorityMode = CONST.PRIORITY_MODE.DEFAULT as PriorityMode;
+const network: Network = {};
+const locale = 'en';
+
+const EMPTY_CONTEXT: DerivedValueContext<typeof sidebarOrderedReportsConfig.key, typeof sidebarOrderedReportsConfig.dependencies> = {
+    currentValue: undefined,
+    sourceValues: undefined,
+};
+
+function buildArgs(reportAttributes?: ReportAttributesDerivedValue): ConfigArgs {
+    return [allReports, undefined, undefined, undefined, undefined, undefined, defaultPriorityMode, mockedBetas, network, locale, reportAttributes] as unknown as ConfigArgs;
+}
+
+function buildReportAttributes(): ReportAttributesDerivedValue {
+    const reports: ReportAttributesDerivedValue['reports'] = {};
+    for (const key of Object.keys(allReports ?? {})) {
+        const reportID = key.replace(ONYXKEYS.COLLECTION.REPORT, '');
+        reports[reportID] = {
+            reportName: `Report ${reportID}`,
+            isEmpty: false,
+            brickRoadStatus: undefined,
+            requiresAttention: false,
+            reportErrors: {},
+        };
+    }
+    return {reports, locale};
+}
+
+describe('SidebarOrderedReports derived value', () => {
+    beforeAll(() => {
+        Onyx.init({keys: ONYXKEYS, evictableKeys: [ONYXKEYS.COLLECTION.REPORT_ACTIONS]});
+        Onyx.multiSet({[ONYXKEYS.NVP_PREFERRED_LOCALE]: 'en'});
+    });
+
+    afterAll(() => {
+        Onyx.clear();
+    });
+
+    test('[sidebarOrderedReports] full compute, 15k reports, DEFAULT priorityMode', async () => {
+        await waitForBatchedUpdates();
+        await measureFunction(() => sidebarOrderedReportsConfig.compute(buildArgs(), EMPTY_CONTEXT));
+    });
+
+    test('[sidebarOrderedReports] full compute, 15k reports, GSD priorityMode', async () => {
+        await waitForBatchedUpdates();
+        const args = buildArgs();
+        args[6] = CONST.PRIORITY_MODE.GSD as PriorityMode;
+        await measureFunction(() => sidebarOrderedReportsConfig.compute(args, EMPTY_CONTEXT));
+    });
+
+    test('[sidebarOrderedReports] incremental compute, 15k reports, ~10 changed', async () => {
+        await waitForBatchedUpdates();
+        const seeded = sidebarOrderedReportsConfig.compute(buildArgs(), EMPTY_CONTEXT);
+        const reportKeys = Object.keys(allReports ?? {}).slice(0, SOURCE_UPDATE_BATCH);
+        const sourceValue: Record<string, Report | undefined> = {};
+        for (const key of reportKeys) {
+            sourceValue[key] = allReports?.[key];
+        }
+
+        await measureFunction(() =>
+            sidebarOrderedReportsConfig.compute(buildArgs(), {
+                currentValue: seeded,
+                sourceValues: {[ONYXKEYS.COLLECTION.REPORT]: sourceValue},
+            }),
+        );
+    });
+
+    // A REPORT_ATTRIBUTES change is diffed against the previous snapshot, so only the changed reports are
+    // re-evaluated via the incremental path instead of triggering a full recompute.
+    test('[sidebarOrderedReports] report attributes update, 15k reports, ~10 changed', async () => {
+        await waitForBatchedUpdates();
+        const seededAttributes = buildReportAttributes();
+        const seededArgs = buildArgs(seededAttributes);
+        const seeded = sidebarOrderedReportsConfig.compute(seededArgs, EMPTY_CONTEXT);
+
+        // Give ~10 reports a new attributes reference so the diff against the snapshot yields exactly those reports.
+        const updatedReports: ReportAttributesDerivedValue['reports'] = {...seededAttributes.reports};
+        for (const reportID of Object.keys(seededAttributes.reports).slice(0, SOURCE_UPDATE_BATCH)) {
+            updatedReports[reportID] = {...seededAttributes.reports[reportID], requiresAttention: true};
+        }
+        const updatedAttributes: ReportAttributesDerivedValue = {reports: updatedReports, locale};
+        const updatedArgs = buildArgs(updatedAttributes);
+
+        // DerivedSourceValues only types collection deltas, but the framework passes any changed
+        // dependency's value at runtime, so we cast to feed the non-collection REPORT_ATTRIBUTES source.
+        const context = {
+            currentValue: seeded,
+            sourceValues: {[ONYXKEYS.DERIVED.REPORT_ATTRIBUTES]: updatedAttributes},
+        } as unknown as typeof EMPTY_CONTEXT;
+
+        await measureFunction(() => sidebarOrderedReportsConfig.compute(updatedArgs, context), {
+            // The compute overwrites the module-level attributes snapshot, so reset it to the seeded baseline before
+            // each run (this runs outside the measured section) so every measured compute diffs the same ~10 reports.
+            beforeEach: () => {
+                sidebarOrderedReportsConfig.compute(seededArgs, EMPTY_CONTEXT);
+            },
+        });
+    });
+});
diff --git a/tests/ui/components/LHNOptionsListTest.tsx b/tests/ui/components/LHNOptionsListTest.tsx
index ae1f424d8ce9..e68177be1171 100644
--- a/tests/ui/components/LHNOptionsListTest.tsx
+++ b/tests/ui/components/LHNOptionsListTest.tsx
@@ -80,7 +80,7 @@ describe('LHNOptionsList', () => {
     const mockReport = getFakeReport([1, 2], 0, false);
 
     const defaultProps: LHNOptionsListProps = {
-        data: [mockReport],
+        data: [mockReport.reportID],
         onSelectRow: jest.fn(),
         optionMode: CONST.OPTION_MODE.DEFAULT,
         onFirstItemRendered: jest.fn(),
@@ -108,7 +108,7 @@ describe('LHNOptionsList', () => {
         );
     };
 
-    beforeEach(() => {
+    beforeEach(async () => {
         act(() => {
             Onyx.init({
                 keys: ONYXKEYS,
@@ -116,6 +116,11 @@ describe('LHNOptionsList', () => {
         });
 
         jest.clearAllMocks();
+
+        // LHNOptionsList resolves each row's report from Onyx by ID, so the default report must be present.
+        await act(async () => {
+            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${mockReport.reportID}`, mockReport);
+        });
     });
 
     afterEach(() => {
@@ -255,7 +260,7 @@ describe('LHNOptionsList', () => {
             });
 
             // When the LHNOptionsList is rendered
-            render(getLHNOptionsListElement({data: [report]}));
+            render(getLHNOptionsListElement({data: [report.reportID]}));
 
             // Then the queued message should be displayed because DEW submissions are processed async and the user needs feedback
             const reportItem = await waitFor(() => getReportItem(reportID));
@@ -312,7 +317,7 @@ describe('LHNOptionsList', () => {
             });
 
             // When the LHNOptionsList is rendered
-            render(getLHNOptionsListElement({data: [report]}));
+            render(getLHNOptionsListElement({data: [report.reportID]}));
 
             // Then the queued message should NOT appear because the server processes DEW submissions immediately when online
             const reportItem = await waitFor(() => getReportItem(reportID));
@@ -379,7 +384,7 @@ describe('LHNOptionsList', () => {
             });
 
             // When the LHNOptionsList renders the workspace thread
-            render(getLHNOptionsListElement({data: [threadReport]}));
+            render(getLHNOptionsListElement({data: [threadReport.reportID]}));
 
             // Then it should render a single avatar, not a diagonal (multiple) avatar
             await waitFor(() => {
@@ -455,7 +460,7 @@ describe('LHNOptionsList', () => {
             });
 
             // When the LHNOptionsList renders the expense request thread
-            render(getLHNOptionsListElement({data: [threadReport]}));
+            render(getLHNOptionsListElement({data: [threadReport.reportID]}));
 
             // Then it should render a subscript avatar (workspace expense requests preserve subscript)
             await waitFor(() => {
@@ -520,7 +525,7 @@ describe('LHNOptionsList', () => {
             });
 
             // When the LHNOptionsList renders the task report
-            render(getLHNOptionsListElement({data: [taskReport]}));
+            render(getLHNOptionsListElement({data: [taskReport.reportID]}));
 
             // Then it should render a subscript avatar (Large User + Small Workspace)
             await waitFor(() => {
@@ -584,7 +589,7 @@ describe('LHNOptionsList', () => {
             });
 
             // When the LHNOptionsList renders the invoice report
-            render(getLHNOptionsListElement({data: [invoiceReport]}));
+            render(getLHNOptionsListElement({data: [invoiceReport.reportID]}));
 
             // Then it should render a subscript avatar (workspace icon + user avatar)
             await waitFor(() => {
@@ -633,7 +638,7 @@ describe('LHNOptionsList', () => {
             });
 
             // When the LHNOptionsList renders the IOU report
-            render(getLHNOptionsListElement({data: [report]}));
+            render(getLHNOptionsListElement({data: [report.reportID]}));
 
             // Then it should render diagonal (multiple) avatars
             await waitFor(() => {
diff --git a/tests/unit/SidebarOrderedReportsDerivedValueTest.ts b/tests/unit/SidebarOrderedReportsDerivedValueTest.ts
new file mode 100644
index 000000000000..a59ab776763f
--- /dev/null
+++ b/tests/unit/SidebarOrderedReportsDerivedValueTest.ts
@@ -0,0 +1,256 @@
+import type {OnyxCollection, OnyxEntry} from 'react-native-onyx';
+import type {DerivedValueContext} from '@libs/actions/OnyxDerived/types';
+import SidebarUtils from '@libs/SidebarUtils';
+import CONST from '@src/CONST';
+import sidebarOrderedReportsConfig from '@src/libs/actions/OnyxDerived/configs/sidebarOrderedReports';
+import ONYXKEYS from '@src/ONYXKEYS';
+import type {Beta, Network, Report, ReportAttributesDerivedValue} from '@src/types/onyx';
+import type PriorityMode from '@src/types/onyx/PriorityMode';
+
+type ConfigArgs = Parameters<typeof sidebarOrderedReportsConfig.compute>[0];
+type DerivedContext = DerivedValueContext<typeof sidebarOrderedReportsConfig.key, typeof sidebarOrderedReportsConfig.dependencies>;
+
+const EMPTY_CONTEXT: DerivedContext = {currentValue: undefined, sourceValues: undefined};
+
+function makeReport(id: string, millisAgo: number, overrides: Partial<Report> = {}): Report {
+    const ts = new Date(Date.now() - millisAgo).toISOString().replace('T', ' ').slice(0, -1);
+    return {
+        reportID: id,
+        type: CONST.REPORT.TYPE.CHAT,
+        chatType: CONST.REPORT.CHAT_TYPE.GROUP,
+        reportName: `Report ${id}`,
+        lastVisibleActionCreated: ts,
+        lastReadTime: ts,
+        lastMessageText: `msg ${id}`,
+        participants: Object.fromEntries([1, 2].map((accountID) => [accountID, {notificationPreference: 'always'}])),
+        ...overrides,
+    } as Report;
+}
+
+function buildArgs(
+    reports: OnyxCollection<Report>,
+    overrides: Partial<{priorityMode: PriorityMode; betas: Beta[]; network: Network; locale: string; reportAttributes: ReportAttributesDerivedValue}> = {},
+): ConfigArgs {
+    const priorityMode: OnyxEntry<PriorityMode> = overrides.priorityMode ?? (CONST.PRIORITY_MODE.DEFAULT as PriorityMode);
+    const betas: OnyxEntry<Beta[]> = overrides.betas ?? [];
+    const network: OnyxEntry<Network> = overrides.network ?? {};
+    const locale = overrides.locale ?? 'en';
+    return [reports, undefined, undefined, undefined, undefined, undefined, priorityMode, betas, network, locale, overrides.reportAttributes] as unknown as ConfigArgs;
+}
+
+function makeAttributes(entries: Array<[reportID: string, requiresAttention: boolean]>): ReportAttributesDerivedValue {
+    const reports: ReportAttributesDerivedValue['reports'] = {};
+    for (const [reportID, requiresAttention] of entries) {
+        reports[reportID] = {reportName: `Report ${reportID}`, isEmpty: false, brickRoadStatus: undefined, requiresAttention, reportErrors: {}};
+    }
+    return {reports, locale: 'en'};
+}
+
+describe('SidebarOrderedReports Derived Value', () => {
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    it('returns empty value when reports collection is empty', () => {
+        const result = sidebarOrderedReportsConfig.compute(buildArgs({}), EMPTY_CONTEXT);
+        expect(result.orderedReportIDs).toEqual([]);
+        expect(result.reportsToDisplay).toEqual({});
+    });
+
+    it('returns empty value when reports is undefined', () => {
+        const result = sidebarOrderedReportsConfig.compute(buildArgs(undefined), EMPTY_CONTEXT);
+        expect(result.orderedReportIDs).toEqual([]);
+        expect(result.reportsToDisplay).toEqual({});
+    });
+
+    it('takes the full-compute path when no currentValue exists', () => {
+        const reports: Record<string, Report> = {[`${ONYXKEYS.COLLECTION.REPORT}1`]: makeReport('1', 1_000)};
+        const getSpy = jest.spyOn(SidebarUtils, 'getReportsToDisplayInLHN');
+        const updateSpy = jest.spyOn(SidebarUtils, 'updateReportsToDisplayInLHN');
+
+        sidebarOrderedReportsConfig.compute(buildArgs(reports), EMPTY_CONTEXT);
+
+        expect(getSpy).toHaveBeenCalledTimes(1);
+        expect(updateSpy).not.toHaveBeenCalled();
+    });
+
+    it('takes the incremental path when a collection sourceValue is present and the cache is populated', () => {
+        const reports: Record<string, Report> = {[`${ONYXKEYS.COLLECTION.REPORT}1`]: makeReport('1', 1_000)};
+        const seededCurrent = {
+            reportsToDisplay: {[`${ONYXKEYS.COLLECTION.REPORT}1`]: reports[`${ONYXKEYS.COLLECTION.REPORT}1`]},
+            orderedReportIDs: ['1'],
+        };
+
+        const getSpy = jest.spyOn(SidebarUtils, 'getReportsToDisplayInLHN');
+        const updateSpy = jest.spyOn(SidebarUtils, 'updateReportsToDisplayInLHN');
+
+        sidebarOrderedReportsConfig.compute(buildArgs(reports), {
+            currentValue: seededCurrent,
+            sourceValues: {[ONYXKEYS.COLLECTION.REPORT]: {[`${ONYXKEYS.COLLECTION.REPORT}1`]: reports[`${ONYXKEYS.COLLECTION.REPORT}1`]}},
+        });
+
+        expect(updateSpy).toHaveBeenCalledTimes(1);
+        expect(getSpy).not.toHaveBeenCalled();
+    });
+
+    it('falls back to the full path when sourceValues is undefined even if currentValue exists', () => {
+        const reports: Record<string, Report> = {[`${ONYXKEYS.COLLECTION.REPORT}1`]: makeReport('1', 1_000)};
+        const seededCurrent = {
+            reportsToDisplay: {[`${ONYXKEYS.COLLECTION.REPORT}1`]: reports[`${ONYXKEYS.COLLECTION.REPORT}1`]},
+            orderedReportIDs: ['1'],
+        };
+        const getSpy = jest.spyOn(SidebarUtils, 'getReportsToDisplayInLHN');
+        const updateSpy = jest.spyOn(SidebarUtils, 'updateReportsToDisplayInLHN');
+
+        sidebarOrderedReportsConfig.compute(buildArgs(reports), {currentValue: seededCurrent, sourceValues: undefined});
+
+        expect(getSpy).toHaveBeenCalledTimes(1);
+        expect(updateSpy).not.toHaveBeenCalled();
+    });
+
+    it('translates REPORT_NAME_VALUE_PAIRS source keys to REPORT keys in the incremental path', () => {
+        const reports: Record<string, Report> = {[`${ONYXKEYS.COLLECTION.REPORT}99`]: makeReport('99', 1_000)};
+        const seededCurrent = {
+            reportsToDisplay: {[`${ONYXKEYS.COLLECTION.REPORT}99`]: reports[`${ONYXKEYS.COLLECTION.REPORT}99`]},
+            orderedReportIDs: ['99'],
+        };
+        const updateSpy = jest.spyOn(SidebarUtils, 'updateReportsToDisplayInLHN');
+
+        sidebarOrderedReportsConfig.compute(buildArgs(reports), {
+            currentValue: seededCurrent,
+            sourceValues: {[ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS]: {[`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}99`]: {}}},
+        });
+
+        expect(updateSpy).toHaveBeenCalledTimes(1);
+        const callArgs = updateSpy.mock.calls.at(0)?.at(0);
+        expect(callArgs?.updatedReportsKeys).toEqual([`${ONYXKEYS.COLLECTION.REPORT}99`]);
+    });
+
+    it('translates REPORT_DRAFT_COMMENT source keys to REPORT keys in the incremental path', () => {
+        const reports: Record<string, Report> = {[`${ONYXKEYS.COLLECTION.REPORT}42`]: makeReport('42', 1_000)};
+        const seededCurrent = {
+            reportsToDisplay: {[`${ONYXKEYS.COLLECTION.REPORT}42`]: reports[`${ONYXKEYS.COLLECTION.REPORT}42`]},
+            orderedReportIDs: ['42'],
+        };
+        const updateSpy = jest.spyOn(SidebarUtils, 'updateReportsToDisplayInLHN');
+
+        sidebarOrderedReportsConfig.compute(buildArgs(reports), {
+            currentValue: seededCurrent,
+            sourceValues: {[ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT]: {[`${ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT}42`]: 'draft'}},
+        });
+
+        const callArgs = updateSpy.mock.calls.at(0)?.at(0);
+        expect(callArgs?.updatedReportsKeys).toEqual([`${ONYXKEYS.COLLECTION.REPORT}42`]);
+    });
+
+    it('cascades a POLICY change to every report under that policy', () => {
+        const policyID = 'POL1';
+        const reports: Record<string, Report> = {
+            [`${ONYXKEYS.COLLECTION.REPORT}a`]: makeReport('a', 1_000, {policyID}),
+            [`${ONYXKEYS.COLLECTION.REPORT}b`]: makeReport('b', 2_000, {policyID}),
+            [`${ONYXKEYS.COLLECTION.REPORT}c`]: makeReport('c', 3_000, {policyID: 'OTHER'}),
+        };
+        const seededCurrent = {
+            reportsToDisplay: {
+                [`${ONYXKEYS.COLLECTION.REPORT}a`]: reports[`${ONYXKEYS.COLLECTION.REPORT}a`],
+                [`${ONYXKEYS.COLLECTION.REPORT}b`]: reports[`${ONYXKEYS.COLLECTION.REPORT}b`],
+                [`${ONYXKEYS.COLLECTION.REPORT}c`]: reports[`${ONYXKEYS.COLLECTION.REPORT}c`],
+            },
+            orderedReportIDs: ['a', 'b', 'c'],
+        };
+        const updateSpy = jest.spyOn(SidebarUtils, 'updateReportsToDisplayInLHN');
+
+        sidebarOrderedReportsConfig.compute(buildArgs(reports), {
+            currentValue: seededCurrent,
+            sourceValues: {[ONYXKEYS.COLLECTION.POLICY]: {[`${ONYXKEYS.COLLECTION.POLICY}${policyID}`]: {}}} as never,
+        });
+
+        const callArgs = updateSpy.mock.calls.at(0)?.at(0);
+        const keys = (callArgs?.updatedReportsKeys ?? []).slice().sort();
+        expect(keys).toEqual([`${ONYXKEYS.COLLECTION.REPORT}a`, `${ONYXKEYS.COLLECTION.REPORT}b`]);
+    });
+
+    it('takes the incremental path on a REPORT_ATTRIBUTES change, re-evaluating only the reports whose attributes changed', () => {
+        const reportKey = `${ONYXKEYS.COLLECTION.REPORT}1`;
+        const otherKey = `${ONYXKEYS.COLLECTION.REPORT}2`;
+        const reports: Record<string, Report> = {[reportKey]: makeReport('1', 1_000), [otherKey]: makeReport('2', 2_000)};
+        // Both reports require attention so they qualify for the LHN and the seeded cache is non-empty.
+        const seededAttributes = makeAttributes([
+            ['1', true],
+            ['2', true],
+        ]);
+
+        // The seeding compute populates the module-level attributes snapshot that the next compute diffs against.
+        const seeded = sidebarOrderedReportsConfig.compute(buildArgs(reports, {reportAttributes: seededAttributes}), EMPTY_CONTEXT);
+
+        // Only report 1's attributes entry gets a new reference; report 2 keeps its reference from the snapshot.
+        const updatedReports: ReportAttributesDerivedValue['reports'] = {...seededAttributes.reports};
+        updatedReports['1'] = {...seededAttributes.reports['1']};
+        const updatedAttributes: ReportAttributesDerivedValue = {reports: updatedReports, locale: 'en'};
+        const getSpy = jest.spyOn(SidebarUtils, 'getReportsToDisplayInLHN');
+        const updateSpy = jest.spyOn(SidebarUtils, 'updateReportsToDisplayInLHN');
+
+        sidebarOrderedReportsConfig.compute(buildArgs(reports, {reportAttributes: updatedAttributes}), {
+            currentValue: seeded,
+            sourceValues: {[ONYXKEYS.DERIVED.REPORT_ATTRIBUTES]: updatedAttributes} as never,
+        });
+
+        expect(getSpy).not.toHaveBeenCalled();
+        expect(updateSpy).toHaveBeenCalledTimes(1);
+        expect(updateSpy.mock.calls.at(0)?.at(0)?.updatedReportsKeys).toEqual([reportKey]);
+    });
+
+    it('adds a currently-hidden report to the displayed set when its attributes flip to requiresAttention', () => {
+        // Focus mode hides read reports without attention, so report 7 only surfaces once it requires attention.
+        // Report 1 always requires attention, so the cached displayed set is non-empty and the incremental path runs.
+        const hiddenKey = `${ONYXKEYS.COLLECTION.REPORT}7`;
+        const shownKey = `${ONYXKEYS.COLLECTION.REPORT}1`;
+        const reports: Record<string, Report> = {[hiddenKey]: makeReport('7', 1_000), [shownKey]: makeReport('1', 2_000)};
+        const focusMode = {priorityMode: CONST.PRIORITY_MODE.GSD as PriorityMode};
+
+        const seeded = sidebarOrderedReportsConfig.compute(
+            buildArgs(reports, {
+                ...focusMode,
+                reportAttributes: makeAttributes([
+                    ['1', true],
+                    ['7', false],
+                ]),
+            }),
+            EMPTY_CONTEXT,
+        );
+        expect(seeded.reportsToDisplay[shownKey]).toBeDefined();
+        expect(seeded.reportsToDisplay[hiddenKey]).toBeUndefined();
+
+        const updatedAttributes = makeAttributes([
+            ['1', true],
+            ['7', true],
+        ]);
+        const result = sidebarOrderedReportsConfig.compute(buildArgs(reports, {...focusMode, reportAttributes: updatedAttributes}), {
+            currentValue: seeded,
+            sourceValues: {[ONYXKEYS.DERIVED.REPORT_ATTRIBUTES]: updatedAttributes} as never,
+        });
+
+        expect(result.reportsToDisplay[hiddenKey]).toBeDefined();
+    });
+
+    it('falls back to the full path on an attributes trigger when there is no previous snapshot', () => {
+        // The empty-reports path resets the module-level attributes snapshot to undefined.
+        sidebarOrderedReportsConfig.compute(buildArgs({}), EMPTY_CONTEXT);
+
+        const reportKey = `${ONYXKEYS.COLLECTION.REPORT}1`;
+        const reports: Record<string, Report> = {[reportKey]: makeReport('1', 1_000)};
+        const attributes = makeAttributes([['1', false]]);
+        const seededCurrent = {reportsToDisplay: {[reportKey]: reports[reportKey]}, orderedReportIDs: ['1']};
+
+        const getSpy = jest.spyOn(SidebarUtils, 'getReportsToDisplayInLHN');
+        const updateSpy = jest.spyOn(SidebarUtils, 'updateReportsToDisplayInLHN');
+
+        sidebarOrderedReportsConfig.compute(buildArgs(reports, {reportAttributes: attributes}), {
+            currentValue: seededCurrent,
+            sourceValues: {[ONYXKEYS.DERIVED.REPORT_ATTRIBUTES]: attributes} as never,
+        });
+
+        expect(getSpy).toHaveBeenCalledTimes(1);
+        expect(updateSpy).not.toHaveBeenCalled();
+    });
+});
diff --git a/tests/unit/SidebarUtilsTest.ts b/tests/unit/SidebarUtilsTest.ts
index 058c41917496..c8fad8ca88ae 100644
--- a/tests/unit/SidebarUtilsTest.ts
+++ b/tests/unit/SidebarUtilsTest.ts
@@ -3867,6 +3867,42 @@ describe('SidebarUtils', () => {
                 expect(result).not.toBe(displayedReports);
                 expect(result['0']).toBeUndefined();
             });
+
+            it('includes a report that is otherwise hidden only when it is the focused report', () => {
+                // A report with no participants is hidden for the current user. With no pin/draft/error/attention,
+                // the only thing that can surface it is the focus override (currentReportId === reportID).
+                const reportKey = `${ONYXKEYS.COLLECTION.REPORT}7`;
+                const report: Report = {
+                    ...createRandomReport(7, undefined),
+                    reportID: '7',
+                    type: CONST.REPORT.TYPE.CHAT,
+                    isPinned: false,
+                    isOwnPolicyExpenseChat: false,
+                };
+                const reports: OnyxCollection<Report> = {[reportKey]: report};
+
+                const baseParams = {
+                    displayedReports: {},
+                    reports,
+                    updatedReportsKeys: [reportKey],
+                    isInFocusMode: false,
+                    betas: [],
+                    transactions: {},
+                    transactionViolations: {},
+                    reportNameValuePairs: {},
+                    reportAttributes: undefined,
+                    draftComments: {},
+                    isOffline: false,
+                    currentUserLogin: CURRENT_USER_LOGIN,
+                    currentUserAccountID: CURRENT_USER_ACCOUNT_ID,
+                };
+
+                const resultWithoutFocus = SidebarUtils.updateReportsToDisplayInLHN({...baseParams, currentReportId: undefined});
+                expect(resultWithoutFocus[reportKey]).toBeUndefined();
+
+                const resultWithFocus = SidebarUtils.updateReportsToDisplayInLHN({...baseParams, currentReportId: '7'});
+                expect(resultWithFocus[reportKey]).toBeDefined();
+            });
         });
 
         describe('getReportsToDisplayInLHN', () => {
diff --git a/tests/unit/useSidebarOrderedReportsTest.tsx b/tests/unit/useSidebarOrderedReportsTest.tsx
index 442bd868d9d9..be464c5804ef 100644
--- a/tests/unit/useSidebarOrderedReportsTest.tsx
+++ b/tests/unit/useSidebarOrderedReportsTest.tsx
@@ -11,11 +11,10 @@ import ONYXKEYS from '@src/ONYXKEYS';
 import type {Report} from '@src/types/onyx';
 import waitForBatchedUpdatesWithAct from '../utils/waitForBatchedUpdatesWithAct';
 
-// Mock dependencies
 jest.mock('@libs/SidebarUtils', () => ({
-    sortReportsToDisplayInLHN: jest.fn(),
-    getReportsToDisplayInLHN: jest.fn(),
-    updateReportsToDisplayInLHN: jest.fn(),
+    sortReportsToDisplayInLHN: jest.fn(() => []),
+    getReportsToDisplayInLHN: jest.fn(() => ({})),
+    updateReportsToDisplayInLHN: jest.fn(({displayedReports}: {displayedReports: unknown}) => displayedReports),
 }));
 jest.mock('@libs/Navigation/Navigation', () => ({
     getActiveRouteWithoutParams: jest.fn(() => ''),
@@ -29,10 +28,19 @@ jest.mock('@libs/ReportUtils', () => ({
 
 const mockSidebarUtils = SidebarUtils as jest.Mocked<typeof SidebarUtils>;
 
+function makeReport(id: string, overrides: Partial<Report> = {}): Report {
+    return {
+        reportID: id,
+        reportName: `Report ${id}`,
+        lastVisibleActionCreated: '2024-01-01 10:00:00',
+        type: CONST.REPORT.TYPE.CHAT,
+        ...overrides,
+    } as Report;
+}
+
 describe('useSidebarOrderedReports', () => {
     beforeAll(async () => {
         Onyx.init({keys: ONYXKEYS});
-        // Set up basic session data
         await act(async () => {
             await Onyx.set(ONYXKEYS.SESSION, {
                 accountID: 12345,
@@ -45,18 +53,14 @@ describe('useSidebarOrderedReports', () => {
 
     beforeEach(async () => {
         jest.clearAllMocks();
+        mockSidebarUtils.sortReportsToDisplayInLHN.mockReturnValue([]);
+        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue({});
+        mockSidebarUtils.updateReportsToDisplayInLHN.mockImplementation(({displayedReports}) => displayedReports);
+
         await act(async () => {
             await Onyx.clear();
-
-            // Set up basic session data for each test
-            await Onyx.set(ONYXKEYS.SESSION, {
-                accountID: 12345,
-                email: 'test@example.com',
-                authTokenType: CONST.AUTH_TOKEN_TYPES.ANONYMOUS,
-            });
-
-            // Set up required Onyx data that the hook depends on
             await Onyx.multiSet({
+                [ONYXKEYS.SESSION]: {accountID: 12345, email: 'test@example.com', authTokenType: CONST.AUTH_TOKEN_TYPES.ANONYMOUS},
                 [ONYXKEYS.NVP_PRIORITY_MODE]: CONST.PRIORITY_MODE.DEFAULT,
                 [ONYXKEYS.COLLECTION.REPORT]: {},
                 [ONYXKEYS.COLLECTION.POLICY]: {},
@@ -66,16 +70,9 @@ describe('useSidebarOrderedReports', () => {
                 [ONYXKEYS.COLLECTION.REPORT_DRAFT_COMMENT]: {},
                 [ONYXKEYS.BETAS]: [],
                 [ONYXKEYS.DERIVED.REPORT_ATTRIBUTES]: {reports: {}},
+                [ONYXKEYS.DERIVED.RAM_ONLY_SIDEBAR_ORDERED_REPORTS]: {reportsToDisplay: {}, orderedReportIDs: []},
             } as unknown as OnyxMultiSetInput);
         });
-
-        await waitForBatchedUpdatesWithAct();
-
-        // Default mock implementations
-        mockSidebarUtils.getReportsToDisplayInLHN.mockImplementation(() => ({}));
-        mockSidebarUtils.updateReportsToDisplayInLHN.mockImplementation(({displayedReports}) => displayedReports);
-        mockSidebarUtils.sortReportsToDisplayInLHN.mockReturnValue([]);
-
         await waitForBatchedUpdatesWithAct();
     });
 
@@ -86,227 +83,83 @@ describe('useSidebarOrderedReports', () => {
         await waitForBatchedUpdatesWithAct();
     });
 
-    const createMockReports = (reports: Record<string, Partial<Report>>) => {
-        const mockReports: Record<string, Report> = {};
-        for (const [key, report] of Object.entries(reports)) {
-            const reportId = key.replace('report', '');
-            mockReports[reportId] = {
-                reportID: reportId,
-                reportName: `Report ${reportId}`,
-                lastVisibleActionCreated: '2024-01-01 10:00:00',
-                type: CONST.REPORT.TYPE.CHAT,
-                ...report,
-            } as Report;
-        }
-        return mockReports;
-    };
-
-    let currentReportIDForTestsValue: string | undefined;
+    let currentReportIDForTest: string | undefined;
 
     function TestWrapper({children}: {children: React.ReactNode}) {
         return (
             <OnyxListItemProvider>
                 <CurrentReportIDContextProvider>
-                    <SidebarOrderedReportsContextProvider currentReportIDForTests={currentReportIDForTestsValue}>{children}</SidebarOrderedReportsContextProvider>
+                    <SidebarOrderedReportsContextProvider currentReportIDForTests={currentReportIDForTest}>{children}</SidebarOrderedReportsContextProvider>
                 </CurrentReportIDContextProvider>
             </OnyxListItemProvider>
         );
     }
 
-    it('should prevent unnecessary re-renders when reports have same content but different references', async () => {
-        // Given reports with same content but different object references
-        const reportsContent = {
-            report1: {reportName: 'Chat 1', lastVisibleActionCreated: '2024-01-01 10:00:00'},
-            report2: {reportName: 'Chat 2', lastVisibleActionCreated: '2024-01-01 11:00:00'},
-        };
-
-        // When the initial reports are set
-        const initialReports = createMockReports(reportsContent);
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue(initialReports);
-        mockSidebarUtils.updateReportsToDisplayInLHN.mockImplementation(({displayedReports}) => displayedReports);
-        currentReportIDForTestsValue = '1';
-
-        // When the hook is rendered
-        const {rerender} = renderHook(() => useSidebarOrderedReports(), {
-            wrapper: TestWrapper,
-        });
-
-        await waitForBatchedUpdatesWithAct();
-
-        // Then the mock calls are cleared
-        mockSidebarUtils.sortReportsToDisplayInLHN.mockClear();
-
-        // When the reports are updated
-        const newReportsWithSameContent = createMockReports(reportsContent);
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue(newReportsWithSameContent);
-
-        rerender({});
-
-        await waitForBatchedUpdatesWithAct();
-
-        // Then sortReportsToDisplayInLHN should not be called again since deep comparison shows no change
-        expect(mockSidebarUtils.sortReportsToDisplayInLHN).not.toHaveBeenCalled();
-    });
-
-    it('should trigger re-render when reports content actually changes', async () => {
-        // Given the initial reports are set
-        const initialReports = createMockReports({
-            report1: {reportName: 'Chat 1'},
-            report2: {reportName: 'Chat 2'},
-        });
-
-        // When the reports are updated
-        const updatedReports = createMockReports({
-            report1: {reportName: 'Chat 1 Updated'}, // Content changed
-            report2: {reportName: 'Chat 2'},
-            report3: {reportName: 'Chat 3'}, // New report added
-        });
-
-        // Then the initial reports are set
+    it('surfaces orderedReportIDs from the derived Onyx value', async () => {
+        currentReportIDForTest = '1';
+        const report1 = makeReport('1');
+        const report2 = makeReport('2');
         await act(async () => {
             await Onyx.multiSet({
-                [`${ONYXKEYS.COLLECTION.REPORT}1`]: initialReports['1'],
-                [`${ONYXKEYS.COLLECTION.REPORT}2`]: initialReports['2'],
+                [`${ONYXKEYS.COLLECTION.REPORT}1`]: report1,
+                [`${ONYXKEYS.COLLECTION.REPORT}2`]: report2,
+                [ONYXKEYS.DERIVED.RAM_ONLY_SIDEBAR_ORDERED_REPORTS]: {
+                    reportsToDisplay: {[`${ONYXKEYS.COLLECTION.REPORT}1`]: report1, [`${ONYXKEYS.COLLECTION.REPORT}2`]: report2},
+                    orderedReportIDs: ['2', '1'],
+                },
             } as unknown as OnyxMultiSetInput);
         });
-
         await waitForBatchedUpdatesWithAct();
 
-        // When the mock is updated
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue(initialReports);
-
-        // When the hook is rendered
-        const {rerender} = renderHook(() => useSidebarOrderedReports(), {
-            wrapper: TestWrapper,
-        });
-
+        const {result} = renderHook(() => useSidebarOrderedReports(), {wrapper: TestWrapper});
         await waitForBatchedUpdatesWithAct();
 
-        // Then the mock calls are cleared
-        mockSidebarUtils.sortReportsToDisplayInLHN.mockClear();
-
-        // When the mocks are updated to reflect the new content
-        // getReportsToDisplayInLHN covers the full-scan path; updateReportsToDisplayInLHN covers
-        // the incremental path (taken when priority mode changes and the cache is already populated).
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue(updatedReports);
-        mockSidebarUtils.updateReportsToDisplayInLHN.mockReturnValue(updatedReports);
-
-        // When the priority mode is changed
-        await act(async () => {
-            await Onyx.set(ONYXKEYS.NVP_PRIORITY_MODE, CONST.PRIORITY_MODE.GSD);
-        });
-
-        rerender({});
-
-        await waitForBatchedUpdatesWithAct();
-
-        // Then sortReportsToDisplayInLHN should be called with the updated reports
-        expect(mockSidebarUtils.sortReportsToDisplayInLHN).toHaveBeenCalledWith(
-            updatedReports,
-            expect.any(String), // priorityMode
-            expect.any(Function), // localeCompare
-            expect.any(Object), // reportsDrafts
-            expect.any(Object), // reportNameValuePairs
-            expect.anything(), // reportAttributes
-        );
+        expect(result.current.orderedReportIDs).toEqual(['2', '1']);
+        expect(result.current.currentReportID).toBe('1');
     });
 
-    it('should handle empty reports correctly with deep comparison', async () => {
-        // Given the initial reports are set
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue({});
-
-        // When the hook is rendered
-        const {rerender} = renderHook(() => useSidebarOrderedReports(), {
-            wrapper: TestWrapper,
+    it('does not call SidebarUtils when the current report is already in the derived list', async () => {
+        currentReportIDForTest = '1';
+        const report1 = makeReport('1');
+        await act(async () => {
+            await Onyx.multiSet({
+                [`${ONYXKEYS.COLLECTION.REPORT}1`]: report1,
+                [ONYXKEYS.DERIVED.RAM_ONLY_SIDEBAR_ORDERED_REPORTS]: {
+                    reportsToDisplay: {[`${ONYXKEYS.COLLECTION.REPORT}1`]: report1},
+                    orderedReportIDs: ['1'],
+                },
+            } as unknown as OnyxMultiSetInput);
         });
-
         await waitForBatchedUpdatesWithAct();
 
-        // Then the mock calls are cleared
-        mockSidebarUtils.sortReportsToDisplayInLHN.mockClear();
-
-        // When the mock is updated
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue({});
-
-        rerender({});
-
+        renderHook(() => useSidebarOrderedReports(), {wrapper: TestWrapper});
         await waitForBatchedUpdatesWithAct();
 
-        // Then sortReportsToDisplayInLHN should not be called again since reports are empty
+        expect(mockSidebarUtils.updateReportsToDisplayInLHN).not.toHaveBeenCalled();
         expect(mockSidebarUtils.sortReportsToDisplayInLHN).not.toHaveBeenCalled();
     });
 
-    it('should maintain referential stability across multiple renders with same content', async () => {
-        // Given the initial reports are set
-        const reportsContent = {
-            report1: {reportName: 'Stable Chat'},
-        };
-
-        // When the initial reports are set
-        const initialReports = createMockReports(reportsContent);
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue(initialReports);
-        mockSidebarUtils.sortReportsToDisplayInLHN.mockReturnValue(['1']);
-        currentReportIDForTestsValue = '1';
-
-        const {rerender} = renderHook(() => useSidebarOrderedReports(), {
-            wrapper: TestWrapper,
-        });
-
-        await waitForBatchedUpdatesWithAct();
-
-        // When the mock is updated
-        const newReportsWithSameContent = createMockReports(reportsContent);
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue(newReportsWithSameContent);
-
-        rerender({});
-        await waitForBatchedUpdatesWithAct();
-        currentReportIDForTestsValue = '2';
-
-        // When the mock is updated
-        const thirdReportsWithSameContent = createMockReports(reportsContent);
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue(thirdReportsWithSameContent);
-
-        rerender({});
-        await waitForBatchedUpdatesWithAct();
-        currentReportIDForTestsValue = '3';
-
-        // Then sortReportsToDisplayInLHN should be called only once (initial render)
-        expect(mockSidebarUtils.sortReportsToDisplayInLHN).toHaveBeenCalledTimes(1);
-    });
-
-    it('should handle priority mode changes correctly with deep comparison', async () => {
-        // Given the initial reports are set
-        const reports = createMockReports({
-            report1: {reportName: 'Chat A'},
-            report2: {reportName: 'Chat B'},
-        });
-
-        mockSidebarUtils.getReportsToDisplayInLHN.mockReturnValue(reports);
-        currentReportIDForTestsValue = '1';
-
-        // When the hook is rendered
-        const {rerender} = renderHook(() => useSidebarOrderedReports(), {
-            wrapper: TestWrapper,
-        });
-
-        await waitForBatchedUpdatesWithAct();
-
-        // Then the mock calls are cleared
-        mockSidebarUtils.sortReportsToDisplayInLHN.mockClear();
-        currentReportIDForTestsValue = '2';
-
-        // When the priority mode is changed
+    it('injects the current report via updateReportsToDisplayInLHN when missing from the derived list', async () => {
+        currentReportIDForTest = '2';
         await act(async () => {
-            await Onyx.set(ONYXKEYS.NVP_PRIORITY_MODE, CONST.PRIORITY_MODE.GSD);
+            await Onyx.multiSet({
+                [ONYXKEYS.DERIVED.RAM_ONLY_SIDEBAR_ORDERED_REPORTS]: {reportsToDisplay: {}, orderedReportIDs: []},
+            } as unknown as OnyxMultiSetInput);
         });
-
         await waitForBatchedUpdatesWithAct();
 
-        rerender({});
+        mockSidebarUtils.sortReportsToDisplayInLHN.mockReturnValue(['2']);
 
+        const {result} = renderHook(() => useSidebarOrderedReports(), {wrapper: TestWrapper});
         await waitForBatchedUpdatesWithAct();
 
-        // Then sortReportsToDisplayInLHN should be called when priority mode changes
+        expect(mockSidebarUtils.updateReportsToDisplayInLHN).toHaveBeenCalledWith(
+            expect.objectContaining({
+                currentReportId: '2',
+                updatedReportsKeys: [`${ONYXKEYS.COLLECTION.REPORT}2`],
+            }),
+        );
         expect(mockSidebarUtils.sortReportsToDisplayInLHN).toHaveBeenCalled();
+        expect(result.current.orderedReportIDs).toEqual(['2']);
     });
 });