diff --git a/src/CONST/index.ts b/src/CONST/index.ts
index 05f2b0fed3be..c59532aed02d 100644
--- a/src/CONST/index.ts
+++ b/src/CONST/index.ts
@@ -3703,8 +3703,11 @@ const CONST = {
         SUCCESS: 'success',
         ERROR: 'error',
         WARNING: 'warning',
+        LOADING: 'loading',
         DURATION: 2000,
         DURATION_LONG: 3500,
+        // Longer duration for growls with an actionable button (e.g. "View"), giving the user enough time to tap it.
+        DURATION_WITH_ACTION: 6000,
     },
 
     LOCALES,
diff --git a/src/ONYXKEYS.ts b/src/ONYXKEYS.ts
index 37ab59480ea1..e127f5b09b47 100755
--- a/src/ONYXKEYS.ts
+++ b/src/ONYXKEYS.ts
@@ -761,9 +761,6 @@ const ONYXKEYS = {
     /** Whether the user has denied the contact import permission prompt */
     HAS_DENIED_CONTACT_IMPORT_PROMPT: 'hasDeniedContactImportPrompt',
 
-    /** The transaction IDs to be highlighted when opening the Expenses search route page */
-    TRANSACTION_IDS_HIGHLIGHT_ON_SEARCH_ROUTE: 'transactionIdsHighlightOnSearchRoute',
-
     /** The report ID to be highlighted when returning to the workspace rooms page */
     ROOM_ID_HIGHLIGHT_ON_ROOMS_PAGE: 'roomIDHighlightOnRoomsPage',
 
@@ -1669,7 +1666,6 @@ type OnyxValuesMapping = {
     [ONYXKEYS.NVP_REPORT_DETAILS_COLUMNS]: string[];
     [ONYXKEYS.HAS_DENIED_CONTACT_IMPORT_PROMPT]: boolean | undefined;
     [ONYXKEYS.PERSONAL_POLICY_ID]: string;
-    [ONYXKEYS.TRANSACTION_IDS_HIGHLIGHT_ON_SEARCH_ROUTE]: Record<string, Record<string, boolean>>;
     [ONYXKEYS.ROOM_ID_HIGHLIGHT_ON_ROOMS_PAGE]: string | null;
     [ONYXKEYS.DOMAIN_GROUP_CREATE_PREFERRED_POLICY_ID]: string | undefined;
 };
diff --git a/src/components/GrowlNotification/GrowlNotificationContainer/index.native.tsx b/src/components/GrowlNotification/GrowlNotificationContainer/index.native.tsx
index 44dea7d7784c..eaeeb85a3964 100644
--- a/src/components/GrowlNotification/GrowlNotificationContainer/index.native.tsx
+++ b/src/components/GrowlNotification/GrowlNotificationContainer/index.native.tsx
@@ -5,11 +5,11 @@ import useStyleUtils from '@hooks/useStyleUtils';
 import useThemeStyles from '@hooks/useThemeStyles';
 import type GrowlNotificationContainerProps from './types';
 
-function GrowlNotificationContainer({children, translateY}: GrowlNotificationContainerProps) {
+function GrowlNotificationContainer({children, progress, inactiveY}: GrowlNotificationContainerProps) {
     const styles = useThemeStyles();
     const StyleUtils = useStyleUtils();
     const insets = useSafeAreaInsets();
-    const animatedStyles = useAnimatedStyle(() => styles.growlNotificationTranslateY(translateY));
+    const animatedStyles = useAnimatedStyle(() => ({transform: [{translateY: inactiveY * (1 - progress.get())}]}), [inactiveY]);
 
     return <Animated.View style={[StyleUtils.getPlatformSafeAreaPadding(insets), styles.growlNotificationContainer, animatedStyles]}>{children}</Animated.View>;
 }
diff --git a/src/components/GrowlNotification/GrowlNotificationContainer/index.tsx b/src/components/GrowlNotification/GrowlNotificationContainer/index.tsx
index a3d2e6379ea6..4bf10ca2cdad 100644
--- a/src/components/GrowlNotification/GrowlNotificationContainer/index.tsx
+++ b/src/components/GrowlNotification/GrowlNotificationContainer/index.tsx
@@ -4,10 +4,14 @@ import useResponsiveLayout from '@hooks/useResponsiveLayout';
 import useThemeStyles from '@hooks/useThemeStyles';
 import type GrowlNotificationContainerProps from './types';
 
-function GrowlNotificationContainer({children, translateY}: GrowlNotificationContainerProps) {
+function GrowlNotificationContainer({children, progress, inactiveY, useBottomPosition}: GrowlNotificationContainerProps) {
     const styles = useThemeStyles();
     const {shouldUseNarrowLayout} = useResponsiveLayout();
-    const animatedStyles = useAnimatedStyle(() => styles.growlNotificationTranslateY(translateY));
+    const animatedStyles = useAnimatedStyle(() => ({transform: [{translateY: inactiveY * (1 - progress.get())}]}), [inactiveY]);
+
+    if (useBottomPosition) {
+        return <Animated.View style={[styles.growlNotificationContainerBottomRight, animatedStyles]}>{children}</Animated.View>;
+    }
 
     return (
         <Animated.View style={[styles.growlNotificationContainer, styles.growlNotificationDesktopContainer, animatedStyles, shouldUseNarrowLayout && styles.mwn]}>{children}</Animated.View>
diff --git a/src/components/GrowlNotification/GrowlNotificationContainer/types.ts b/src/components/GrowlNotification/GrowlNotificationContainer/types.ts
index 5f137f6d3c48..bd935c9bc279 100644
--- a/src/components/GrowlNotification/GrowlNotificationContainer/types.ts
+++ b/src/components/GrowlNotification/GrowlNotificationContainer/types.ts
@@ -2,7 +2,14 @@ import type {SharedValue} from 'react-native-reanimated';
 import type ChildrenProps from '@src/types/utils/ChildrenProps';
 
 type GrowlNotificationContainerProps = ChildrenProps & {
-    translateY: SharedValue<number>;
+    /** Normalized visibility (0 = fully offscreen, 1 = fully visible). Translated to a pixel offset at render time. */
+    progress: SharedValue<number>;
+
+    /** Pixel offset that corresponds to the current "offscreen" position for the active anchor. */
+    inactiveY: number;
+
+    /** When true, position the growl at the bottom-right (wide screens with an action button). */
+    useBottomPosition?: boolean;
 };
 
 export default GrowlNotificationContainerProps;
diff --git a/src/components/GrowlNotification/GrowlNotificationContent.tsx b/src/components/GrowlNotification/GrowlNotificationContent.tsx
new file mode 100644
index 000000000000..fdfb7fdc59ee
--- /dev/null
+++ b/src/components/GrowlNotification/GrowlNotificationContent.tsx
@@ -0,0 +1,215 @@
+import React, {useCallback, useEffect, useMemo, useRef, useState} from 'react';
+import {View} from 'react-native';
+import {Directions, Gesture, GestureDetector} from 'react-native-gesture-handler';
+import {useSharedValue, withSpring} from 'react-native-reanimated';
+import type {SvgProps} from 'react-native-svg';
+import ActivityIndicator from '@components/ActivityIndicator';
+import Button from '@components/Button';
+import Icon from '@components/Icon';
+import * as Pressables from '@components/Pressable';
+import Text from '@components/Text';
+import {useMemoizedLazyExpensifyIcons} from '@hooks/useLazyAsset';
+import useResponsiveLayout from '@hooks/useResponsiveLayout';
+import useTheme from '@hooks/useTheme';
+import useThemeStyles from '@hooks/useThemeStyles';
+import type {GrowlAction, GrowlType} from '@libs/Growl';
+import CONST from '@src/CONST';
+import type IconAsset from '@src/types/utils/IconAsset';
+import GrowlNotificationContainer from './GrowlNotificationContainer';
+
+const INACTIVE_OFFSET = 255;
+const INACTIVE_POSITION_Y = -INACTIVE_OFFSET;
+// Approximate time for the slide spring to settle. Used to delay onDismissed
+// until the slide-out animation has visibly finished.
+const SLIDE_DURATION_MS = 400;
+
+const PressableWithoutFeedback = Pressables.PressableWithoutFeedback;
+
+type GrowlNotificationContentProps = {
+    bodyText: string;
+    type: GrowlType;
+    duration: number;
+    action?: GrowlAction;
+    onDismissed: () => void;
+};
+
+function GrowlNotificationContent({bodyText, type, duration, action, onDismissed}: GrowlNotificationContentProps) {
+    // Normalized: 0 = fully offscreen for the current anchor, 1 = fully visible. The container
+    // multiplies this against the live `inactiveY`, so the offscreen position stays correct
+    // even when the responsive layout flips after the growl is dismissed.
+    const progress = useSharedValue(0);
+    // Guards against double-firing the action's onPress while the slide-out animation
+    // is still on screen. Reset whenever new growl content arrives.
+    const isActionPressedRef = useRef(false);
+    // Holds the post-fling-out setTimeout so the content-change effect can cancel a
+    // pending unmount when a new growl arrives mid-dismissal. Only touched inside effects.
+    const dismissTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+    // Counter that triggers the dismiss-after-slide-out effect. Kept in state (rather than
+    // a ref) so triggerDismiss doesn't transitively read a ref — that would make the React
+    // Compiler reject the gesture's useMemo as "ref access during render".
+    const [dismissNonce, setDismissNonce] = useState(0);
+
+    const theme = useTheme();
+    const styles = useThemeStyles();
+    const {shouldUseNarrowLayout} = useResponsiveLayout();
+    const icons = useMemoizedLazyExpensifyIcons(['Exclamation', 'Checkmark']);
+
+    // Derived live so that resizing the window flips position + slide direction during display.
+    const useBottomPosition = !!action && !shouldUseNarrowLayout;
+    const inactiveY = useBottomPosition ? INACTIVE_OFFSET : INACTIVE_POSITION_Y;
+
+    // Every non-loading growl variant must have an icon mapping. Loading is rendered separately
+    // (ActivityIndicator), so it's excluded here — keeping this map exhaustive over the rest.
+    type GrowlIconTypes = Record<
+        Exclude<GrowlType, typeof CONST.GROWL.LOADING>,
+        {
+            icon: React.FC<SvgProps> | IconAsset;
+            iconColor: string;
+        }
+    >;
+
+    const types: GrowlIconTypes = {
+        [CONST.GROWL.SUCCESS]: {
+            icon: icons.Checkmark,
+            iconColor: theme.success,
+        },
+        [CONST.GROWL.ERROR]: {
+            icon: icons.Exclamation,
+            iconColor: theme.danger,
+        },
+        [CONST.GROWL.WARNING]: {
+            icon: icons.Exclamation,
+            iconColor: theme.warning,
+        },
+    };
+
+    /**
+     * Animate growl notification. `targetProgress` is 0 for offscreen, 1 for visible.
+     */
+    const fling = useCallback(
+        (targetProgress = 0) => {
+            'worklet';
+
+            progress.set(
+                withSpring(targetProgress, {
+                    overshootClamping: false,
+                }),
+            );
+        },
+        [progress],
+    );
+
+    /**
+     * Slide the growl off-screen and schedule its unmount via the dismissNonce effect.
+     */
+    const triggerDismiss = useCallback(() => {
+        fling(0);
+        setDismissNonce((n) => n + 1);
+    }, [fling]);
+
+    // Schedule unmount once a dismiss has been requested. Effect cleanup cancels the timer
+    // when this effect re-runs or the component unmounts.
+    useEffect(() => {
+        if (dismissNonce === 0) {
+            return;
+        }
+        const timeoutId = setTimeout(onDismissed, SLIDE_DURATION_MS);
+        dismissTimeoutRef.current = timeoutId;
+        return () => {
+            clearTimeout(timeoutId);
+            dismissTimeoutRef.current = null;
+        };
+    }, [dismissNonce, onDismissed]);
+
+    useEffect(() => {
+        isActionPressedRef.current = false;
+        // New content arrived — cancel any in-flight unmount-after-slide-out from the previous
+        // growl. (We can't reset dismissNonce here because setState in an effect body is
+        // disallowed by lint; clearing the timer directly via the ref achieves the same result.)
+        if (dismissTimeoutRef.current) {
+            clearTimeout(dismissTimeoutRef.current);
+            dismissTimeoutRef.current = null;
+        }
+
+        // Snap to fully offscreen before sliding in so the slide-in direction matches the
+        // current placement (from above for top, from below for bottom).
+        progress.set(0);
+        fling(1);
+
+        if (duration <= 0) {
+            // Indefinite (loading) growl - slide in but don't auto-dismiss.
+            return;
+        }
+
+        const autoDismissTimeoutId = setTimeout(triggerDismiss, duration);
+        return () => clearTimeout(autoDismissTimeoutId);
+    }, [bodyText, type, action, duration, fling, progress, triggerDismiss]);
+
+    // GestureDetector by default runs callbacks on UI thread using Reanimated. In this
+    // case we want to trigger an RN's Animated animation, which needs to be done on JS thread.
+    // Wrapped in useMemo so the React Compiler doesn't flag the gesture builder's internal
+    // mutable state as ref access during render.
+    const flingGesture = useMemo(
+        () =>
+            Gesture.Fling()
+                .direction(useBottomPosition ? Directions.DOWN : Directions.UP)
+                .runOnJS(true)
+                .onStart(() => {
+                    triggerDismiss();
+                }),
+        [useBottomPosition, triggerDismiss],
+    );
+
+    return (
+        <View style={[styles.growlNotificationWrapper]}>
+            <GrowlNotificationContainer
+                progress={progress}
+                inactiveY={inactiveY}
+                useBottomPosition={useBottomPosition}
+            >
+                <PressableWithoutFeedback
+                    accessibilityLabel={bodyText}
+                    sentryLabel="GrowlNotification-Dismiss"
+                    onPress={() => triggerDismiss()}
+                >
+                    <GestureDetector gesture={flingGesture}>
+                        <View style={styles.growlNotificationBox}>
+                            {type === CONST.GROWL.LOADING ? (
+                                <ActivityIndicator reasonAttributes={{context: 'GrowlNotification.Loading'}} />
+                            ) : (
+                                <Icon
+                                    src={types[type].icon}
+                                    fill={types[type].iconColor}
+                                />
+                            )}
+                            <Text style={[styles.growlNotificationText, action ? styles.growlNotificationTextWithAction : styles.growlNotificationTextWithoutAction]}>{bodyText}</Text>
+                            {!!action && (
+                                <Button
+                                    medium
+                                    text={action.label}
+                                    accessibilityLabel={action.label}
+                                    sentryLabel="GrowlNotification-Action"
+                                    onPress={() => {
+                                        if (isActionPressedRef.current) {
+                                            return;
+                                        }
+                                        isActionPressedRef.current = true;
+                                        triggerDismiss();
+                                        action.onPress();
+                                    }}
+                                    innerStyles={styles.bgTransparent}
+                                    textStyles={styles.growlNotificationActionText}
+                                    shouldUseDefaultHover={false}
+                                    hoverStyles={styles.growlNotificationActionHovered}
+                                    isNested
+                                />
+                            )}
+                        </View>
+                    </GestureDetector>
+                </PressableWithoutFeedback>
+            </GrowlNotificationContainer>
+        </View>
+    );
+}
+
+export default GrowlNotificationContent;
diff --git a/src/components/GrowlNotification/index.tsx b/src/components/GrowlNotification/index.tsx
index 58d99ea81507..ea267874d63e 100644
--- a/src/components/GrowlNotification/index.tsx
+++ b/src/components/GrowlNotification/index.tsx
@@ -1,151 +1,55 @@
 import type {ForwardedRef} from 'react';
 import React, {useCallback, useEffect, useImperativeHandle, useState} from 'react';
-import {View} from 'react-native';
-import {Directions, Gesture, GestureDetector} from 'react-native-gesture-handler';
-import {useSharedValue, withSpring} from 'react-native-reanimated';
-import type {SvgProps} from 'react-native-svg';
-import Icon from '@components/Icon';
-import * as Pressables from '@components/Pressable';
-import Text from '@components/Text';
-import {useMemoizedLazyExpensifyIcons} from '@hooks/useLazyAsset';
-import useTheme from '@hooks/useTheme';
-import useThemeStyles from '@hooks/useThemeStyles';
 import {setIsReady} from '@libs/Growl';
-import type {GrowlRef} from '@libs/Growl';
-import CONST from '@src/CONST';
-import type IconAsset from '@src/types/utils/IconAsset';
-import GrowlNotificationContainer from './GrowlNotificationContainer';
-
-const INACTIVE_POSITION_Y = -255;
-
-const PressableWithoutFeedback = Pressables.PressableWithoutFeedback;
+import type {GrowlAction, GrowlRef, GrowlType} from '@libs/Growl';
+import GrowlNotificationContent from './GrowlNotificationContent';
+
+type GrowlContent = {
+    bodyText: string;
+    type: GrowlType;
+    duration: number;
+    action?: GrowlAction;
+};
 
 type GrowlNotificationProps = {
     /** Reference to outer element */
     ref?: ForwardedRef<GrowlRef>;
 };
 
+/**
+ * Outer growl shell. Intentionally does NOT subscribe to navigation/theme/responsive contexts —
+ * those live in GrowlNotificationContent, which is mounted only while a growl is visible.
+ * This keeps the shell from re-rendering on every screen change, focus change, etc.
+ */
 function GrowlNotification({ref}: GrowlNotificationProps) {
-    const translateY = useSharedValue(INACTIVE_POSITION_Y);
-    const [bodyText, setBodyText] = useState('');
-    const [type, setType] = useState('success');
-    const [duration, setDuration] = useState<number>();
-    const theme = useTheme();
-    const styles = useThemeStyles();
-    const icons = useMemoizedLazyExpensifyIcons(['Exclamation', 'Checkmark']);
-
-    type GrowlIconTypes = Record<
-        /** String representing the growl type, all type strings
-         *  for growl notifications are stored in CONST.GROWL
-         */
-        string,
-        {
-            /** Expensicon for the page */
-            icon: React.FC<SvgProps> | IconAsset;
+    const [content, setContent] = useState<GrowlContent | null>(null);
 
-            /** Color for the icon (should be from theme) */
-            iconColor: string;
-        }
-    >;
-
-    const types: GrowlIconTypes = {
-        [CONST.GROWL.SUCCESS]: {
-            icon: icons.Checkmark,
-            iconColor: theme.success,
-        },
-        [CONST.GROWL.ERROR]: {
-            icon: icons.Exclamation,
-            iconColor: theme.danger,
-        },
-        [CONST.GROWL.WARNING]: {
-            icon: icons.Exclamation,
-            iconColor: theme.warning,
-        },
-    };
-
-    /**
-     * Show the growl notification
-     *
-     * @param {String} bodyText
-     * @param {String} type
-     * @param {Number} duration
-     */
-    const show = useCallback((text: string, growlType: string, growlDuration: number) => {
-        setBodyText(text);
-        setType(growlType);
-        setDuration(growlDuration);
+    const show = useCallback((text: string, growlType: GrowlType, duration: number, action?: GrowlAction) => {
+        setContent({bodyText: text, type: growlType, duration, action});
     }, []);
 
-    /**
-     * Animate growl notification
-     *
-     * @param {Number} val
-     */
-    const fling = useCallback(
-        (val = INACTIVE_POSITION_Y) => {
-            'worklet';
-
-            translateY.set(
-                withSpring(val, {
-                    overshootClamping: false,
-                }),
-            );
-        },
-        [translateY],
-    );
-
-    useImperativeHandle(
-        ref,
-        () => ({
-            show,
-        }),
-        [show],
-    );
+    useImperativeHandle(ref, () => ({show}), [show]);
 
     useEffect(() => {
         setIsReady();
     }, []);
 
-    useEffect(() => {
-        if (!duration) {
-            return;
-        }
-
-        fling(0);
-        setTimeout(() => {
-            fling();
-            setDuration(undefined);
-        }, duration);
-    }, [duration, fling]);
+    const handleDismissed = useCallback(() => {
+        setContent(null);
+    }, []);
 
-    // GestureDetector by default runs callbacks on UI thread using Reanimated. In this
-    // case we want to trigger an RN's Animated animation, which needs to be done on JS thread.
-    const flingGesture = Gesture.Fling()
-        .direction(Directions.UP)
-        .runOnJS(true)
-        .onStart(() => {
-            fling();
-        });
+    if (!content) {
+        return null;
+    }
 
     return (
-        <View style={[styles.growlNotificationWrapper]}>
-            <GrowlNotificationContainer translateY={translateY}>
-                <PressableWithoutFeedback
-                    accessibilityLabel={bodyText}
-                    onPress={() => fling()}
-                >
-                    <GestureDetector gesture={flingGesture}>
-                        <View style={styles.growlNotificationBox}>
-                            <Icon
-                                src={types[type].icon}
-                                fill={types[type].iconColor}
-                            />
-                            <Text style={styles.growlNotificationText}>{bodyText}</Text>
-                        </View>
-                    </GestureDetector>
-                </PressableWithoutFeedback>
-            </GrowlNotificationContainer>
-        </View>
+        <GrowlNotificationContent
+            bodyText={content.bodyText}
+            type={content.type}
+            duration={content.duration}
+            action={content.action}
+            onDismissed={handleDismissed}
+        />
     );
 }
 
diff --git a/src/components/Search/ExpenseFlatSearchView.tsx b/src/components/Search/ExpenseFlatSearchView.tsx
index 8ac03d41a910..df24ff4dfbdb 100644
--- a/src/components/Search/ExpenseFlatSearchView.tsx
+++ b/src/components/Search/ExpenseFlatSearchView.tsx
@@ -69,9 +69,6 @@ type ExpenseFlatSearchViewProps = {
     /** Whether every transaction has been loaded (gates the fully-checked select-all state). */
     hasLoadedAllTransactions?: boolean;
 
-    /** Transactions flagged for the post-create highlight animation (feeds BaseSearchList extraData). */
-    newTransactions: Transaction[];
-
     /** The navigation/thread-creation handler for a row tap (owned by the router). */
     onSelectRow: (item: SearchListItem, transactionPreviewData?: TransactionPreviewData, event?: ModifiedMouseEvent) => void;
 
@@ -109,8 +106,7 @@ const isRowDeleted = (item: SearchListItem) => item.pendingAction === CONST.RED_
  * primitives directly around `BaseSearchList` — no `SearchList` shell, no `ListItem` prop, no factory.
  * `TransactionListItem` is the only row renderer for the flat-expense path, and rows always animate, so the
  * group/sticky/chat/task branches of `SearchList` do not apply here. Keyboard navigation is inherited from
- * `BaseSearchList`; the post-create highlight stays in the router (the snapshot stamps
- * `shouldAnimateInHighlight`, and `newTransactions` flows into `extraData`).
+ * `BaseSearchList`.
  */
 function ExpenseFlatSearchView({
     queryJSON,
@@ -124,7 +120,6 @@ function ExpenseFlatSearchView({
     SearchTableHeader: searchTableHeader,
     tableHeaderVisible,
     hasLoadedAllTransactions,
-    newTransactions,
     onSelectRow,
     ListFooterComponent,
     onEndReached,
@@ -279,7 +274,6 @@ function ExpenseFlatSearchView({
                     ListFooterComponent={ListFooterComponent}
                     onLayout={onLayout}
                     contentContainerStyle={contentContainerStyle}
-                    newTransactions={newTransactions}
                     isAttendeesEnabledForMovingPolicy={isAttendeesEnabledForMovingPolicy}
                     nonPersonalAndWorkspaceCards={nonPersonalAndWorkspaceCards}
                 />
diff --git a/src/components/Search/SearchList/BaseSearchList/index.tsx b/src/components/Search/SearchList/BaseSearchList/index.tsx
index d542cac81a46..cd49bad9cea3 100644
--- a/src/components/Search/SearchList/BaseSearchList/index.tsx
+++ b/src/components/Search/SearchList/BaseSearchList/index.tsx
@@ -58,7 +58,6 @@ function BaseSearchList({
     onLayout,
     contentContainerStyle,
     flattenedItemsLength,
-    newTransactions,
     isAttendeesEnabledForMovingPolicy,
     nonPersonalAndWorkspaceCards,
     stickyHeaderIndices,
@@ -165,8 +164,8 @@ function BaseSearchList({
     }, [setHasKeyBeenPressed]);
 
     const extraData = useMemo(
-        () => [focusedIndex, columns, newTransactions, nonPersonalAndWorkspaceCards, isAttendeesEnabledForMovingPolicy],
-        [focusedIndex, columns, newTransactions, nonPersonalAndWorkspaceCards, isAttendeesEnabledForMovingPolicy],
+        () => [focusedIndex, columns, nonPersonalAndWorkspaceCards, isAttendeesEnabledForMovingPolicy],
+        [focusedIndex, columns, nonPersonalAndWorkspaceCards, isAttendeesEnabledForMovingPolicy],
     );
 
     return (
diff --git a/src/components/Search/SearchList/BaseSearchList/types.ts b/src/components/Search/SearchList/BaseSearchList/types.ts
index 5ed483aab917..2b0b2bbb91ab 100644
--- a/src/components/Search/SearchList/BaseSearchList/types.ts
+++ b/src/components/Search/SearchList/BaseSearchList/types.ts
@@ -4,7 +4,7 @@ import type {NativeSyntheticEvent} from 'react-native';
 import type {SearchListItem} from '@components/Search/SearchList/ListItem/types';
 import type {SearchColumnType} from '@components/Search/types';
 import type {ExtendedTargetedEvent} from '@components/SelectionList/ListItem/types';
-import type {CardList, Transaction} from '@src/types/onyx';
+import type {CardList} from '@src/types/onyx';
 
 type BaseSearchListProps = Pick<
     FlashListProps<SearchListItem>,
@@ -30,9 +30,6 @@ type BaseSearchListProps = Pick<
     /** The columns that might change to trigger re-render via extraData */
     columns: SearchColumnType[];
 
-    /** The transactions that might trigger re-render via extraData */
-    newTransactions: Transaction[];
-
     /** The length of the flattened items in the list */
     flattenedItemsLength: number;
 
diff --git a/src/components/Search/SearchList/ListItem/GroupChildrenContainer.tsx b/src/components/Search/SearchList/ListItem/GroupChildrenContainer.tsx
index a6432c493e57..35fe8c523a7f 100644
--- a/src/components/Search/SearchList/ListItem/GroupChildrenContainer.tsx
+++ b/src/components/Search/SearchList/ListItem/GroupChildrenContainer.tsx
@@ -26,7 +26,6 @@ function GroupChildrenContainer({
     nonPersonalAndWorkspaceCards,
     onUndelete,
     isLastItem,
-    newTransactionID,
     bankAccountList,
     cardFeeds,
     conciergeReportID,
@@ -78,7 +77,6 @@ function GroupChildrenContainer({
                             onLongPressRow={onLongPressRow}
                             nonPersonalAndWorkspaceCards={nonPersonalAndWorkspaceCards}
                             onUndelete={onUndelete}
-                            newTransactionID={newTransactionID}
                             bankAccountList={bankAccountList}
                             cardFeeds={cardFeeds}
                             conciergeReportID={conciergeReportID}
diff --git a/src/components/Search/SearchList/ListItem/GroupChildrenContent.tsx b/src/components/Search/SearchList/ListItem/GroupChildrenContent.tsx
index 6f876082cd80..9c64f8b671cc 100644
--- a/src/components/Search/SearchList/ListItem/GroupChildrenContent.tsx
+++ b/src/components/Search/SearchList/ListItem/GroupChildrenContent.tsx
@@ -28,7 +28,6 @@ function GroupChildrenContent({
     onLongPressRow,
     nonPersonalAndWorkspaceCards,
     onUndelete,
-    newTransactionID,
     bankAccountList,
     cardFeeds,
     conciergeReportID,
@@ -121,15 +120,6 @@ function GroupChildrenContent({
         });
     };
 
-    useEffect(() => {
-        if (!newTransactionID || !isExpanded) {
-            return;
-        }
-        refreshTransactions();
-        // Only refresh when a new transaction is created in this group — refreshTransactions is excluded to avoid infinite loops
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [newTransactionID, isExpanded]);
-
     useEffect(() => {
         if (!isExpanded || isExpenseReportType) {
             return;
diff --git a/src/components/Search/SearchList/ListItem/TransactionGroupListItem.tsx b/src/components/Search/SearchList/ListItem/TransactionGroupListItem.tsx
index dff4e1eac338..b9599cba5d9a 100644
--- a/src/components/Search/SearchList/ListItem/TransactionGroupListItem.tsx
+++ b/src/components/Search/SearchList/ListItem/TransactionGroupListItem.tsx
@@ -79,7 +79,6 @@ function TransactionGroupListItem<TItem extends ListItem>({
     columns,
     groupBy,
     searchType,
-    newTransactionID,
     lastPaymentMethod,
     personalPolicyID,
     nonPersonalAndWorkspaceCards,
@@ -235,24 +234,6 @@ function TransactionGroupListItem<TItem extends ListItem>({
     ];
     const pressableRef = useRef<View>(null);
 
-    useEffect(() => {
-        if (!newTransactionID || !isExpanded) {
-            return;
-        }
-        if (!groupItem.transactionsQueryJSON) {
-            return;
-        }
-
-        search({
-            queryJSON: groupItem.transactionsQueryJSON,
-            searchKey: undefined,
-            offset: 0,
-            shouldCalculateTotals: false,
-            isLoading: !!transactionsSnapshot?.search?.isLoading,
-            isOffline,
-        });
-    }, [newTransactionID, isExpanded, groupItem.transactionsQueryJSON, isOffline, transactionsSnapshot?.search?.isLoading]);
-
     const wasScreenFocusedRef = useRef(isScreenFocused);
     useEffect(() => {
         const didReturnToScreen = wasScreenFocusedRef.current === false && isScreenFocused === true;
diff --git a/src/components/Search/SearchList/ListItem/types.ts b/src/components/Search/SearchList/ListItem/types.ts
index 23e11a170425..4f35c4112845 100644
--- a/src/components/Search/SearchList/ListItem/types.ts
+++ b/src/components/Search/SearchList/ListItem/types.ts
@@ -456,7 +456,6 @@ type TransactionGroupListItemProps<TItem extends ListItem> = ListItemProps<TItem
         searchType?: SearchDataTypes;
         accountID?: number;
         columns?: SearchColumnType[];
-        newTransactionID?: string;
         /** Non-personal and workspace cards for company card display */
         nonPersonalAndWorkspaceCards?: CardList;
         /** Callback to undelete a transaction */
@@ -527,7 +526,6 @@ type GroupChildrenContentProps = {
     onLongPressRow?: (item: SearchListItem, itemTransactions?: TransactionListItemType[]) => void;
     nonPersonalAndWorkspaceCards?: CardList;
     onUndelete?: (transaction: Transaction) => void;
-    newTransactionID?: string;
     bankAccountList?: OnyxEntry<BankAccountList>;
     cardFeeds?: OnyxCollection<CardFeeds>;
     conciergeReportID?: string;
diff --git a/src/components/Search/SearchList/index.tsx b/src/components/Search/SearchList/index.tsx
index f8b0de3a239e..20f1a4bcbb50 100644
--- a/src/components/Search/SearchList/index.tsx
+++ b/src/components/Search/SearchList/index.tsx
@@ -9,7 +9,7 @@ import SelectionTopBar from '@components/Search/primitives/SelectionTopBar';
 import useRowLongPressMenu from '@components/Search/primitives/useRowLongPressMenu';
 import useScrollRestoration from '@components/Search/primitives/useScrollRestoration';
 import {useSearchRowSelectionActions, useSearchSelectionContext} from '@components/Search/SearchContext';
-import type {SearchColumnType, SearchGroupBy, SearchQueryJSON} from '@components/Search/types';
+import type {SearchColumnType, SearchQueryJSON} from '@components/Search/types';
 import type {ExtendedTargetedEvent} from '@components/SelectionList/ListItem/types';
 import {useEditingCellState} from '@components/TransactionItemRow/EditableCell';
 import useKeyboardState from '@hooks/useKeyboardState';
@@ -20,7 +20,6 @@ import useResponsiveLayout from '@hooks/useResponsiveLayout';
 import useSafeAreaPaddings from '@hooks/useSafeAreaPaddings';
 import useThemeStyles from '@hooks/useThemeStyles';
 import useUndeleteTransactions from '@hooks/useUndeleteTransactions';
-import DateUtils from '@libs/DateUtils';
 import getPlatform from '@libs/getPlatform';
 import type {ModifiedMouseEvent} from '@libs/Navigation/helpers/openInternalRouteInNewTab';
 import {splitGroupsIntoPairs} from '@libs/SearchUIUtils';
@@ -38,19 +37,7 @@ import GroupHeader from './ListItem/GroupHeader';
 import type TaskListItem from './ListItem/TaskListItem';
 import type TransactionGroupListItem from './ListItem/TransactionGroupListItem';
 import type TransactionListItem from './ListItem/TransactionListItem';
-import type {
-    ReportActionListItemType,
-    TaskListItemType,
-    TransactionCardGroupListItemType,
-    TransactionCategoryGroupListItemType,
-    TransactionGroupListItemType,
-    TransactionListItemType,
-    TransactionMerchantGroupListItemType,
-    TransactionMonthGroupListItemType,
-    TransactionQuarterGroupListItemType,
-    TransactionWeekGroupListItemType,
-    TransactionYearGroupListItemType,
-} from './ListItem/types';
+import type {ReportActionListItemType, TaskListItemType, TransactionGroupListItemType, TransactionListItemType} from './ListItem/types';
 import {isGroupChildrenContainerItem, isGroupHeaderItem} from './ListItem/types';
 
 type SearchListItem = TransactionListItemType | TransactionGroupListItemType | ReportActionListItemType | TaskListItemType;
@@ -101,8 +88,6 @@ type SearchListProps = Pick<FlashListProps<SearchListItem>, 'onScroll' | 'conten
     /** Whether mobile selection mode is enabled */
     isMobileSelectionModeEnabled: boolean;
 
-    newTransactions?: Transaction[];
-
     /** Non-personal and workspace cards (same drill path as former custom card names for rows) */
     nonPersonalAndWorkspaceCards?: CardList;
 
@@ -129,49 +114,6 @@ function isTransactionGroupListItemArray(data: SearchListItem[]): data is Transa
     return typeof firstElement === 'object' && 'transactions' in firstElement;
 }
 
-function isTransactionMatchWithGroupItem(transaction: Transaction, groupItem: SearchListItem, groupBy: SearchGroupBy | undefined) {
-    if (groupBy === CONST.SEARCH.GROUP_BY.CARD) {
-        return transaction.cardID === (groupItem as TransactionCardGroupListItemType).cardID;
-    }
-    if (groupBy === CONST.SEARCH.GROUP_BY.FROM) {
-        return !!transaction.transactionID;
-    }
-    if (groupBy === CONST.SEARCH.GROUP_BY.CATEGORY) {
-        return (transaction.category ?? '') === ((groupItem as TransactionCategoryGroupListItemType).category ?? '');
-    }
-    if (groupBy === CONST.SEARCH.GROUP_BY.MERCHANT) {
-        return (transaction.merchant ?? '') === ((groupItem as TransactionMerchantGroupListItemType).merchant ?? '');
-    }
-    if (groupBy === CONST.SEARCH.GROUP_BY.MONTH) {
-        const monthGroup = groupItem as TransactionMonthGroupListItemType;
-        const transactionDateString = transaction.modifiedCreated ?? transaction.created ?? '';
-        return DateUtils.isDateStringInMonth(transactionDateString, monthGroup.year, monthGroup.month);
-    }
-    if (groupBy === CONST.SEARCH.GROUP_BY.WEEK) {
-        const weekGroup = groupItem as TransactionWeekGroupListItemType;
-        const transactionDateString = transaction.modifiedCreated ?? transaction.created ?? '';
-        const datePart = transactionDateString.substring(0, 10);
-        const {start: weekStart, end: weekEnd} = DateUtils.getWeekDateRange(weekGroup.week);
-        return datePart >= weekStart && datePart <= weekEnd;
-    }
-    if (groupBy === CONST.SEARCH.GROUP_BY.YEAR) {
-        const yearGroup = groupItem as TransactionYearGroupListItemType;
-        const transactionDateString = transaction.modifiedCreated ?? transaction.created ?? '';
-        const transactionYear = parseInt(transactionDateString.substring(0, 4), 10);
-        return transactionYear === yearGroup.year;
-    }
-    if (groupBy === CONST.SEARCH.GROUP_BY.QUARTER) {
-        const quarterGroup = groupItem as TransactionQuarterGroupListItemType;
-        const transactionDateString = transaction.modifiedCreated ?? transaction.created ?? '';
-        const transactionYear = parseInt(transactionDateString.substring(0, 4), 10);
-        const transactionMonth = parseInt(transactionDateString.substring(5, 7), 10);
-        // Calculate which quarter the transaction belongs to (1-4)
-        const transactionQuarter = Math.floor((transactionMonth - 1) / 3) + 1;
-        return transactionYear === quarterGroup.year && transactionQuarter === quarterGroup.quarter;
-    }
-    return false;
-}
-
 function SearchList({
     data,
     ListItem,
@@ -191,7 +133,6 @@ function SearchList({
     onLayout,
     shouldAnimate,
     isMobileSelectionModeEnabled,
-    newTransactions = [],
     nonPersonalAndWorkspaceCards,
     hasLoadedAllTransactions,
     isActionColumnWide,
@@ -363,22 +304,6 @@ function SearchList({
 
     const handleUndelete = (transaction: Transaction) => undeleteTransactions([transaction]);
 
-    const newTransactionIDByItemKey = (() => {
-        if (newTransactions.length === 0) {
-            return CONST.EMPTY_MAP;
-        }
-
-        const mappedTransactionIDs = new Map<string, string>();
-        for (const item of data) {
-            const matchedTransactionID = newTransactions.find((transaction) => isTransactionMatchWithGroupItem(transaction, item, groupBy))?.transactionID;
-            if (matchedTransactionID && item.keyForList) {
-                mappedTransactionIDs.set(item.keyForList, matchedTransactionID);
-            }
-        }
-
-        return mappedTransactionIDs;
-    })();
-
     const {onLongPressRow, modal} = useRowLongPressMenu({shouldPreventLongPressRow, isSmallScreenWidth, isMobileSelectionModeEnabled});
 
     // In mobile selection mode a row tap toggles selection. This must live here (not in <Search>) because
@@ -492,7 +417,6 @@ function SearchList({
             if (isGroupChildrenContainerItem(item)) {
                 const containerItem = item;
                 const originalKey = (item.keyForList ?? '').replace('children_', '');
-                const containerNewTransactionID = item.keyForList ? newTransactionIDByItemKey.get(originalKey) : undefined;
                 return (
                     <GroupChildrenContainer
                         item={containerItem}
@@ -507,7 +431,6 @@ function SearchList({
                         nonPersonalAndWorkspaceCards={nonPersonalAndWorkspaceCards}
                         onUndelete={handleUndelete}
                         isLastItem={index === lastVisibleIndex && !ListFooterComponent}
-                        newTransactionID={containerNewTransactionID}
                         bankAccountList={bankAccountList}
                         cardFeeds={cardFeeds}
                         conciergeReportID={conciergeReportID}
@@ -519,8 +442,6 @@ function SearchList({
             const isDisabled = item.pendingAction === CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE;
             const shouldApplyAnimation = shouldAnimate && index < listData.length - 1;
 
-            const newTransactionID = item.keyForList ? newTransactionIDByItemKey.get(item.keyForList) : undefined;
-
             return (
                 <AnimatedExitRow
                     shouldApplyAnimation={!!shouldApplyAnimation}
@@ -544,7 +465,6 @@ function SearchList({
                         ownerBillingGracePeriodEnd={ownerBillingGracePeriodEnd}
                         nonPersonalAndWorkspaceCards={nonPersonalAndWorkspaceCards}
                         onFocus={onFocus}
-                        newTransactionID={newTransactionID}
                         onUndelete={handleUndelete}
                         keyForList={item.keyForList}
                         isFirstItem={index === firstVisibleIndex}
@@ -556,7 +476,6 @@ function SearchList({
         [
             type,
             groupBy,
-            newTransactionIDByItemKey,
             shouldAnimate,
             listData.length,
             hasItemsBeingRemoved,
@@ -621,7 +540,6 @@ function SearchList({
                 onViewableItemsChanged={onViewableItemsChanged}
                 onLayout={onLayout}
                 contentContainerStyle={contentContainerStyle}
-                newTransactions={newTransactions}
                 isAttendeesEnabledForMovingPolicy={isAttendeesEnabledForMovingPolicy}
                 nonPersonalAndWorkspaceCards={nonPersonalAndWorkspaceCards}
                 stickyHeaderIndices={stickyHeaderIndices}
diff --git a/src/components/Search/index.tsx b/src/components/Search/index.tsx
index f439bfa2cef5..136b04a34499 100644
--- a/src/components/Search/index.tsx
+++ b/src/components/Search/index.tsx
@@ -20,7 +20,7 @@ import usePolicyForMovingExpenses from '@hooks/usePolicyForMovingExpenses';
 import usePrevious from '@hooks/usePrevious';
 import useResponsiveLayout from '@hooks/useResponsiveLayout';
 import useSaveSortedReportIDs from '@hooks/useSaveSortedReportIDs';
-import useSearchHighlightAndScroll from '@hooks/useSearchHighlightAndScroll';
+import useSearchAutoRefetch from '@hooks/useSearchAutoRefetch';
 import useSearchShouldCalculateTotals from '@hooks/useSearchShouldCalculateTotals';
 import useStableArrayReference from '@hooks/useStableArrayReference';
 import useThemeStyles from '@hooks/useThemeStyles';
@@ -194,7 +194,7 @@ function Search({
         clearSelectedTransactions();
     }, [validGroupBy, prevValidGroupBy, clearSelectedTransactions]);
 
-    const {newSearchResultKeys, handleSelectionListScroll, newTransactions, hasQueuedHighlights} = useSearchHighlightAndScroll({
+    useSearchAutoRefetch({
         searchResults,
         transactions,
         previousTransactions,
@@ -223,17 +223,7 @@ function Search({
         hasPendingWriteOnMountRef,
         skipDeferralOnFocusRef,
         rearmTracking,
-    } = useSearchSnapshot({queryJSON, searchResults, newSearchResultKeys, transactions, reportActions});
-
-    // Mirror `hasQueuedHighlights` into a ref so the post-create-flow `useFocusEffect`
-    // (which has empty deps) can read the latest value without re-creating its callback.
-    // Used to skip the deferral that would otherwise hide the freshly-added row from
-    // FlashList during the RHP dismiss transition, which would prevent the highlight
-    // animation from ever firing on it.
-    const hasQueuedHighlightsRef = useRef(hasQueuedHighlights);
-    useEffect(() => {
-        hasQueuedHighlightsRef.current = hasQueuedHighlights;
-    }, [hasQueuedHighlights]);
+    } = useSearchSnapshot({queryJSON, searchResults, newSearchResultKeys: null, transactions, reportActions});
 
     // There's a race condition in Onyx which makes it return data from the previous Search, so in addition to checking that the data is loaded
     // we also need to check that the searchResults matches the type and status of the current search
@@ -294,14 +284,6 @@ function Search({
                 return;
             }
 
-            // If the highlight hook already queued rows for the post-create animation,
-            // skip the skeleton-during-transition defer. Otherwise FlashList stays empty
-            // for ~1s while the RHP dismiss transition runs, the row never mounts inside
-            // the 300ms highlight window, and `useAnimatedHighlightStyle` never fires.
-            if (hasQueuedHighlightsRef.current) {
-                return;
-            }
-
             // Show skeleton while the RHP dismiss animation plays. The transition
             // hasn't started yet when useFocusEffect fires (it begins after paint),
             // so waitForUpcomingTransition defers until the animation actually ends.
@@ -734,9 +716,8 @@ function Search({
 
     const onLayout = useCallback(() => {
         onLayoutBase();
-        handleSelectionListScroll(stableSortedData, searchListRef.current);
         onContentReady?.();
-    }, [onLayoutBase, handleSelectionListScroll, stableSortedData, onContentReady]);
+    }, [onLayoutBase, onContentReady]);
 
     // Must be a ref, not state: cancelNavigationSpans is called during render
     // (inside conditional returns), so using setState would trigger infinite re-renders.
@@ -1075,7 +1056,6 @@ function Search({
                             ListFooterComponent={listFooterComponent}
                             onLayout={onLayout}
                             isMobileSelectionModeEnabled={isMobileSelectionModeEnabled}
-                            newTransactions={newTransactions}
                             hasLoadedAllTransactions={hasLoadedAllTransactions}
                             isAttendeesEnabledForMovingPolicy={isAttendeesEnabledForMovingPolicy}
                             nonPersonalAndWorkspaceCards={nonPersonalAndWorkspaceCards}
@@ -1101,7 +1081,6 @@ function Search({
                             onLayout={onLayout}
                             isMobileSelectionModeEnabled={isMobileSelectionModeEnabled}
                             shouldAnimate={type === CONST.SEARCH.DATA_TYPES.EXPENSE}
-                            newTransactions={newTransactions}
                             hasLoadedAllTransactions={hasLoadedAllTransactions}
                             isAttendeesEnabledForMovingPolicy={isAttendeesEnabledForMovingPolicy}
                             nonPersonalAndWorkspaceCards={nonPersonalAndWorkspaceCards}
diff --git a/src/hooks/useSearchAutoRefetch.ts b/src/hooks/useSearchAutoRefetch.ts
new file mode 100644
index 000000000000..24f53d47f611
--- /dev/null
+++ b/src/hooks/useSearchAutoRefetch.ts
@@ -0,0 +1,172 @@
+import {useIsFocused} from '@react-navigation/native';
+import {useEffect, useRef} from 'react';
+import type {OnyxCollection, OnyxEntry} from 'react-native-onyx';
+import type {SearchQueryJSON} from '@components/Search/types';
+import {search} from '@libs/actions/Search';
+import isSearchTopmostFullScreenRoute from '@libs/Navigation/helpers/isSearchTopmostFullScreenRoute';
+import TransitionTracker from '@libs/Navigation/TransitionTracker';
+import {isReportActionEntry} from '@libs/SearchUIUtils';
+import type {SearchKey} from '@libs/SearchUIUtils';
+import CONST from '@src/CONST';
+import type {ReportActions, SearchResults, Transaction} from '@src/types/onyx';
+import useNetwork from './useNetwork';
+
+type UseSearchAutoRefetch = {
+    searchResults: OnyxEntry<SearchResults>;
+    transactions: OnyxCollection<Transaction>;
+    previousTransactions: OnyxCollection<Transaction>;
+    reportActions: OnyxCollection<ReportActions>;
+    previousReportActions: OnyxCollection<ReportActions>;
+    queryJSON: SearchQueryJSON;
+    searchKey: SearchKey | undefined;
+    offset: number;
+    shouldCalculateTotals: boolean;
+    shouldUseLiveData: boolean;
+};
+
+function useSearchAutoRefetch({
+    searchResults,
+    transactions,
+    previousTransactions,
+    reportActions,
+    previousReportActions,
+    queryJSON,
+    searchKey,
+    offset,
+    shouldCalculateTotals,
+    shouldUseLiveData,
+}: UseSearchAutoRefetch) {
+    const isFocused = useIsFocused();
+    const {isOffline} = useNetwork();
+    const searchTriggeredRef = useRef(false);
+    const hasPendingSearchRef = useRef(false);
+    const isChat = queryJSON.type === CONST.SEARCH.DATA_TYPES.CHAT;
+    const searchResultsData = searchResults?.data;
+
+    useEffect(() => {
+        const previousTransactionIDsLocal = Object.keys(previousTransactions ?? {});
+        const transactionsIDs = Object.keys(transactions ?? {});
+
+        const reportActionsIDs = Object.values(reportActions ?? {})
+            .map((actions) => Object.keys(actions ?? {}))
+            .flat();
+        const previousReportActionsIDs = Object.values(previousReportActions ?? {})
+            .map((actions) => Object.keys(actions ?? {}))
+            .flat();
+
+        if ((previousTransactionIDsLocal.length === 0 && previousReportActionsIDs.length === 0) || searchTriggeredRef.current) {
+            return;
+        }
+
+        const previousTransactionsIDsSet = new Set(previousTransactionIDsLocal);
+        const previousReportActionsIDsSet = new Set(previousReportActionsIDs);
+        const hasTransactionsIDsChange = transactionsIDs.length !== previousTransactionIDsLocal.length || transactionsIDs.some((id) => !previousTransactionsIDsSet.has(id));
+        const hasReportActionsIDsChange = reportActionsIDs.some((id) => !previousReportActionsIDsSet.has(id));
+
+        if ((!isChat && hasTransactionsIDsChange) || hasReportActionsIDsChange || hasPendingSearchRef.current) {
+            // An RHP layered on top of Search makes `isFocused` false but keeps Search as the topmost
+            // fullscreen route, so we still want to refetch — otherwise the snapshot can't reflect
+            // entries the user creates from the RHP until they close it.
+            const isSearchStillActive = isFocused || isSearchTopmostFullScreenRoute();
+            if (!isSearchStillActive || isOffline) {
+                hasPendingSearchRef.current = true;
+                return;
+            }
+            hasPendingSearchRef.current = false;
+
+            const newIDs = isChat ? reportActionsIDs : transactionsIDs;
+            let currentSearchResultIDs: string[] = [];
+            if (searchResultsData) {
+                currentSearchResultIDs = isChat ? extractReportActionIDsFromSearchResults(searchResultsData) : extractTransactionIDsFromSearchResults(searchResultsData);
+            }
+            const existingSearchResultIDsSet = new Set(currentSearchResultIDs);
+            const hasAGenuinelyNewID = newIDs.some((id) => !existingSearchResultIDsSet.has(id));
+
+            // Only skip search if there are no new items AND search results aren't empty.
+            // This ensures deletions that result in empty data still trigger search.
+            if (!hasAGenuinelyNewID && currentSearchResultIDs.length > 0) {
+                const newIDsSet = new Set(newIDs);
+                const hasDeletedID = currentSearchResultIDs.some((id) => !newIDsSet.has(id));
+                if (!hasDeletedID) {
+                    return;
+                }
+            }
+
+            TransitionTracker.runAfterTransitions({
+                callback: () => {
+                    search({queryJSON, searchKey, offset, shouldCalculateTotals, isLoading: !!searchResults?.search?.isLoading});
+                },
+            });
+
+            searchTriggeredRef.current = true;
+        }
+    }, [
+        isFocused,
+        transactions,
+        previousTransactions,
+        queryJSON,
+        searchKey,
+        offset,
+        shouldCalculateTotals,
+        reportActions,
+        previousReportActions,
+        isChat,
+        searchResultsData,
+        isOffline,
+        searchResults?.search?.isLoading,
+    ]);
+
+    useEffect(() => {
+        // For live data, isLoading is always false, so we also need to reset when searchResultsData changes.
+        // For snapshot data, we wait for isLoading to become false after the API call completes.
+        if (searchResults?.search?.isLoading) {
+            return;
+        }
+
+        searchTriggeredRef.current = false;
+    }, [searchResults?.search?.isLoading, shouldUseLiveData, searchResultsData]);
+}
+
+function getTransactionIDFromValue(value: unknown): string | undefined {
+    if (!value || typeof value !== 'object' || !('transactionID' in value)) {
+        return undefined;
+    }
+    const {transactionID} = value;
+    return typeof transactionID === 'string' && transactionID ? transactionID : undefined;
+}
+
+function extractTransactionIDsFromSearchResults(searchResultsData: Partial<SearchResults['data']>): string[] {
+    const transactionIDs: string[] = [];
+
+    for (const item of Object.values(searchResultsData)) {
+        if (!item || typeof item !== 'object') {
+            continue;
+        }
+
+        const itemTransactionID = getTransactionIDFromValue(item);
+        if (itemTransactionID) {
+            transactionIDs.push(itemTransactionID);
+        }
+
+        if ('transactions' in item && Array.isArray(item.transactions)) {
+            for (const transaction of item.transactions) {
+                const transactionID = getTransactionIDFromValue(transaction);
+                if (transactionID) {
+                    transactionIDs.push(transactionID);
+                }
+            }
+        }
+    }
+
+    return transactionIDs;
+}
+
+function extractReportActionIDsFromSearchResults(searchResultsData: Partial<SearchResults['data']>): string[] {
+    return Object.keys(searchResultsData ?? {})
+        .filter(isReportActionEntry)
+        .map((key) => Object.keys(searchResultsData[key] ?? {}))
+        .flat();
+}
+
+export default useSearchAutoRefetch;
+export type {UseSearchAutoRefetch};
diff --git a/src/hooks/useSearchHighlightAndScroll.ts b/src/hooks/useSearchHighlightAndScroll.ts
deleted file mode 100644
index 079214806cd6..000000000000
--- a/src/hooks/useSearchHighlightAndScroll.ts
+++ /dev/null
@@ -1,357 +0,0 @@
-import {useIsFocused} from '@react-navigation/native';
-import {useCallback, useEffect, useRef, useState} from 'react';
-import type {OnyxCollection, OnyxEntry} from 'react-native-onyx';
-import type {SearchListItem, TransactionGroupListItemType, TransactionListItemType} from '@components/Search/SearchList/ListItem/types';
-import type {SearchQueryJSON} from '@components/Search/types';
-import type {SelectionListHandle} from '@components/SelectionList/types';
-import {search} from '@libs/actions/Search';
-import {mergeTransactionIdsHighlightOnSearchRoute} from '@libs/actions/Transaction';
-import isSearchTopmostFullScreenRoute from '@libs/Navigation/helpers/isSearchTopmostFullScreenRoute';
-import TransitionTracker from '@libs/Navigation/TransitionTracker';
-import {isReportActionEntry} from '@libs/SearchUIUtils';
-import type {SearchKey} from '@libs/SearchUIUtils';
-import CONST from '@src/CONST';
-import ONYXKEYS from '@src/ONYXKEYS';
-import type {ReportActions, SearchResults, Transaction} from '@src/types/onyx';
-import useNetwork from './useNetwork';
-import useOnyx from './useOnyx';
-import usePrevious from './usePrevious';
-
-type UseSearchHighlightAndScroll = {
-    searchResults: OnyxEntry<SearchResults>;
-    transactions: OnyxCollection<Transaction>;
-    previousTransactions: OnyxCollection<Transaction>;
-    reportActions: OnyxCollection<ReportActions>;
-    previousReportActions: OnyxCollection<ReportActions>;
-    queryJSON: SearchQueryJSON;
-    searchKey: SearchKey | undefined;
-    offset: number;
-    shouldCalculateTotals: boolean;
-    shouldUseLiveData: boolean;
-};
-
-/**
- * Hook used to trigger a search when a new transaction or report action is added and handle highlighting and scrolling.
- */
-function useSearchHighlightAndScroll({
-    searchResults,
-    transactions,
-    previousTransactions,
-    reportActions,
-    previousReportActions,
-    queryJSON,
-    searchKey,
-    offset,
-    shouldCalculateTotals,
-    shouldUseLiveData,
-}: UseSearchHighlightAndScroll) {
-    const isFocused = useIsFocused();
-    const {isOffline} = useNetwork();
-    // Ref to track if the search was triggered by this hook
-    const triggeredByHookRef = useRef(false);
-    const searchTriggeredRef = useRef(false);
-    const hasNewItemsRef = useRef(false);
-    const previousSearchResults = usePrevious(searchResults?.data);
-    const [newSearchResultKeys, setNewSearchResultKeys] = useState<Set<string> | null>(null);
-    const highlightedIDs = useRef<Set<string>>(new Set());
-    const initializedRef = useRef(false);
-    const hasPendingSearchRef = useRef(false);
-    const isChat = queryJSON.type === CONST.SEARCH.DATA_TYPES.CHAT;
-
-    const transactionIDsToHighlightSelector = useCallback((allTransactionIDs: OnyxEntry<Record<string, Record<string, boolean>>>) => allTransactionIDs?.[queryJSON.type], [queryJSON.type]);
-    const [transactionIDsToHighlight] = useOnyx(ONYXKEYS.TRANSACTION_IDS_HIGHLIGHT_ON_SEARCH_ROUTE, {
-        selector: transactionIDsToHighlightSelector,
-    });
-    const searchResultsData = searchResults?.data;
-
-    const prevTransactionsIDs = Object.keys(previousTransactions ?? {});
-    const newTransactions: Transaction[] = [];
-    if (prevTransactionsIDs.length > 0) {
-        const previousIDs = new Set(prevTransactionsIDs);
-        for (const [id, transaction] of Object.entries(transactions ?? {})) {
-            if (!previousIDs.has(id) && transaction) {
-                newTransactions.push(transaction);
-            }
-        }
-    }
-
-    // Trigger search when a new report action is added while on chat or when a new transaction is added for the other search types.
-    useEffect(() => {
-        const previousTransactionIDsLocal = Object.keys(previousTransactions ?? {});
-        const transactionsIDs = Object.keys(transactions ?? {});
-
-        const reportActionsIDs = Object.values(reportActions ?? {})
-            .map((actions) => Object.keys(actions ?? {}))
-            .flat();
-        const previousReportActionsIDs = Object.values(previousReportActions ?? {})
-            .map((actions) => Object.keys(actions ?? {}))
-            .flat();
-
-        // Only proceed if we have previous data to compare against
-        // This prevents triggering on initial data load
-        if ((previousTransactionIDsLocal.length === 0 && previousReportActionsIDs.length === 0) || searchTriggeredRef.current) {
-            return;
-        }
-
-        const previousTransactionsIDsSet = new Set(previousTransactionIDsLocal);
-        const previousReportActionsIDsSet = new Set(previousReportActionsIDs);
-        const hasTransactionsIDsChange = transactionsIDs.length !== previousTransactionIDsLocal.length || transactionsIDs.some((id) => !previousTransactionsIDsSet.has(id));
-        const hasReportActionsIDsChange = reportActionsIDs.some((id) => !previousReportActionsIDsSet.has(id));
-
-        // Check if there is a change in the transactions or report actions list
-        if ((!isChat && hasTransactionsIDsChange) || hasReportActionsIDsChange || hasPendingSearchRef.current) {
-            // Skip if offline, or if the user has navigated to a different fullscreen page entirely.
-            // An RHP layered on top of Search makes `isFocused` false but keeps Search as the topmost
-            // fullscreen route, so we still want to refetch — otherwise the snapshot can't reflect
-            // entries the user creates from the RHP until they close it.
-            const isSearchStillActive = isFocused || isSearchTopmostFullScreenRoute();
-            if (!isSearchStillActive || isOffline) {
-                hasPendingSearchRef.current = true;
-                return;
-            }
-            hasPendingSearchRef.current = false;
-
-            const newIDs = isChat ? reportActionsIDs : transactionsIDs;
-            let currentSearchResultIDs: string[] = [];
-            if (searchResultsData) {
-                currentSearchResultIDs = isChat ? extractReportActionIDsFromSearchResults(searchResultsData) : extractTransactionIDsFromSearchResults(searchResultsData);
-            }
-            const existingSearchResultIDsSet = new Set(currentSearchResultIDs);
-            const hasAGenuinelyNewID = newIDs.some((id) => !existingSearchResultIDsSet.has(id));
-
-            // Only skip search if there are no new items AND search results aren't empty
-            // This ensures deletions that result in empty data still trigger search
-            if (!hasAGenuinelyNewID && currentSearchResultIDs.length > 0) {
-                const newIDsSet = new Set(newIDs);
-                const hasDeletedID = currentSearchResultIDs.some((id) => !newIDsSet.has(id));
-                if (!hasDeletedID) {
-                    return;
-                }
-            }
-            // We only want to highlight new items if the addition of transactions or report actions triggered the search.
-            // This is because, on deletion of items, the backend sometimes returns old items in place of the deleted ones.
-            // We don't want to highlight these old items, even if they appear new in the current search results.
-            hasNewItemsRef.current = isChat ? reportActionsIDs.length > previousReportActionsIDs.length : transactionsIDs.length > previousTransactionIDsLocal.length;
-
-            // Set the flag indicating the search is triggered by the hook
-            triggeredByHookRef.current = true;
-
-            // Trigger the search
-            TransitionTracker.runAfterTransitions({
-                callback: () => {
-                    search({queryJSON, searchKey, offset, shouldCalculateTotals, isLoading: !!searchResults?.search?.isLoading});
-                },
-            });
-
-            // Set the ref to prevent further triggers until reset
-            searchTriggeredRef.current = true;
-        }
-    }, [
-        isFocused,
-        transactions,
-        previousTransactions,
-        queryJSON,
-        searchKey,
-        offset,
-        shouldCalculateTotals,
-        reportActions,
-        previousReportActions,
-        isChat,
-        searchResultsData,
-        isOffline,
-        searchResults?.search?.isLoading,
-    ]);
-
-    useEffect(() => {
-        // For live data, isLoading is always false, so we also need to reset when searchResultsData changes
-        // For snapshot data, we wait for isLoading to become false after the API call completes
-        if (searchResults?.search?.isLoading) {
-            return;
-        }
-
-        searchTriggeredRef.current = false;
-    }, [searchResults?.search?.isLoading, shouldUseLiveData, searchResultsData]);
-
-    // Initialize the set with existing IDs only once
-    useEffect(() => {
-        if (initializedRef.current || !searchResultsData) {
-            return;
-        }
-
-        const initialIDs = isChat ? extractReportActionIDsFromSearchResults(searchResultsData) : extractTransactionIDsFromSearchResults(searchResultsData);
-        highlightedIDs.current = new Set(initialIDs);
-        initializedRef.current = true;
-    }, [searchResultsData, isChat]);
-
-    // Detect new items (transactions or report actions)
-    useEffect(() => {
-        if (!previousSearchResults || !searchResults?.data) {
-            return;
-        }
-        if (isChat) {
-            const previousReportActionIDs = extractReportActionIDsFromSearchResults(previousSearchResults);
-            const currentReportActionIDs = extractReportActionIDsFromSearchResults(searchResults.data);
-
-            // Find new report action IDs that are not in the previousReportActionIDs and not already highlighted
-            const newReportActionIDs = currentReportActionIDs.filter((id) => !previousReportActionIDs.includes(id) && !highlightedIDs.current.has(id));
-
-            if (!triggeredByHookRef.current || newReportActionIDs.length === 0 || !hasNewItemsRef.current) {
-                return;
-            }
-
-            const newKeys = new Set<string>();
-            for (const id of newReportActionIDs) {
-                const newReportActionKey = `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${id}`;
-                highlightedIDs.current.add(newReportActionKey);
-                newKeys.add(newReportActionKey);
-            }
-            setNewSearchResultKeys(newKeys);
-        } else {
-            const previousTransactionIDs = extractTransactionIDsFromSearchResults(previousSearchResults);
-            const currentTransactionIDs = extractTransactionIDsFromSearchResults(searchResults.data);
-            const manualHighlightTransactionIDs = new Set(Object.keys(transactionIDsToHighlight ?? {}).filter((id) => !!transactionIDsToHighlight?.[id]));
-
-            // Find new transaction IDs that are not in the previousTransactionIDs and not already highlighted
-            const newTransactionIDs = currentTransactionIDs.filter((id) => {
-                if (manualHighlightTransactionIDs.has(id)) {
-                    return true;
-                }
-                if (!triggeredByHookRef.current || !hasNewItemsRef.current) {
-                    return false;
-                }
-                return !previousTransactionIDs.includes(id) && !highlightedIDs.current.has(id);
-            });
-
-            if (newTransactionIDs.length === 0) {
-                return;
-            }
-
-            const newKeys = new Set<string>();
-            const consumedManualIDs: string[] = [];
-            for (const id of newTransactionIDs) {
-                const newTransactionKey = `${ONYXKEYS.COLLECTION.TRANSACTION}${id}`;
-                highlightedIDs.current.add(newTransactionKey);
-                newKeys.add(newTransactionKey);
-                if (manualHighlightTransactionIDs.has(id)) {
-                    consumedManualIDs.push(id);
-                }
-            }
-            setNewSearchResultKeys(newKeys);
-
-            // Clear consumed manual highlight flags so subsequent detect runs don't re-highlight the same IDs.
-            if (consumedManualIDs.length > 0) {
-                mergeTransactionIdsHighlightOnSearchRoute(queryJSON.type, Object.fromEntries(consumedManualIDs.map((id) => [id, false])));
-            }
-        }
-    }, [searchResults?.data, previousSearchResults, isChat, transactionIDsToHighlight, queryJSON.type]);
-
-    // Remove transactionIDsToHighlight when the user leaves the current search type
-    useEffect(
-        () => () => {
-            mergeTransactionIdsHighlightOnSearchRoute(queryJSON.type, null);
-        },
-        [queryJSON.type],
-    );
-
-    // Reset newSearchResultKey after it's been used
-    useEffect(() => {
-        if (newSearchResultKeys === null) {
-            return;
-        }
-
-        const timer = setTimeout(() => {
-            setNewSearchResultKeys(null);
-        }, CONST.ANIMATED_HIGHLIGHT_START_DURATION);
-
-        return () => clearTimeout(timer);
-    }, [newSearchResultKeys]);
-
-    /**
-     * Callback to handle scrolling to the new search result.
-     */
-    const handleSelectionListScroll = (data: SearchListItem[], ref: SelectionListHandle<SearchListItem> | null) => {
-        // Early return if there's no ref, new transaction wasn't brought in by this hook
-        // or there's no new search result key
-        const newSearchResultKey = newSearchResultKeys?.values().next().value;
-        if (!ref || !triggeredByHookRef.current || !newSearchResultKey) {
-            return;
-        }
-
-        // Extract the transaction/report action ID from the newSearchResultKey
-        const newID = newSearchResultKey.replace(isChat ? ONYXKEYS.COLLECTION.REPORT_ACTIONS : ONYXKEYS.COLLECTION.TRANSACTION, '');
-
-        // Find the index of the new transaction/report action in the data array
-        const indexOfNewItem = data.findIndex((item) => {
-            if (isChat) {
-                if ('reportActionID' in item && item.reportActionID === newID) {
-                    return true;
-                }
-            } else {
-                // Handle TransactionListItemType
-                if ('transactionID' in item && item.transactionID === newID) {
-                    return true;
-                }
-
-                // Handle TransactionGroupListItemType with transactions array
-                if ('transactions' in item && Array.isArray(item.transactions)) {
-                    return item.transactions.some((transaction) => transaction?.transactionID === newID);
-                }
-            }
-
-            return false;
-        });
-
-        // Early return if the new item is not found in the data array
-        if (indexOfNewItem <= 0) {
-            return;
-        }
-
-        // Perform the scrolling action
-        ref.scrollToIndex(indexOfNewItem);
-        // Reset the trigger flag to prevent unintended future scrolls and highlights
-        triggeredByHookRef.current = false;
-    };
-
-    const hasQueuedHighlights = newSearchResultKeys !== null && newSearchResultKeys.size > 0;
-
-    return {newSearchResultKeys, handleSelectionListScroll, newTransactions, hasQueuedHighlights};
-}
-
-/**
- * Helper function to extract transaction IDs from search results data.
- */
-function extractTransactionIDsFromSearchResults(searchResultsData: Partial<SearchResults['data']>): string[] {
-    const transactionIDs: string[] = [];
-
-    for (const item of Object.values(searchResultsData)) {
-        // Check for transactionID directly on the item (TransactionListItemType)
-        if ((item as TransactionListItemType)?.transactionID) {
-            transactionIDs.push((item as TransactionListItemType).transactionID);
-        }
-
-        // Check for transactions array within the item (TransactionGroupListItemType)
-        if (Array.isArray((item as TransactionGroupListItemType)?.transactions)) {
-            for (const transaction of (item as TransactionGroupListItemType).transactions) {
-                if (!transaction?.transactionID) {
-                    continue;
-                }
-                transactionIDs.push(transaction.transactionID);
-            }
-        }
-    }
-
-    return transactionIDs;
-}
-
-/**
- * Helper function to extract report action IDs from search results data.
- */
-function extractReportActionIDsFromSearchResults(searchResultsData: Partial<SearchResults['data']>): string[] {
-    return Object.keys(searchResultsData ?? {})
-        .filter(isReportActionEntry)
-        .map((key) => Object.keys(searchResultsData[key] ?? {}))
-        .flat();
-}
-
-export default useSearchHighlightAndScroll;
-export type {UseSearchHighlightAndScroll};
diff --git a/src/languages/de.ts b/src/languages/de.ts
index 5a9861434563..ae4241d6c78a 100644
--- a/src/languages/de.ts
+++ b/src/languages/de.ts
@@ -1205,6 +1205,8 @@ const translations: TranslationDeepObject<typeof en> = {
     },
     iou: {
         amount: 'Betrag',
+        expenseAdded: 'Ausgabe hinzugefügt',
+        invoiceSent: 'Rechnung gesendet',
         percent: 'Prozent',
         date: 'Datum',
         taxAmount: 'Steuerbetrag',
diff --git a/src/languages/en.ts b/src/languages/en.ts
index b737efa1a55b..d3f148754b32 100644
--- a/src/languages/en.ts
+++ b/src/languages/en.ts
@@ -1269,6 +1269,8 @@ const translations = {
     },
     iou: {
         amount: 'Amount',
+        expenseAdded: 'Expense added',
+        invoiceSent: 'Invoice sent',
         percent: 'Percent',
         date: 'Date',
         taxAmount: 'Tax amount',
diff --git a/src/languages/es.ts b/src/languages/es.ts
index e34c3b9a72b8..902d1ab6ef11 100644
--- a/src/languages/es.ts
+++ b/src/languages/es.ts
@@ -1170,6 +1170,8 @@ const translations: TranslationDeepObject<typeof en> = {
     },
     iou: {
         amount: 'Importe',
+        expenseAdded: 'Gasto añadido',
+        invoiceSent: 'Factura enviada',
         percent: 'Porcentaje',
         date: 'Fecha',
         taxAmount: 'Importe del impuesto',
diff --git a/src/languages/fr.ts b/src/languages/fr.ts
index 5999f8920e92..adb36a0af95f 100644
--- a/src/languages/fr.ts
+++ b/src/languages/fr.ts
@@ -1209,6 +1209,8 @@ const translations: TranslationDeepObject<typeof en> = {
     },
     iou: {
         amount: 'Montant',
+        expenseAdded: 'Dépense ajoutée',
+        invoiceSent: 'Facture envoyée',
         percent: 'Pourcentage',
         date: 'Date',
         taxAmount: 'Montant de la taxe',
diff --git a/src/languages/it.ts b/src/languages/it.ts
index dd516f9289ac..a2693a1475ca 100644
--- a/src/languages/it.ts
+++ b/src/languages/it.ts
@@ -1205,6 +1205,8 @@ const translations: TranslationDeepObject<typeof en> = {
     },
     iou: {
         amount: 'Importo',
+        expenseAdded: 'Spesa aggiunta',
+        invoiceSent: 'Fattura inviata',
         percent: 'Percentuale',
         date: 'Data',
         taxAmount: 'Importo imposta',
diff --git a/src/languages/ja.ts b/src/languages/ja.ts
index ca4a804b867e..2859bf94be70 100644
--- a/src/languages/ja.ts
+++ b/src/languages/ja.ts
@@ -1191,6 +1191,8 @@ const translations: TranslationDeepObject<typeof en> = {
     },
     iou: {
         amount: '金額',
+        expenseAdded: '経費を追加しました',
+        invoiceSent: '請求書を送信しました',
         percent: 'パーセント',
         date: '日付',
         taxAmount: '税額',
diff --git a/src/languages/nl.ts b/src/languages/nl.ts
index 96df64019b0d..e4f867be4408 100644
--- a/src/languages/nl.ts
+++ b/src/languages/nl.ts
@@ -1203,6 +1203,8 @@ const translations: TranslationDeepObject<typeof en> = {
     },
     iou: {
         amount: 'Bedrag',
+        expenseAdded: 'Uitgave toegevoegd',
+        invoiceSent: 'Factuur verzonden',
         percent: 'Procent',
         date: 'Datum',
         taxAmount: 'Belastingbedrag',
diff --git a/src/languages/pl.ts b/src/languages/pl.ts
index 16ec1bed0b22..3951071ee17d 100644
--- a/src/languages/pl.ts
+++ b/src/languages/pl.ts
@@ -1203,6 +1203,8 @@ const translations: TranslationDeepObject<typeof en> = {
     },
     iou: {
         amount: 'Kwota',
+        expenseAdded: 'Dodano wydatek',
+        invoiceSent: 'Wysłano fakturę',
         percent: 'Procent',
         date: 'Data',
         taxAmount: 'Kwota podatku',
diff --git a/src/languages/pt-BR.ts b/src/languages/pt-BR.ts
index 17097c5f2d2a..0cdd38d575f4 100644
--- a/src/languages/pt-BR.ts
+++ b/src/languages/pt-BR.ts
@@ -1203,6 +1203,8 @@ const translations: TranslationDeepObject<typeof en> = {
     },
     iou: {
         amount: 'Valor',
+        expenseAdded: 'Despesa adicionada',
+        invoiceSent: 'Fatura enviada',
         percent: 'Porcentagem',
         date: 'Data',
         taxAmount: 'Valor do imposto',
diff --git a/src/languages/zh-hans.ts b/src/languages/zh-hans.ts
index 76b94d5deb48..5be44a670606 100644
--- a/src/languages/zh-hans.ts
+++ b/src/languages/zh-hans.ts
@@ -1160,6 +1160,8 @@ const translations: TranslationDeepObject<typeof en> = {
     },
     iou: {
         amount: '金额',
+        expenseAdded: '已添加支出',
+        invoiceSent: '已发送发票',
         percent: '百分比',
         date: '日期',
         taxAmount: '税额',
diff --git a/src/libs/Growl.ts b/src/libs/Growl.ts
index 3812a155ba1f..112ecdd717a6 100644
--- a/src/libs/Growl.ts
+++ b/src/libs/Growl.ts
@@ -1,8 +1,16 @@
 import React from 'react';
 import CONST from '@src/CONST';
 
+type GrowlAction = {
+    label: string;
+    onPress: () => void;
+};
+
+/** The set of growl variants the notification UI knows how to render. */
+type GrowlType = typeof CONST.GROWL.SUCCESS | typeof CONST.GROWL.ERROR | typeof CONST.GROWL.WARNING | typeof CONST.GROWL.LOADING;
+
 type GrowlRef = {
-    show?: (bodyText: string, type: string, duration: number) => void;
+    show?: (bodyText: string, type: GrowlType, duration: number, action?: GrowlAction) => void;
 };
 
 const growlRef = React.createRef<GrowlRef>();
@@ -21,12 +29,12 @@ function setIsReady() {
 /**
  * Show the growl notification
  */
-function show(bodyText: string, type: string, duration: number = CONST.GROWL.DURATION) {
+function show(bodyText: string, type: GrowlType, duration: number = CONST.GROWL.DURATION, action?: GrowlAction) {
     isReadyPromise.then(() => {
         if (!growlRef?.current?.show) {
             return;
         }
-        growlRef.current.show(bodyText, type, duration);
+        growlRef.current.show(bodyText, type, duration, action);
     });
 }
 
@@ -40,16 +48,24 @@ function error(bodyText: string, duration: number = CONST.GROWL.DURATION) {
 /**
  * Show success growl
  */
-function success(bodyText: string, duration: number = CONST.GROWL.DURATION) {
-    show(bodyText, CONST.GROWL.SUCCESS, duration);
+function success(bodyText: string, duration: number = CONST.GROWL.DURATION, action?: GrowlAction) {
+    show(bodyText, CONST.GROWL.SUCCESS, duration, action);
+}
+
+/**
+ * Show indefinite loading growl (no auto-dismiss). Call success/error/show again to replace it.
+ */
+function loading(bodyText: string) {
+    show(bodyText, CONST.GROWL.LOADING, 0);
 }
 
 export default {
     show,
     error,
     success,
+    loading,
 };
 
-export type {GrowlRef};
+export type {GrowlRef, GrowlAction, GrowlType};
 
 export {growlRef, setIsReady};
diff --git a/src/libs/Navigation/helpers/cleanupAfterSkipConfirmSubmit.ts b/src/libs/Navigation/helpers/cleanupAfterSkipConfirmSubmit.ts
index 65224064cb68..a01b95a3a292 100644
--- a/src/libs/Navigation/helpers/cleanupAfterSkipConfirmSubmit.ts
+++ b/src/libs/Navigation/helpers/cleanupAfterSkipConfirmSubmit.ts
@@ -1,16 +1,13 @@
 import cleanupAfterExpenseCreate from './cleanupAfterExpenseCreate';
-import cleanupAndNavigateAfterExpenseCreate from './cleanupAndNavigateAfterExpenseCreate';
 import type {CleanupAndNavigateAfterExpenseCreateParams} from './cleanupAndNavigateAfterExpenseCreate';
 
 /**
- * Skip-confirmation cleanup dispatcher: `shouldHandleNavigation` (from `submitWithDismissFirst`) picks
- * cleanup-only vs cleanup-and-navigate. The skip-confirm analog of `useExpenseSubmission`'s `performPostBatchCleanup`.
+ * Cleanup-only after a skip-confirmation submit. The skip-confirm analog of `useExpenseSubmission`'s
+ * `performPostBatchCleanup`: the write action now owns post-creation navigation (via its own
+ * `shouldHandleNavigation`), so cleanup must never navigate too or the fallback path would run
+ * navigation/growl twice. Navigation on dismiss-first paths is done by `submitWithDismissFirst`.
  */
-function cleanupAfterSkipConfirmSubmit(shouldHandleNavigation: boolean, params: CleanupAndNavigateAfterExpenseCreateParams) {
-    if (shouldHandleNavigation) {
-        cleanupAndNavigateAfterExpenseCreate(params);
-        return;
-    }
+function cleanupAfterSkipConfirmSubmit(params: CleanupAndNavigateAfterExpenseCreateParams) {
     cleanupAfterExpenseCreate({draftTransactionIDs: params.draftTransactionIDs, linkedTrackedExpenseReportAction: params.linkedTrackedExpenseReportAction});
 }
 
diff --git a/src/libs/Navigation/helpers/navigateAfterExpenseCreate.ts b/src/libs/Navigation/helpers/navigateAfterExpenseCreate.ts
index 8a991dbfe6df..7482f7970e37 100644
--- a/src/libs/Navigation/helpers/navigateAfterExpenseCreate.ts
+++ b/src/libs/Navigation/helpers/navigateAfterExpenseCreate.ts
@@ -1,21 +1,70 @@
+import Onyx from 'react-native-onyx';
+import type {OnyxCollection} from 'react-native-onyx';
 import {addPendingNewTransactionIDs} from '@libs/actions/IOU/PendingNewTransactions';
+import {createTransactionThreadReport, setOptimisticTransactionThread} from '@libs/actions/Report';
+import {setActiveTransactionIDs} from '@libs/actions/TransactionThreadNavigation';
 import getIsNarrowLayout from '@libs/getIsNarrowLayout';
+import Growl from '@libs/Growl';
+import {translateLocal} from '@libs/Localize';
 import Log from '@libs/Log';
 import {getPreservedNavigatorState} from '@libs/Navigation/AppNavigator/createSplitNavigator/usePreserveNavigatorState';
 import Navigation, {navigationRef} from '@libs/Navigation/Navigation';
+import {getIOUActionForReportID} from '@libs/ReportActionsUtils';
+import {getReportOrDraftReport} from '@libs/ReportUtils';
 import {buildCannedSearchQuery, getCurrentSearchQueryJSON} from '@libs/SearchQueryUtils';
 import {setPendingSubmitFollowUpAction} from '@libs/telemetry/submitFollowUpAction';
 import CONST from '@src/CONST';
 import NAVIGATORS from '@src/NAVIGATORS';
+import ONYXKEYS from '@src/ONYXKEYS';
 import ROUTES from '@src/ROUTES';
 import SCREENS from '@src/SCREENS';
+import type {Beta, IntroSelected, Transaction} from '@src/types/onyx';
 import dismissModalAndOpenReportInInboxTab from './dismissModalAndOpenReportInInboxTab';
+import getTopmostFullScreenRoute from './getTopmostFullScreenRoute';
 import isReportTopmostSplitNavigator from './isReportTopmostSplitNavigator';
 import isSearchTopmostFullScreenRoute from './isSearchTopmostFullScreenRoute';
+import setNavigationActionToMicrotaskQueue from './setNavigationActionToMicrotaskQueue';
+
+let currentUserEmail = '';
+let currentUserAccountID: number = CONST.DEFAULT_NUMBER_ID;
+Onyx.connectWithoutView({
+    key: ONYXKEYS.SESSION,
+    callback: (value) => {
+        currentUserEmail = value?.email ?? '';
+        currentUserAccountID = value?.accountID ?? CONST.DEFAULT_NUMBER_ID;
+    },
+});
+
+let introSelected: IntroSelected | undefined;
+Onyx.connectWithoutView({
+    key: ONYXKEYS.NVP_INTRO_SELECTED,
+    callback: (value) => {
+        introSelected = value ?? undefined;
+    },
+});
+
+let betas: Beta[] | undefined;
+Onyx.connectWithoutView({
+    key: ONYXKEYS.BETAS,
+    callback: (value) => {
+        betas = value ?? undefined;
+    },
+});
+
+let allTransactions: OnyxCollection<Transaction>;
+Onyx.connectWithoutView({
+    key: ONYXKEYS.COLLECTION.TRANSACTION,
+    waitForCollectionCallback: true,
+    callback: (transactions) => {
+        allTransactions = transactions;
+    },
+});
 
 type NavigateAfterExpenseCreateParams = {
     activeReportID?: string;
+    iouReportID?: string;
     transactionID?: string;
+    transactionThreadReportID?: string;
     isFromGlobalCreate?: boolean;
     isInvoice?: boolean;
     hasMultipleTransactions: boolean;
@@ -23,12 +72,194 @@ type NavigateAfterExpenseCreateParams = {
     shouldNavigate?: boolean;
 };
 
-function getNavigateAfterCreateSearchNavigatorState() {
-    const rootState = navigationRef.getRootState();
-    const tabNavigatorRoute = rootState?.routes?.findLast((route) => route.name === NAVIGATORS.TAB_NAVIGATOR);
-    const tabState = tabNavigatorRoute?.state ?? (tabNavigatorRoute?.key ? getPreservedNavigatorState(tabNavigatorRoute.key) : undefined);
-    const searchNavigatorRoute = tabState?.routes?.findLast((route) => route.name === NAVIGATORS.SEARCH_FULLSCREEN_NAVIGATOR);
-    return searchNavigatorRoute?.state ?? (searchNavigatorRoute?.key ? getPreservedNavigatorState(searchNavigatorRoute.key) : undefined);
+type ShowExpenseAddedGrowlParams = {
+    iouReportID?: string;
+    transactionID?: string;
+    transactionThreadReportID?: string;
+
+    /**
+     * Whether the growl was shown in the Inbox context. When omitted (dismiss-first orchestrator
+     * paths that don't know where the user lands), the context is resolved at "View" press time.
+     */
+    isInbox?: boolean;
+
+    /** Whether this confirmation is for an invoice (changes the toast copy from "Expense added"). */
+    isInvoice?: boolean;
+};
+
+/**
+ * Shows the "Expense added" growl with a "View" action that deep-links to the new expense's RHP.
+ *
+ * The IOU action's optimistic data is typically not yet in the Onyx cache when this runs — the
+ * `API.write` is deferred (deferred-for-search pattern) until Search's content layout flushes the
+ * channel. We subscribe to the iouReport's reportActions and wait for the optimistic iouAction
+ * to land, then build the thread + show the growl. A safety timeout falls back to a growl
+ * without the "View" link if the iouAction never appears.
+ */
+function showExpenseAddedGrowl({iouReportID, transactionID, transactionThreadReportID: providedTransactionThreadReportID, isInbox, isInvoice}: ShowExpenseAddedGrowlParams) {
+    if (!transactionID) {
+        return;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated -- imperative module (not a React component); no useLocalize hook available here
+    const growlMessage = isInvoice ? translateLocal('iou.invoiceSent') : translateLocal('iou.expenseAdded');
+
+    const buildThreadFromOnyx = (): string | undefined => {
+        const iouReport = iouReportID ? getReportOrDraftReport(iouReportID) : undefined;
+        const iouAction = iouReportID ? getIOUActionForReportID(iouReportID, transactionID) : undefined;
+        let threadReportID = providedTransactionThreadReportID ?? iouAction?.childReportID;
+        if (!threadReportID) {
+            const transaction = allTransactions?.[`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`];
+            const optimisticThread = createTransactionThreadReport({
+                introSelected,
+                currentUserLogin: currentUserEmail,
+                currentUserAccountID,
+                betas,
+                iouReport,
+                iouReportAction: iouAction,
+                transaction,
+            });
+            threadReportID = optimisticThread?.reportID;
+        } else {
+            setOptimisticTransactionThread(threadReportID, iouReport?.reportID, iouAction?.reportActionID, iouReport?.policyID);
+        }
+        return threadReportID;
+    };
+
+    const showGrowl = (threadReportID: string | undefined) => {
+        if (!threadReportID) {
+            Log.warn('[showExpenseAddedGrowl] Unable to resolve transaction thread reportID; growl without View.');
+            Growl.success(growlMessage, CONST.GROWL.DURATION_LONG);
+            return;
+        }
+        const resolvedThreadReportID = threadReportID;
+        const navigateToExpenseRHP = () => {
+            const backTo = Navigation.getActiveRoute();
+            // The explicit flag wins (set when the growl's origin context is known). Otherwise
+            // (dismiss-first orchestrator paths) resolve the context at press time.
+            const openOnInbox = isInbox ?? (isReportTopmostSplitNavigator() && !isSearchTopmostFullScreenRoute());
+
+            if (!openOnInbox) {
+                // Spend context: open the transaction thread RHP within Search (the report is shown
+                // underneath via the Wide RHP machinery).
+                setActiveTransactionIDs([transactionID]).then(() => {
+                    Navigation.navigate(ROUTES.SEARCH_REPORT.getRoute({reportID: resolvedThreadReportID, backTo}));
+                });
+                return;
+            }
+
+            // Inbox + narrow layout: super wide RHP is unavailable, so open the transaction thread
+            // as a full report view (matches MoneyRequestReportPreview's narrow-screen behavior).
+            if (getIsNarrowLayout()) {
+                Navigation.navigate(ROUTES.REPORT_WITH_ID.getRoute(resolvedThreadReportID, undefined, undefined, backTo));
+                return;
+            }
+
+            // Inbox + wide layout. A report with multiple transactions opens in a super wide RHP, so
+            // we open the expense report underneath and stack the transaction thread RHP on top of it -
+            // the super wide RHP keeps both visible as one cohesive surface. A single-transaction report
+            // does NOT use the super wide RHP (see SearchMoneyRequestReportPage's `shouldShowSuperWideRHP`),
+            // so stacking would surface as two separate RHP panels (RHP appears to open twice). In that
+            // case navigate straight to the transaction thread instead; the report still shows underneath
+            // via the Wide RHP machinery, matching the Spend-context path above.
+            const hasMultipleReportTransactions =
+                Object.values(allTransactions ?? {}).filter(
+                    (transaction) => transaction?.reportID === iouReportID && transaction?.pendingAction !== CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE,
+                ).length > 1;
+
+            if (iouReportID && hasMultipleReportTransactions) {
+                Navigation.navigate(ROUTES.EXPENSE_REPORT_RHP.getRoute({reportID: iouReportID, backTo}));
+            }
+            setNavigationActionToMicrotaskQueue(() => {
+                setActiveTransactionIDs([transactionID]).then(() => {
+                    Navigation.navigate(ROUTES.SEARCH_REPORT.getRoute({reportID: resolvedThreadReportID, backTo: Navigation.getActiveRoute()}));
+                });
+            });
+        };
+        // eslint-disable-next-line @typescript-eslint/no-deprecated -- imperative module (not a React component); no useLocalize hook available here
+        Growl.success(growlMessage, CONST.GROWL.DURATION_WITH_ACTION, {label: translateLocal('common.view'), onPress: navigateToExpenseRHP});
+    };
+
+    // Fast path: the thread is already resolvable, so show the growl immediately instead of waiting on
+    // the reportActions subscription (which would otherwise hit the 8s safety timeout). This covers:
+    // - personal tracked expenses (unreported/self-DM): there's no iouReportID, but the thread ID is
+    //   passed in directly, so we can build from it right away;
+    // - the iouAction already being in Onyx (retry / non-deferred edge cases).
+    if (providedTransactionThreadReportID || (iouReportID && getIOUActionForReportID(iouReportID, transactionID)?.reportActionID)) {
+        const threadReportID = buildThreadFromOnyx();
+        showGrowl(threadReportID);
+        return;
+    }
+
+    // No iouReportID to subscribe to (and no thread ID was passed): the reportActions key would be
+    // `reportActions_undefined` and the callback below early-returns on `!iouReportID` forever, so the
+    // subscription can never resolve and would only fire via the 8s timeout. Resolve immediately with
+    // the same fallback the timeout would produce (a growl without "View" when no thread is resolvable).
+    if (!iouReportID) {
+        showGrowl(buildThreadFromOnyx());
+        return;
+    }
+
+    // Slow path: wait for Search to render → flushDeferredWrite('search') → API.write applies
+    // optimistic data → iouAction lands → we show the growl.
+    const SAFETY_TIMEOUT_MS = 8000;
+    let resolved = false;
+    const reportActionsKey = `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${iouReportID}` as const;
+    const connectionId = Onyx.connectWithoutView({
+        key: reportActionsKey,
+        callback: () => {
+            if (resolved || !iouReportID) {
+                return;
+            }
+            const iouAction = getIOUActionForReportID(iouReportID, transactionID);
+            if (!iouAction?.reportActionID) {
+                return;
+            }
+            resolved = true;
+            Onyx.disconnect(connectionId);
+            const threadReportID = buildThreadFromOnyx();
+            showGrowl(threadReportID);
+        },
+    });
+
+    setTimeout(() => {
+        if (resolved) {
+            return;
+        }
+        resolved = true;
+        Onyx.disconnect(connectionId);
+        const threadReportID = buildThreadFromOnyx();
+        showGrowl(threadReportID);
+    }, SAFETY_TIMEOUT_MS);
+}
+
+type SurfaceExpenseCreatedFeedbackParams = {
+    iouReportID?: string;
+    transactionID?: string;
+    transactionThreadReportID?: string;
+
+    /**
+     * Whether the expense was added from within its own expense report (i.e. the report table is the
+     * surface in front of the user). When true we highlight the new row instead of showing a growl.
+     */
+    isMoneyRequestReport?: boolean;
+
+    /** Whether this is an invoice (changes the growl copy). */
+    isInvoice?: boolean;
+};
+
+/**
+ * Surfaces post-create feedback when navigation is owned elsewhere (the dismiss-first orchestrator) or
+ * isn't needed. Single decision point shared by every expense type:
+ * - if the user is looking at the expense report's table (in-report add) → highlight the new row;
+ * - otherwise → show the "Expense added" growl with a "View" deep link.
+ */
+function surfaceExpenseCreatedFeedback({iouReportID, transactionID, transactionThreadReportID, isMoneyRequestReport, isInvoice}: SurfaceExpenseCreatedFeedbackParams) {
+    if (isMoneyRequestReport && iouReportID && transactionID) {
+        addPendingNewTransactionIDs(iouReportID, transactionID);
+        return;
+    }
+    showExpenseAddedGrowl({iouReportID, transactionID, transactionThreadReportID, isInvoice});
 }
 
 /**
@@ -40,63 +271,101 @@ function getNavigateAfterCreateSearchNavigatorState() {
  */
 function navigateAfterExpenseCreate({
     activeReportID,
+
+    iouReportID,
     transactionID,
+    transactionThreadReportID: providedTransactionThreadReportID,
+
     isFromGlobalCreate,
+
     isInvoice,
+
     hasMultipleTransactions,
     shouldAddPendingNewTransactionIDs = false,
     shouldNavigate = true,
 }: NavigateAfterExpenseCreateParams) {
     const isUserOnInbox = isReportTopmostSplitNavigator();
+    const isUserOnSpend = isSearchTopmostFullScreenRoute();
+
+    // If the expense is not created from global create or there is no transaction to link,
+    // we just need to dismiss the money request flow screens and open the report chat
+    // containing the IOU report. No growl is shown in this case.
+    if (!isFromGlobalCreate || !transactionID) {
+        if (shouldNavigate) {
+            dismissModalAndOpenReportInInboxTab(activeReportID, isInvoice, hasMultipleTransactions);
+        }
+        if (shouldAddPendingNewTransactionIDs) {
+            addPendingNewTransactionIDs(activeReportID, transactionID);
+        }
+        return;
+    }
 
-    // If the expense is not created from global create or is currently on the inbox tab,
-    // we just need to dismiss the money request flow screens
-    // and open the report chat containing the IOU report
-    if (!isFromGlobalCreate || isUserOnInbox || !transactionID) {
+    // From global create on the Inbox tab: stay on Inbox (dismiss the flow and open the report
+    // chat containing the IOU report) and show the "Expense added" growl on top of it. We don't
+    // redirect to Spend here - the growl just shows.
+    if (isUserOnInbox) {
         if (shouldNavigate) {
             dismissModalAndOpenReportInInboxTab(activeReportID, isInvoice, hasMultipleTransactions);
         }
         if (shouldAddPendingNewTransactionIDs) {
             addPendingNewTransactionIDs(activeReportID, transactionID);
         }
+        showExpenseAddedGrowl({iouReportID, transactionID, transactionThreadReportID: providedTransactionThreadReportID, isInbox: true, isInvoice});
         return;
     }
 
+    // The caller owns navigation in this case, so skip redirecting to Search.
     if (!shouldNavigate) {
         return;
     }
 
     const type = isInvoice ? CONST.SEARCH.DATA_TYPES.INVOICE : CONST.SEARCH.DATA_TYPES.EXPENSE;
 
-    // When already on Search ROOT with the same type (expense vs invoice), we navigate to the same screen (no-op or refresh); record as dismiss_modal_only.
-    // When on another Search sub-tab (e.g. Chats), or on Search with a different type (e.g. on Invoice, submitting expense), record as navigate_to_search.
-    const searchNavigatorState = getNavigateAfterCreateSearchNavigatorState();
+    // POC variant B: navigate to Search (if not already there), then show the "View" growl on
+    // Search once the optimistic IOU action lands in Onyx. Runs whether or not the user is
+    // already on Spend — on the SEARCH_PRE_INSERT fast path the orchestrator pre-inserts Search
+    // and dismisses the modal before createTransaction runs, so by the time we get here the user
+    // is already on Search (isUserOnSpend=true). The growl must still fire in that case.
+    //
+    // Why this works without an explicit deferred-write flush: Search's content onLayout callback
+    // calls flushDeferredWrite('search') as soon as the actual list (not the skeleton) renders.
+    // That fires API.write, which applies optimistic data → our reportActions subscription fires
+    // → we have a valid iouAction to build the thread from → show growl with working "View" link.
+    const queryString = buildCannedSearchQuery({type});
+    // SEARCH_FULLSCREEN_NAVIGATOR is nested inside TAB_NAVIGATOR, not at the root, and its `state`
+    // can be undefined when the split navigator isn't actively rendered - so we resolve it via the
+    // same TAB_NAVIGATOR traversal isSearchTopmostFullScreenRoute uses, then fall back to the
+    // preserved navigator state for the search navigator's own inner routes.
+    const searchNavigatorRoute = isUserOnSpend ? getTopmostFullScreenRoute() : undefined;
+    const searchNavigatorState = searchNavigatorRoute?.state ?? (searchNavigatorRoute?.key ? getPreservedNavigatorState(searchNavigatorRoute.key) : undefined);
     const lastSearchRoute = searchNavigatorState?.routes?.at(-1);
-    const isSearchTopmost = isSearchTopmostFullScreenRoute();
-    const alreadyOnSearchRoot = isSearchTopmost && lastSearchRoute?.name === SCREENS.SEARCH.ROOT;
+    const alreadyOnSearchRoot = isUserOnSpend && lastSearchRoute?.name === SCREENS.SEARCH.ROOT;
     const currentSearchQueryJSON = alreadyOnSearchRoot ? getCurrentSearchQueryJSON() : undefined;
     const isSameSearchType = currentSearchQueryJSON?.type === type;
-    const followUpAction = alreadyOnSearchRoot && isSameSearchType ? CONST.TELEMETRY.SUBMIT_FOLLOW_UP_ACTION.DISMISS_MODAL_ONLY : CONST.TELEMETRY.SUBMIT_FOLLOW_UP_ACTION.NAVIGATE_TO_SEARCH;
-    setPendingSubmitFollowUpAction(followUpAction);
 
-    const queryString = buildCannedSearchQuery({type});
+    setPendingSubmitFollowUpAction(
+        alreadyOnSearchRoot && isSameSearchType ? CONST.TELEMETRY.SUBMIT_FOLLOW_UP_ACTION.DISMISS_MODAL_ONLY : CONST.TELEMETRY.SUBMIT_FOLLOW_UP_ACTION.NAVIGATE_TO_SEARCH,
+    );
+
     const navigateToSearch = () => {
-        // On the fast path, onConfirm already cleared the flag and dismissed the modal,
-        // so this branch is only reached on the slow path (user submitted before the
-        // 300ms pre-insert timer fired).
-        if (getIsNarrowLayout() && Navigation.getIsFullscreenPreInsertedUnderRHP()) {
+        const isNarrow = getIsNarrowLayout();
+        const isFullscreenPreInserted = Navigation.getIsFullscreenPreInsertedUnderRHP();
+        if (isNarrow && isFullscreenPreInserted) {
             Navigation.clearFullscreenPreInsertedFlag();
             Navigation.dismissModal();
-        } else if (getIsNarrowLayout()) {
+            return;
+        }
+        if (isNarrow) {
             const isRHPStillOnTop = navigationRef.getRootState()?.routes?.at(-1)?.name === NAVIGATORS.RIGHT_MODAL_NAVIGATOR;
             if (!alreadyOnSearchRoot || !isSameSearchType || isRHPStillOnTop) {
                 Navigation.navigate(ROUTES.SEARCH_ROOT.getRoute({query: queryString}), {forceReplace: true});
-            } else {
-                Log.info('[IOU] navigateToSearch: already on matching Search root with RHP dismissed - no-op');
             }
-        } else {
-            Navigation.revealRouteBeforeDismissingModal(ROUTES.SEARCH_ROOT.getRoute({query: queryString}));
+            return;
         }
+        if (alreadyOnSearchRoot && isSameSearchType) {
+            return;
+        }
+        Navigation.revealRouteBeforeDismissingModal(ROUTES.SEARCH_ROOT.getRoute({query: queryString}));
     };
 
     if (navigationRef.isReady()) {
@@ -104,6 +373,9 @@ function navigateAfterExpenseCreate({
     } else {
         Navigation.isNavigationReady().then(navigateToSearch);
     }
+
+    showExpenseAddedGrowl({iouReportID, transactionID, transactionThreadReportID: providedTransactionThreadReportID, isInbox: false, isInvoice});
 }
 
 export default navigateAfterExpenseCreate;
+export {surfaceExpenseCreatedFeedback};
diff --git a/src/libs/actions/IOU/MoneyRequest.ts b/src/libs/actions/IOU/MoneyRequest.ts
index fdf35f90b133..436f85381f7d 100644
--- a/src/libs/actions/IOU/MoneyRequest.ts
+++ b/src/libs/actions/IOU/MoneyRequest.ts
@@ -84,6 +84,8 @@ type CreateTransactionParams = {
     optimisticTransactionIDs: string[];
     optimisticChatReportID: string | undefined;
     currentUserLocalCurrency: string | undefined;
+    /** Whether the created action should own post-creation navigation. Skip-confirm orchestrators that dismiss/reveal first pass `false` so navigation isn't run twice. */
+    shouldHandleNavigation?: boolean;
 };
 
 function createTransaction({
@@ -112,6 +114,7 @@ function createTransaction({
     optimisticTransactionIDs,
     optimisticChatReportID,
     currentUserLocalCurrency,
+    shouldHandleNavigation = true,
 }: CreateTransactionParams) {
     const draftTransactionIDs = Object.keys(allTransactionDrafts ?? {});
 
@@ -159,6 +162,7 @@ function createTransaction({
                 optimisticChatReportID,
                 optimisticTransactionID,
                 currentUserLocalCurrency,
+                shouldHandleNavigation,
             });
         } else {
             const existingTransactionID = getExistingTransactionID(transaction?.linkedTrackedExpenseReportAction);
@@ -201,6 +205,7 @@ function createTransaction({
                 personalDetails,
                 optimisticChatReportID,
                 optimisticTransactionID,
+                shouldHandleNavigation,
             });
         }
     }
diff --git a/src/libs/actions/IOU/MoneyRequestBuilder.ts b/src/libs/actions/IOU/MoneyRequestBuilder.ts
index dee1d57cab96..b37ee7c73351 100644
--- a/src/libs/actions/IOU/MoneyRequestBuilder.ts
+++ b/src/libs/actions/IOU/MoneyRequestBuilder.ts
@@ -158,6 +158,15 @@ type RequestMoneyInformation = {
     transactionParams: RequestMoneyTransactionParams;
     isRetry?: boolean;
     shouldPlaySound?: boolean;
+    shouldHandleNavigation?: boolean;
+    /**
+     * When a confirmation submits several transactions, the orchestrator calls this action once per
+     * transaction in a loop. Post-create navigation + the "Expense added" growl are owned by the
+     * action, so they must fire only once - for the final transaction of the batch. Defaults to true
+     * so single-transaction callers keep their existing behavior.
+     */
+    isLastTransactionOfBatch?: boolean;
+    backToReport?: string;
     /** Retry-path cleanup only; the action itself never reads this. */
     draftTransactionIDs?: string[];
     optimisticChatReportID?: string;
diff --git a/src/libs/actions/IOU/NavigationHelpers.ts b/src/libs/actions/IOU/NavigationHelpers.ts
index 7c763d5be509..04110c523f21 100644
--- a/src/libs/actions/IOU/NavigationHelpers.ts
+++ b/src/libs/actions/IOU/NavigationHelpers.ts
@@ -1,8 +1,5 @@
 import sharedDismissModalAndOpenReportInInboxTab from '@libs/Navigation/helpers/dismissModalAndOpenReportInInboxTab';
-import isReportTopmostSplitNavigator from '@libs/Navigation/helpers/isReportTopmostSplitNavigator';
 import navigateAfterExpenseCreate from '@libs/Navigation/helpers/navigateAfterExpenseCreate';
-import {mergeTransactionIdsHighlightOnSearchRoute} from '@userActions/Transaction';
-import type {SearchDataTypes} from '@src/types/onyx/SearchResults';
 import {getAllTransactions} from './index';
 
 /**
@@ -16,17 +13,6 @@ function dismissModalAndOpenReportInInboxTab(reportID?: string, isInvoice?: bool
     sharedDismissModalAndOpenReportInInboxTab(reportID, isInvoice, hasMultipleTransactions);
 }
 
-/**
- * Marks a transaction for highlight on the Search page when the expense was created
- * from the global create button and the user is not on the Inbox tab.
- */
-function highlightTransactionOnSearchRouteIfNeeded(isFromGlobalCreate: boolean | undefined, transactionID: string | undefined, dataType: SearchDataTypes) {
-    if (!isFromGlobalCreate || isReportTopmostSplitNavigator() || !transactionID) {
-        return;
-    }
-    mergeTransactionIdsHighlightOnSearchRoute(dataType, {[transactionID]: true});
-}
-
 /**
  * Helper to navigate after an expense is created in order to standardize the post‑creation experience
  * when creating an expense from the global create button.
@@ -36,21 +22,32 @@ function highlightTransactionOnSearchRouteIfNeeded(isFromGlobalCreate: boolean |
  */
 function handleNavigateAfterExpenseCreate({
     activeReportID,
+    iouReportID,
     transactionID,
+    transactionThreadReportID,
     isFromGlobalCreate,
     isInvoice,
     shouldAddPendingNewTransactionIDs = false,
-    shouldNavigate = true,
 }: {
     activeReportID?: string;
+    iouReportID?: string;
     transactionID?: string;
+    transactionThreadReportID?: string;
     isFromGlobalCreate?: boolean;
     isInvoice?: boolean;
     shouldAddPendingNewTransactionIDs?: boolean;
-    shouldNavigate?: boolean;
 }) {
     const hasMultipleTransactions = Object.values(getAllTransactions()).filter((transaction) => transaction?.reportID === activeReportID).length > 0;
-    navigateAfterExpenseCreate({activeReportID, transactionID, isFromGlobalCreate, isInvoice, hasMultipleTransactions, shouldAddPendingNewTransactionIDs, shouldNavigate});
+    navigateAfterExpenseCreate({
+        activeReportID,
+        iouReportID,
+        transactionID,
+        transactionThreadReportID,
+        isFromGlobalCreate,
+        isInvoice,
+        hasMultipleTransactions,
+        shouldAddPendingNewTransactionIDs,
+    });
 }
 
-export {dismissModalAndOpenReportInInboxTab, handleNavigateAfterExpenseCreate, highlightTransactionOnSearchRouteIfNeeded};
+export {dismissModalAndOpenReportInInboxTab, handleNavigateAfterExpenseCreate};
diff --git a/src/libs/actions/IOU/PerDiem.ts b/src/libs/actions/IOU/PerDiem.ts
index 1ee03152c5d3..3cc467ecba0f 100644
--- a/src/libs/actions/IOU/PerDiem.ts
+++ b/src/libs/actions/IOU/PerDiem.ts
@@ -56,7 +56,6 @@ import {
     mergePolicyRecentlyUsedCurrencies,
 } from './MoneyRequestBuilder';
 import type {MoneyRequestInformation} from './MoneyRequestBuilder';
-import {highlightTransactionOnSearchRouteIfNeeded} from './NavigationHelpers';
 import type BasePolicyParams from './types/BasePolicyParams';
 import type BaseTransactionParams from './types/BaseTransactionParams';
 import type RequestMoneyParticipantParams from './types/RequestMoneyParticipantParams';
@@ -911,7 +910,7 @@ function submitPerDiemExpense(submitPerDiemExpenseInformation: PerDiemExpenseInf
         optimisticTransactionID,
         delegateAccountID,
     } = submitPerDiemExpenseInformation;
-    const {currency, comment = '', category, tag, created, customUnit, attendees, isFromGlobalCreate} = transactionParams;
+    const {currency, comment = '', category, tag, created, customUnit, attendees} = transactionParams;
 
     if (
         isEmptyObject(policyParams.policy) ||
@@ -1018,13 +1017,11 @@ function submitPerDiemExpense(submitPerDiemExpenseInformation: PerDiemExpenseInf
 
     TransitionTracker.runAfterTransitions({callback: () => removeDraftTransaction(CONST.IOU.OPTIMISTIC_TRANSACTION_ID), waitForUpcomingTransition: true});
 
-    highlightTransactionOnSearchRouteIfNeeded(isFromGlobalCreate, transaction.transactionID, CONST.SEARCH.DATA_TYPES.EXPENSE);
-
     if (activeReportID) {
         notifyNewAction(activeReportID, undefined, participantParams.payeeAccountID === currentUserAccountIDParam);
     }
 
-    return {iouReport, transactionID: transaction.transactionID};
+    return {iouReport, transactionID: transaction.transactionID, transactionThreadReportID};
 }
 
 /**
diff --git a/src/libs/actions/IOU/SendInvoice.ts b/src/libs/actions/IOU/SendInvoice.ts
index 1c46da332183..118cd16bc566 100644
--- a/src/libs/actions/IOU/SendInvoice.ts
+++ b/src/libs/actions/IOU/SendInvoice.ts
@@ -9,6 +9,7 @@ import {getMicroSecondOnyxErrorWithTranslationKey} from '@libs/ErrorUtils';
 import {formatPhoneNumber} from '@libs/LocalePhoneNumber';
 import Log from '@libs/Log';
 import isReportTopmostSplitNavigator from '@libs/Navigation/helpers/isReportTopmostSplitNavigator';
+import {surfaceExpenseCreatedFeedback} from '@libs/Navigation/helpers/navigateAfterExpenseCreate';
 import TransitionTracker from '@libs/Navigation/TransitionTracker';
 import {getReportActionHtml, getReportActionText} from '@libs/ReportActionsUtils';
 import type {OptimisticChatReport, OptimisticCreatedReportAction, OptimisticIOUReportAction} from '@libs/ReportUtils';
@@ -36,7 +37,7 @@ import type {Receipt} from '@src/types/onyx/Transaction';
 import {isEmptyObject} from '@src/types/utils/EmptyObject';
 import {getAllPersonalDetails} from '.';
 import {getReceiptError, mergePolicyRecentlyUsedCategories, mergePolicyRecentlyUsedCurrencies} from './MoneyRequestBuilder';
-import {handleNavigateAfterExpenseCreate, highlightTransactionOnSearchRouteIfNeeded} from './NavigationHelpers';
+import {handleNavigateAfterExpenseCreate} from './NavigationHelpers';
 import {getSearchOnyxUpdate} from './SearchUpdate';
 import type BasePolicyParams from './types/BasePolicyParams';
 
@@ -812,17 +813,25 @@ function sendInvoice({
         onDeferred: () => addOptimization(CONST.TELEMETRY.SUBMIT_OPTIMIZATION.DEFERRED_WRITE),
     });
 
-    highlightTransactionOnSearchRouteIfNeeded(isFromGlobalCreate, transactionID, CONST.SEARCH.DATA_TYPES.INVOICE);
-
     if (shouldHandleNavigation) {
         TransitionTracker.runAfterTransitions({callback: () => removeDraftTransaction(CONST.IOU.OPTIMISTIC_TRANSACTION_ID), waitForUpcomingTransition: true});
         handleNavigateAfterExpenseCreate({
             activeReportID: invoiceRoom.reportID,
+            iouReportID: invoiceReportID,
             transactionID,
+            transactionThreadReportID,
             isFromGlobalCreate,
             isInvoice: true,
         });
     } else {
+        // Dismiss-first paths (orchestrator owns navigation); still surface feedback wherever the user
+        // lands. Invoices go to an invoice room (no expense-report table), so this resolves to the growl.
+        surfaceExpenseCreatedFeedback({
+            iouReportID: invoiceReportID,
+            transactionID,
+            transactionThreadReportID,
+            isInvoice: true,
+        });
         removeDraftTransaction(CONST.IOU.OPTIMISTIC_TRANSACTION_ID);
     }
 
diff --git a/src/libs/actions/IOU/Split.ts b/src/libs/actions/IOU/Split.ts
index efb600b186fd..bfff40661345 100644
--- a/src/libs/actions/IOU/Split.ts
+++ b/src/libs/actions/IOU/Split.ts
@@ -13,6 +13,7 @@ import {calculateAmount as calculateIOUAmount, updateIOUOwnerAndTotal} from '@li
 import {formatPhoneNumber} from '@libs/LocalePhoneNumber';
 import * as Localize from '@libs/Localize';
 import isReportTopmostSplitNavigator from '@libs/Navigation/helpers/isReportTopmostSplitNavigator';
+import {surfaceExpenseCreatedFeedback} from '@libs/Navigation/helpers/navigateAfterExpenseCreate';
 import Navigation from '@libs/Navigation/Navigation';
 import TransitionTracker from '@libs/Navigation/TransitionTracker';
 import {roundToTwoDecimalPlaces} from '@libs/NumberUtils';
@@ -33,7 +34,6 @@ import {
     getParsedComment,
     getReportNotificationPreference,
     getReportOrDraftReport,
-    getReportTransactions,
     getTransactionDetails,
     hasViolations as hasViolationsReportUtils,
     isExpenseReport,
@@ -77,8 +77,7 @@ import {
     mergePolicyRecentlyUsedCurrencies,
 } from './MoneyRequestBuilder';
 import type {BuildOnyxDataForMoneyRequestKeys, OneOnOneIOUReport} from './MoneyRequestBuilder';
-import {dismissModalAndOpenReportInInboxTab, handleNavigateAfterExpenseCreate, highlightTransactionOnSearchRouteIfNeeded} from './NavigationHelpers';
-import {isOneToTwoTransactionTransition} from './PendingNewTransactions';
+import {dismissModalAndOpenReportInInboxTab, handleNavigateAfterExpenseCreate} from './NavigationHelpers';
 import type BasePolicyParams from './types/BasePolicyParams';
 import type BaseTransactionParams from './types/BaseTransactionParams';
 
@@ -2179,8 +2178,6 @@ function createDistanceRequest(distanceRequestInformation: CreateDistanceRequest
         API.write(WRITE_COMMANDS.CREATE_DISTANCE_REQUEST, parameters, onyxData);
     };
 
-    const isOneToTwoTransition = isOneToTwoTransactionTransition(isMoneyRequestReport, getReportTransactions(moneyRequestReportID));
-
     deferOrExecuteWrite(apiWrite, {
         shouldDeferForSearch: shouldDeferForSearch || !!(shouldHandleNavigation && isFromGlobalCreate && !isReportTopmostSplitNavigator()),
         optimisticWatchKey: `${ONYXKEYS.COLLECTION.TRANSACTION}${parameters.transactionID}`,
@@ -2191,20 +2188,29 @@ function createDistanceRequest(distanceRequestInformation: CreateDistanceRequest
 
     if (shouldHandleNavigation) {
         TransitionTracker.runAfterTransitions({callback: () => removeDraftTransaction(CONST.IOU.OPTIMISTIC_TRANSACTION_ID), waitForUpcomingTransition: true});
-        highlightTransactionOnSearchRouteIfNeeded(isFromGlobalCreate, parameters.transactionID, CONST.SEARCH.DATA_TYPES.EXPENSE);
+        const navigationActiveReportID = backToReport ?? activeReportID;
+        handleNavigateAfterExpenseCreate({
+            activeReportID: navigationActiveReportID,
+
+            iouReportID: parameters.iouReportID,
+            isFromGlobalCreate,
+
+            transactionID: parameters.transactionID,
+            transactionThreadReportID: parameters.transactionThreadReportID,
+            shouldAddPendingNewTransactionIDs: isMoneyRequestReport,
+        });
     } else {
+        // Dismiss-first paths (orchestrator owns navigation). Surface feedback wherever the user lands:
+        // highlight the new row for in-report adds, otherwise the "Expense added" growl with "View".
+        surfaceExpenseCreatedFeedback({
+            iouReportID: parameters.iouReportID,
+            transactionID: parameters.transactionID,
+            transactionThreadReportID: parameters.transactionThreadReportID,
+            isMoneyRequestReport,
+        });
         removeDraftTransaction(CONST.IOU.OPTIMISTIC_TRANSACTION_ID);
     }
 
-    const navigationActiveReportID = backToReport ?? activeReportID;
-    handleNavigateAfterExpenseCreate({
-        activeReportID: navigationActiveReportID,
-        isFromGlobalCreate,
-        transactionID: parameters.transactionID,
-        shouldAddPendingNewTransactionIDs: isOneToTwoTransition || (shouldHandleNavigation && navigationActiveReportID === parameters.chatReportID),
-        shouldNavigate: shouldHandleNavigation,
-    });
-
     if (!isMoneyRequestReport) {
         notifyNewAction(activeReportID, undefined, true);
     }
diff --git a/src/libs/actions/IOU/TrackExpense.ts b/src/libs/actions/IOU/TrackExpense.ts
index bbb22e82c784..e677908a4afb 100644
--- a/src/libs/actions/IOU/TrackExpense.ts
+++ b/src/libs/actions/IOU/TrackExpense.ts
@@ -22,6 +22,7 @@ import {isMovingTransactionFromTrackExpense as isMovingTransactionFromTrackExpen
 import isFileUploadable from '@libs/isFileUploadable';
 import {formatPhoneNumber} from '@libs/LocalePhoneNumber';
 import Log from '@libs/Log';
+import {surfaceExpenseCreatedFeedback} from '@libs/Navigation/helpers/navigateAfterExpenseCreate';
 import Navigation from '@libs/Navigation/Navigation';
 import {roundToTwoDecimalPlaces} from '@libs/NumberUtils';
 import * as NumberUtils from '@libs/NumberUtils';
@@ -56,7 +57,6 @@ import {
     getParsedComment,
     getReportOrDraftReport,
     getReportRecipientAccountIDs,
-    getReportTransactions,
     isDraftReport,
     isHiddenForCurrentUser,
     isMoneyRequestReport as isMoneyRequestReportReportUtils,
@@ -108,8 +108,7 @@ import {deleteMoneyRequest, getCleanUpTransactionThreadReportOnyxData, getNaviga
 import {getAllReports, getAllTransactionDrafts, getAllTransactions, getAllTransactionViolations, getMoneyRequestPolicyTags} from './index';
 import {buildMinimalTransactionForFormula, getMoneyRequestInformation, getReceiptError, getReportPreviewAction, getTransactionWithPreservedLocalReceiptSource} from './MoneyRequestBuilder';
 import type {BuildOnyxDataForMoneyRequestKeys, RequestMoneyInformation} from './MoneyRequestBuilder';
-import {highlightTransactionOnSearchRouteIfNeeded} from './NavigationHelpers';
-import {addPendingNewTransactionIDs, isOneToTwoTransactionTransition} from './PendingNewTransactions';
+import {handleNavigateAfterExpenseCreate} from './NavigationHelpers';
 import type {ReplaceReceipt} from './Receipt';
 import {getSearchOnyxUpdate} from './SearchUpdate';
 import type {StartSplitBilActionParams} from './Split';
@@ -1621,6 +1620,9 @@ function requestMoney(requestMoneyInformation: RequestMoneyInformation): {iouRep
         gpsPoint,
         action,
         shouldPlaySound = true,
+        shouldHandleNavigation = true,
+        isLastTransactionOfBatch = true,
+        backToReport,
         optimisticChatReportID,
         optimisticCreatedReportActionID,
         optimisticIOUReportID,
@@ -1900,10 +1902,6 @@ function requestMoney(requestMoneyInformation: RequestMoneyInformation): {iouRep
         }
     }
 
-    if (isOneToTwoTransactionTransition(isMoneyRequestReport, getReportTransactions(moneyRequestReportID))) {
-        addPendingNewTransactionIDs(activeReportID, transaction.transactionID);
-    }
-
     if (deferredAPIWrite) {
         deferOrExecuteWrite(deferredAPIWrite, {
             shouldDeferForSearch: false,
@@ -1913,8 +1911,30 @@ function requestMoney(requestMoneyInformation: RequestMoneyInformation): {iouRep
         });
     }
 
-    if (!requestMoneyInformation.isRetry) {
-        highlightTransactionOnSearchRouteIfNeeded(isFromGlobalCreate, transaction.transactionID, CONST.SEARCH.DATA_TYPES.EXPENSE);
+    // Gate post-create navigation/growl to the final transaction of a multi-transaction batch so a
+    // multi-receipt submit fires a single dismiss/navigate and a single "Expense added" toast.
+    if (!requestMoneyInformation.isRetry && isLastTransactionOfBatch) {
+        if (shouldHandleNavigation) {
+            const navigationReportID = backToReport ?? activeReportID;
+            handleNavigateAfterExpenseCreate({
+                activeReportID: navigationReportID,
+                iouReportID: iouReport?.reportID,
+                transactionID: transaction.transactionID,
+                transactionThreadReportID: transactionThreadReportID ?? iouAction?.childReportID,
+                isFromGlobalCreate,
+                shouldAddPendingNewTransactionIDs: isMoneyRequestReport,
+            });
+        } else {
+            // Navigation is owned by SubmitExpenseOrchestrator (dismiss-first paths). Surface feedback
+            // wherever the user lands: highlight the new row for in-report adds, otherwise the
+            // "Expense added" growl with a "View" deep link.
+            surfaceExpenseCreatedFeedback({
+                iouReportID: iouReport?.reportID,
+                transactionID: transaction.transactionID,
+                transactionThreadReportID: transactionThreadReportID ?? iouAction?.childReportID,
+                isMoneyRequestReport,
+            });
+        }
     }
 
     if (activeReportID && !isMoneyRequestReport) {
@@ -2340,6 +2360,8 @@ function trackExpense(params: CreateTrackExpenseParams) {
         existingTransaction,
         transactionParams: transactionData,
         accountantParams,
+        shouldHandleNavigation = true,
+        isLastTransactionOfBatch = true,
         shouldPlaySound = true,
         optimisticChatReportID,
         optimisticTransactionID,
@@ -2738,8 +2760,28 @@ function trackExpense(params: CreateTrackExpenseParams) {
         }
     }
 
-    if (!params.isRetry) {
-        highlightTransactionOnSearchRouteIfNeeded(isFromGlobalCreate, transaction?.transactionID, CONST.SEARCH.DATA_TYPES.EXPENSE);
+    // Gate post-create navigation/growl to the final transaction of a multi-transaction batch so a
+    // multi-receipt submit fires a single dismiss/navigate and a single "Expense added" toast.
+    if (!params.isRetry && isLastTransactionOfBatch) {
+        if (shouldHandleNavigation) {
+            handleNavigateAfterExpenseCreate({
+                activeReportID,
+                iouReportID: iouReport?.reportID,
+                transactionID: transaction?.transactionID,
+                transactionThreadReportID: transactionThreadReportID ?? iouAction?.childReportID,
+                isFromGlobalCreate,
+                shouldAddPendingNewTransactionIDs: action === CONST.IOU.ACTION.CATEGORIZE || action === CONST.IOU.ACTION.SHARE,
+            });
+        } else {
+            // Navigation is owned by SubmitExpenseOrchestrator (dismiss-first paths). Surface feedback
+            // wherever the user lands: highlight the new row for in-report adds, otherwise the growl.
+            surfaceExpenseCreatedFeedback({
+                iouReportID: iouReport?.reportID,
+                transactionID: transaction?.transactionID,
+                transactionThreadReportID: transactionThreadReportID ?? iouAction?.childReportID,
+                isMoneyRequestReport,
+            });
+        }
     }
 
     notifyNewAction(activeReportID, undefined, payeeAccountID === currentUserAccountIDParam);
diff --git a/src/libs/actions/IOU/types/CreateTrackExpenseParams.ts b/src/libs/actions/IOU/types/CreateTrackExpenseParams.ts
index 940cd13fe12c..51c41735cc21 100644
--- a/src/libs/actions/IOU/types/CreateTrackExpenseParams.ts
+++ b/src/libs/actions/IOU/types/CreateTrackExpenseParams.ts
@@ -22,6 +22,14 @@ type CreateTrackExpenseParams = {
     accountantParams?: TrackExpenseAccountantParams;
     isRetry?: boolean;
     shouldPlaySound?: boolean;
+    shouldHandleNavigation?: boolean;
+    /**
+     * When a confirmation submits several transactions, the orchestrator calls this action once per
+     * transaction in a loop. Post-create navigation + the "Expense added" growl are owned by the
+     * action, so they must fire only once - for the final transaction of the batch. Defaults to true
+     * so single-transaction callers keep their existing behavior.
+     */
+    isLastTransactionOfBatch?: boolean;
     /** Retry-path cleanup only; the action itself never reads this. */
     draftTransactionIDs?: string[];
     optimisticChatReportID?: string;
diff --git a/src/libs/actions/Transaction.ts b/src/libs/actions/Transaction.ts
index 97ccfe409436..0c8eef3c0e46 100644
--- a/src/libs/actions/Transaction.ts
+++ b/src/libs/actions/Transaction.ts
@@ -79,7 +79,6 @@ import type {
 } from '@src/types/onyx';
 import type {OriginalMessageIOU, OriginalMessageModifiedExpense} from '@src/types/onyx/OriginalMessage';
 import type {OnyxData} from '@src/types/onyx/Request';
-import type {SearchDataTypes} from '@src/types/onyx/SearchResults';
 import type {Waypoint, WaypointCollection} from '@src/types/onyx/Transaction';
 import type TransactionState from '@src/types/utils/TransactionStateType';
 
@@ -1865,10 +1864,6 @@ function getDefaultP2PMileageRate() {
     API.read(READ_COMMANDS.GET_DEFAULT_P2P_MILEAGE_RATE, null);
 }
 
-function mergeTransactionIdsHighlightOnSearchRoute(type: SearchDataTypes, data: Record<string, boolean> | null) {
-    return Onyx.merge(ONYXKEYS.TRANSACTION_IDS_HIGHLIGHT_ON_SEARCH_ROUTE, {[type]: data});
-}
-
 function getDuplicateTransactionDetails(transactionID?: string) {
     if (!transactionID) {
         return;
@@ -1901,6 +1896,5 @@ export {
     changeTransactionsReport,
     setTransactionReport,
     getDefaultP2PMileageRate,
-    mergeTransactionIdsHighlightOnSearchRoute,
     getDuplicateTransactionDetails,
 };
diff --git a/src/pages/Share/SubmitDetailsPage.tsx b/src/pages/Share/SubmitDetailsPage.tsx
index 83564087d4ab..847c13d0a2ff 100644
--- a/src/pages/Share/SubmitDetailsPage.tsx
+++ b/src/pages/Share/SubmitDetailsPage.tsx
@@ -264,6 +264,8 @@ function SubmitDetailsPage({
                 isSelfTourViewed,
                 optimisticTransactionID,
                 currentUserLocalCurrency: currentUserPersonalDetails.localCurrencyCode ?? CONST.CURRENCY.USD,
+                // Navigation is owned by cleanupAndNavigateAfterExpenseCreate below; don't let the action navigate too.
+                shouldHandleNavigation: false,
             });
         } else {
             const existingTransactionDraft = existingTransactionID ? transactionDrafts?.[existingTransactionID] : undefined;
@@ -308,6 +310,8 @@ function SubmitDetailsPage({
                 betas,
                 personalDetails,
                 optimisticTransactionID,
+                // Navigation is owned by cleanupAndNavigateAfterExpenseCreate below; don't let the action navigate too.
+                shouldHandleNavigation: false,
             });
         }
         cleanupAndNavigateAfterExpenseCreate({
diff --git a/src/pages/iou/request/step/AmountSubmission.ts b/src/pages/iou/request/step/AmountSubmission.ts
index f90a446aee11..4ebf1d5f2f4a 100644
--- a/src/pages/iou/request/step/AmountSubmission.ts
+++ b/src/pages/iou/request/step/AmountSubmission.ts
@@ -385,6 +385,7 @@ function submitAmount({
                             isSelfTourViewed,
                             optimisticChatReportID,
                             optimisticTransactionID,
+                            shouldHandleNavigation: overrides.shouldHandleNavigation,
                         });
                     } else {
                         const existingTransactionDraft = existingTransactionID ? transactionDrafts?.[existingTransactionID] : undefined;
@@ -419,9 +420,10 @@ function submitAmount({
                             personalDetails: allPersonalDetails,
                             optimisticChatReportID,
                             optimisticTransactionID,
+                            shouldHandleNavigation: overrides.shouldHandleNavigation,
                         });
                     }
-                    cleanupAfterSkipConfirmSubmit(overrides.shouldHandleNavigation, {
+                    cleanupAfterSkipConfirmSubmit({
                         report,
                         action,
                         draftTransactionIDs: draftTransactionIDsList,
diff --git a/src/pages/iou/request/step/IOURequestStepDistance/handleMoneyRequestStepDistanceNavigation.ts b/src/pages/iou/request/step/IOURequestStepDistance/handleMoneyRequestStepDistanceNavigation.ts
index c7b8c9920e12..188588b5f867 100644
--- a/src/pages/iou/request/step/IOURequestStepDistance/handleMoneyRequestStepDistanceNavigation.ts
+++ b/src/pages/iou/request/step/IOURequestStepDistance/handleMoneyRequestStepDistanceNavigation.ts
@@ -265,7 +265,7 @@ function handleMoneyRequestStepDistanceNavigation({
             });
             if (isCreatingTrackExpense && participant) {
                 submitWithDismissFirst({
-                    // trackExpense is a void action with no navigation params; submitWithDismissFirst owns dismiss/reveal and cleanup runs after.
+                    // submitWithDismissFirst owns dismiss/reveal; pass its shouldHandleNavigation through so trackExpense doesn't also navigate.
                     executeWrite: (overrides) => {
                         trackExpense({
                             report,
@@ -317,8 +317,9 @@ function handleMoneyRequestStepDistanceNavigation({
                             optimisticTransactionID,
                             optimisticChatReportID,
                             currentUserLocalCurrency,
+                            shouldHandleNavigation: overrides.shouldHandleNavigation,
                         });
-                        cleanupAfterSkipConfirmSubmit(overrides.shouldHandleNavigation, {
+                        cleanupAfterSkipConfirmSubmit({
                             report,
                             action,
                             draftTransactionIDs,
@@ -393,7 +394,7 @@ function handleMoneyRequestStepDistanceNavigation({
                             policyTagList,
                         },
                     });
-                    cleanupAfterSkipConfirmSubmit(overrides.shouldHandleNavigation, {
+                    cleanupAfterSkipConfirmSubmit({
                         report,
                         action,
                         draftTransactionIDs,
diff --git a/src/pages/iou/request/step/IOURequestStepScan/components/ScanSkipConfirmation.tsx b/src/pages/iou/request/step/IOURequestStepScan/components/ScanSkipConfirmation.tsx
index 7d94d402b4bb..84ec9541246c 100644
--- a/src/pages/iou/request/step/IOURequestStepScan/components/ScanSkipConfirmation.tsx
+++ b/src/pages/iou/request/step/IOURequestStepScan/components/ScanSkipConfirmation.tsx
@@ -202,7 +202,7 @@ function ScanSkipConfirmation({report, action, iouType, reportID, transactionID,
                         shouldHandleNavigation: overrides.shouldHandleNavigation,
                         shouldDeferForSearch: false,
                     });
-                    cleanupAfterSkipConfirmSubmit(overrides.shouldHandleNavigation, {
+                    cleanupAfterSkipConfirmSubmit({
                         report,
                         action,
                         draftTransactionIDs,
@@ -272,7 +272,7 @@ function ScanSkipConfirmation({report, action, iouType, reportID, transactionID,
             executeWrite: (overrides) => {
                 // Cleanup runs after each write (not once up front) so a stalled GPS lookup can't clear the draft before the expense exists.
                 const runCleanup = () =>
-                    cleanupAfterSkipConfirmSubmit(overrides.shouldHandleNavigation, {
+                    cleanupAfterSkipConfirmSubmit({
                         report,
                         action,
                         draftTransactionIDs,
@@ -291,19 +291,20 @@ function ScanSkipConfirmation({report, action, iouType, reportID, transactionID,
                                     lat: successData.coords.latitude,
                                     long: successData.coords.longitude,
                                 },
+                                shouldHandleNavigation: overrides.shouldHandleNavigation,
                             });
                             runCleanup();
                         },
                         (errorData) => {
                             Log.info('[ScanSkipConfirmation] getCurrentPosition failed', false, errorData);
                             // When there is an error, the money can still be requested, it just won't include the GPS coordinates
-                            createTransaction(baseParams);
+                            createTransaction({...baseParams, shouldHandleNavigation: overrides.shouldHandleNavigation});
                             runCleanup();
                         },
                     );
                     return;
                 }
-                createTransaction(baseParams);
+                createTransaction({...baseParams, shouldHandleNavigation: overrides.shouldHandleNavigation});
                 runCleanup();
             },
             destinationReportID: scanDestinationReportID,
diff --git a/src/pages/iou/request/step/confirmation/useExpenseSubmission.ts b/src/pages/iou/request/step/confirmation/useExpenseSubmission.ts
index 8b0c0b477ba5..7a38a849df07 100644
--- a/src/pages/iou/request/step/confirmation/useExpenseSubmission.ts
+++ b/src/pages/iou/request/step/confirmation/useExpenseSubmission.ts
@@ -22,10 +22,9 @@ import {getStringifiedGPSCoordinates} from '@libs/GPSDraftDetailsUtils';
 import {getExistingTransactionID, resolveOptimisticChatReportID} from '@libs/IOUUtils';
 import Log from '@libs/Log';
 import cleanupAfterExpenseCreate from '@libs/Navigation/helpers/cleanupAfterExpenseCreate';
-import cleanupAndNavigateAfterExpenseCreate from '@libs/Navigation/helpers/cleanupAndNavigateAfterExpenseCreate';
 import dismissModalAndOpenReportInInboxTabHelper from '@libs/Navigation/helpers/dismissModalAndOpenReportInInboxTab';
 import isSearchTopmostFullScreenRoute from '@libs/Navigation/helpers/isSearchTopmostFullScreenRoute';
-import navigateAfterExpenseCreate from '@libs/Navigation/helpers/navigateAfterExpenseCreate';
+import navigateAfterExpenseCreate, {surfaceExpenseCreatedFeedback} from '@libs/Navigation/helpers/navigateAfterExpenseCreate';
 import {rand64, roundToTwoDecimalPlaces} from '@libs/NumberUtils';
 import {isTaxTrackingEnabled} from '@libs/PolicyUtils';
 import {
@@ -49,7 +48,6 @@ import {
     isGPSDistanceRequest as isGPSDistanceRequestTransactionUtils,
     isManualDistanceRequest as isManualDistanceRequestTransactionUtils,
 } from '@libs/TransactionUtils';
-import {resolveChatTargetForSubmitCleanup} from '@pages/iou/request/step/resolveChatTarget';
 import {isOneToTwoTransactionTransition} from '@userActions/IOU/PendingNewTransactions';
 import {submitPerDiemExpenseForSelfDM, submitPerDiemExpense as submitPerDiemExpenseIOUActions} from '@userActions/IOU/PerDiem';
 import {getReceiverType, sendInvoice} from '@userActions/IOU/SendInvoice';
@@ -289,13 +287,7 @@ function useExpenseSubmission(params: UseExpenseSubmissionParams) {
     const [storedTransactions] = useTransactionsByID(transactionIDs);
 
     function performPostBatchCleanup({
-        participant,
-        shouldHandleNavigation,
         allTransactionsCreated,
-        fallbackOptimisticChatReportID,
-        navigateBackToReport,
-        lastOptimisticTransactionID,
-        preResolvedChatTarget,
     }: {
         participant: Participant;
         shouldHandleNavigation: boolean;
@@ -310,32 +302,11 @@ function useExpenseSubmission(params: UseExpenseSubmissionParams) {
         if (!allTransactionsCreated) {
             return;
         }
-        if (!shouldHandleNavigation) {
-            cleanupAfterExpenseCreate({draftTransactionIDs, linkedTrackedExpenseReportAction: lastTransaction?.linkedTrackedExpenseReportAction});
-            return;
-        }
-        // requestMoney passes the chat it wrote to (iouReport.chatReportID) as preResolvedChatTarget; trackExpense is void so it still derives (self-DM case).
-        const {report: resolvedReport, chatReportID} =
-            preResolvedChatTarget ??
-            resolveChatTargetForSubmitCleanup({
-                participant,
-                currentUserAccountID: currentUserPersonalDetails.accountID,
-                report,
-                fallbackOptimisticChatReportID,
-                action,
-            });
-        // Move-from-track (SUBMIT/CATEGORIZE/SHARE) reuses the tracked transaction's ID — mirror the builder's `existingTransactionID ?? optimisticTransactionID`.
-        const lastTransactionID = getExistingTransactionID(lastTransaction?.linkedTrackedExpenseReportAction) ?? lastOptimisticTransactionID;
-        cleanupAndNavigateAfterExpenseCreate({
-            report: resolvedReport,
-            action,
-            draftTransactionIDs,
-            transactionID: lastTransactionID,
-            isFromGlobalCreate: getIsFromGlobalCreate(lastTransaction),
-            backToReport: navigateBackToReport,
-            optimisticChatReportID: chatReportID,
-            linkedTrackedExpenseReportAction: lastTransaction?.linkedTrackedExpenseReportAction,
-        });
+        // Navigation + the "Expense added" growl are owned by the IOU action itself (requestMoney/trackExpense
+        // call handleNavigateAfterExpenseCreate / showExpenseAddedGrowl internally). Doing it here as well fired
+        // the growl twice and ran navigation twice on the shouldHandleNavigation=true paths, so this only performs
+        // the non-navigation cleanup now.
+        cleanupAfterExpenseCreate({draftTransactionIDs, linkedTrackedExpenseReportAction: lastTransaction?.linkedTrackedExpenseReportAction});
     }
 
     function requestMoney(shouldHandleNavigation: boolean, gpsPoint?: GpsPoint) {
@@ -360,7 +331,7 @@ function useExpenseSubmission(params: UseExpenseSubmissionParams) {
         let allTransactionsCreated = true;
         let lastOptimisticTransactionID: string | undefined;
 
-        for (const item of transactions) {
+        for (const [index, item] of transactions.entries()) {
             lastOptimisticTransactionID = rand64();
             const receipt = receiptFiles[item.transactionID];
             const isTestReceipt = receipt?.isTestReceipt ?? false;
@@ -466,6 +437,11 @@ function useExpenseSubmission(params: UseExpenseSubmissionParams) {
                     ...(isTimeRequest ? {type: CONST.TRANSACTION.TYPE.TIME, count: item.comment?.units?.count, rate: item.comment?.units?.rate, unit: CONST.TIME_TRACKING.UNIT.HOUR} : {}),
                 },
                 optimisticTransactionID: lastOptimisticTransactionID,
+                // The action owns post-create navigation + growl, but only when the caller permits it
+                // (dismiss-first orchestrators pass shouldHandleNavigation=false after revealing/dismissing
+                // the destination themselves) and only for the final transaction of the batch.
+                shouldHandleNavigation,
+                isLastTransactionOfBatch: index === transactions.length - 1,
                 shouldGenerateTransactionThreadReport,
                 isASAPSubmitBetaEnabled,
                 currentUserAccountIDParam: currentUserPersonalDetails.accountID,
@@ -592,14 +568,28 @@ function useExpenseSubmission(params: UseExpenseSubmissionParams) {
             const isOneToTwoTransition = !backToReport && isOneToTwoTransactionTransition(isMoneyRequestReport, reportTransactions);
 
             if (result && targetReportID) {
-                navigateAfterExpenseCreate({
-                    activeReportID: targetReportID,
-                    transactionID: result.transactionID,
-                    isFromGlobalCreate: getIsFromGlobalCreate(transaction),
-                    hasMultipleTransactions: reportTransactions.length > 0,
-                    shouldAddPendingNewTransactionIDs: (shouldHandleNavigation && targetReportID === chatReportID) || isOneToTwoTransition,
-                    shouldNavigate: shouldHandleNavigation,
-                });
+                if (shouldHandleNavigation) {
+                    navigateAfterExpenseCreate({
+                        activeReportID: targetReportID,
+                        iouReportID: result.iouReport?.reportID,
+                        transactionID: result.transactionID,
+                        transactionThreadReportID: result.transactionThreadReportID,
+                        isFromGlobalCreate: getIsFromGlobalCreate(transaction),
+                        hasMultipleTransactions: reportTransactions.length > 0,
+                        shouldAddPendingNewTransactionIDs: targetReportID === chatReportID || isOneToTwoTransition,
+                    });
+                } else {
+                    // Navigation is owned by SubmitExpenseOrchestrator (dismiss-first paths). Surface
+                    // feedback wherever the user lands: highlight the new row for in-report adds,
+                    // otherwise the "Expense added" growl with a "View" deep link - matching
+                    // requestMoney/trackExpense/split/invoice.
+                    surfaceExpenseCreatedFeedback({
+                        iouReportID: result.iouReport?.reportID,
+                        transactionID: result.transactionID,
+                        transactionThreadReportID: result.transactionThreadReportID,
+                        isMoneyRequestReport,
+                    });
+                }
             }
         }
     }
@@ -621,7 +611,7 @@ function useExpenseSubmission(params: UseExpenseSubmissionParams) {
         const optimisticSelfDMReportID = selfDMReport?.reportID ?? generateReportID();
         const policyExpenseChatReportActions = getAllPolicyExpenseChatReportActions(allReports, allReportActions);
         let lastOptimisticTransactionID: string | undefined;
-        for (const item of transactions) {
+        for (const [index, item] of transactions.entries()) {
             lastOptimisticTransactionID = rand64();
             const isLinkedTrackedExpenseReportArchived =
                 !!item.linkedTrackedExpenseReportID && privateIsArchivedMap[`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${item.linkedTrackedExpenseReportID}`];
@@ -677,6 +667,11 @@ function useExpenseSubmission(params: UseExpenseSubmissionParams) {
                 },
                 optimisticChatReportID: optimisticSelfDMReportID,
                 optimisticTransactionID: lastOptimisticTransactionID,
+                // The action owns post-create navigation + growl, but only when the caller permits it
+                // (dismiss-first orchestrators pass shouldHandleNavigation=false after revealing/dismissing
+                // the destination themselves) and only for the final transaction of the batch.
+                shouldHandleNavigation,
+                isLastTransactionOfBatch: index === transactions.length - 1,
                 isASAPSubmitBetaEnabled,
                 currentUser: {accountID: currentUserPersonalDetails.accountID, email},
                 introSelected,
diff --git a/src/styles/index.ts b/src/styles/index.ts
index 374497651c32..492fb4af28ab 100644
--- a/src/styles/index.ts
+++ b/src/styles/index.ts
@@ -3357,6 +3357,16 @@ const staticStyles = (theme: ThemeColors) =>
             ...positioning.pFixed,
         },
 
+        growlNotificationContainerBottomRight: {
+            maxWidth: variables.sideBarWidth,
+            width: '100%',
+            right: 0,
+            bottom: 20,
+            ...spacing.pl5,
+            ...spacing.pr5,
+            ...positioning.pFixed,
+        },
+
         growlNotificationBox: {
             backgroundColor: theme.inverse,
             borderRadius: variables.componentBorderRadiusNormal,
@@ -3364,16 +3374,39 @@ const staticStyles = (theme: ThemeColors) =>
             flexDirection: 'row',
             justifyContent: 'space-between',
             boxShadow: `${theme.shadow}`,
-            ...spacing.p5,
+            // Spec: padding-left 16px, padding-top/right/bottom 8px, 12px gap between items.
+            // The 8px top/bottom padding + the 40px-tall Medium Link action button add up to the
+            // 56px growl height from the design.
+            ...spacing.pl4,
+            ...spacing.pt2,
+            ...spacing.pr2,
+            ...spacing.pb2,
+            ...spacing.gap3,
         },
 
         growlNotificationText: {
             fontSize: variables.fontSizeNormal,
             ...FontUtils.fontFamily.platform.EXP_NEUE,
-            width: '90%',
             lineHeight: variables.fontSizeNormalHeight,
             color: theme.textReversed,
-            ...spacing.ml4,
+        },
+
+        growlNotificationTextWithoutAction: {
+            width: '90%',
+        },
+
+        growlNotificationTextWithAction: {
+            flex: 1,
+            minWidth: 0,
+        },
+
+        // "View" action rendered as a Medium Link Button on the growl's inverse-colored surface.
+        growlNotificationActionText: {
+            color: theme.linkReversed,
+        },
+
+        growlNotificationActionHovered: {
+            backgroundColor: theme.buttonHoveredBGReversed,
         },
 
         noSelect: {
@@ -6456,14 +6489,6 @@ const dynamicStyles = (theme: ThemeColors) =>
 
         RHPNavigatorContainerNavigatorContainerStyles: (isSmallScreenWidth: boolean) => ({marginLeft: isSmallScreenWidth ? 0 : variables.sideBarWidth, flex: 1}) satisfies ViewStyle,
 
-        growlNotificationTranslateY: (translateY: SharedValue<number>) => {
-            'worklet';
-
-            return {
-                transform: [{translateY: translateY.get()}],
-            };
-        },
-
         activeDropzoneDashedBorder: (borderColor: string, isActive: boolean) => {
             const browser = getBrowser();
             const isSafariOrChromeBrowser = getPlatform() === CONST.PLATFORM.WEB && (browser === CONST.BROWSER.SAFARI || browser === CONST.BROWSER.CHROME);
diff --git a/src/styles/theme/themes/dark.ts b/src/styles/theme/themes/dark.ts
index 2ba9fbb6933c..a8b99ae8f9b1 100644
--- a/src/styles/theme/themes/dark.ts
+++ b/src/styles/theme/themes/dark.ts
@@ -27,8 +27,10 @@ const darkTheme = {
     syntax: colors.productDark800,
     link: colors.blue300,
     linkHover: colors.blue100,
+    linkReversed: colors.blue600,
     buttonDefaultBG: colors.productDark400,
     buttonHoveredBG: colors.productDark500,
+    buttonHoveredBGReversed: colors.productLight500,
     buttonPressedBG: colors.productDark600,
     buttonSuccessText: colors.productLight100,
     buttonDangerText: colors.productDark900,
diff --git a/src/styles/theme/themes/light.ts b/src/styles/theme/themes/light.ts
index 8bf89843ae56..ef13613a4017 100644
--- a/src/styles/theme/themes/light.ts
+++ b/src/styles/theme/themes/light.ts
@@ -27,8 +27,10 @@ const lightTheme = {
     syntax: colors.productLight800,
     link: colors.blue600,
     linkHover: colors.blue500,
+    linkReversed: colors.blue300,
     buttonDefaultBG: colors.productLight400,
     buttonHoveredBG: colors.productLight500,
+    buttonHoveredBGReversed: colors.productDark500,
     buttonPressedBG: colors.productLight600,
     buttonSuccessText: colors.productLight100,
     buttonDangerText: colors.white,
diff --git a/src/styles/theme/types.ts b/src/styles/theme/types.ts
index 87d2a228f025..d0bef1341c04 100644
--- a/src/styles/theme/types.ts
+++ b/src/styles/theme/types.ts
@@ -33,8 +33,11 @@ type ThemeColors = {
     syntax: Color;
     link: Color;
     linkHover: Color;
+    linkReversed: Color;
     buttonDefaultBG: Color;
     buttonHoveredBG: Color;
+    /** Hover background for buttons rendered on an inverse-colored surface (e.g. the growl notification). */
+    buttonHoveredBGReversed: Color;
     buttonPressedBG: Color;
     buttonSuccessText: Color;
     buttonDangerText: Color;
diff --git a/tests/actions/IOU/MoneyRequestTest.ts b/tests/actions/IOU/MoneyRequestTest.ts
index 831c0315bb11..60616a5f6f1f 100644
--- a/tests/actions/IOU/MoneyRequestTest.ts
+++ b/tests/actions/IOU/MoneyRequestTest.ts
@@ -66,19 +66,12 @@ jest.mock('@libs/getCurrentPosition');
 
 // Fire executeWrite synchronously so downstream writes can be asserted.
 jest.mock('@libs/Navigation/helpers/submitWithDismissFirst', () => jest.requireActual<typeof SubmitWithDismissFirstMock>('../../__mocks__/submitWithDismissFirst'));
-// Cleanup helpers are spies so the move-from-track cleanup-id contract can be asserted.
-const mockCleanupAndNavigateAfterExpenseCreate = jest.fn();
-const mockCleanupAfterExpenseCreate = jest.fn();
-jest.mock('@libs/Navigation/helpers/cleanupAndNavigateAfterExpenseCreate', () => ({
+// cleanupAfterSkipConfirmSubmit is a spy so the move-from-track cleanup-id contract can be asserted. It's cleanup-only — the write action owns post-create navigation.
+const mockCleanupAfterSkipConfirmSubmit = jest.fn();
+jest.mock('@libs/Navigation/helpers/cleanupAfterSkipConfirmSubmit', () => ({
     __esModule: true,
     default: (...args: unknown[]): void => {
-        mockCleanupAndNavigateAfterExpenseCreate(...args);
-    },
-}));
-jest.mock('@libs/Navigation/helpers/cleanupAfterExpenseCreate', () => ({
-    __esModule: true,
-    default: (...args: unknown[]): void => {
-        mockCleanupAfterExpenseCreate(...args);
+        mockCleanupAfterSkipConfirmSubmit(...args);
     },
 }));
 
@@ -179,10 +172,10 @@ describe('MoneyRequest', () => {
                 }),
             );
 
-            // Deferral is channel-driven; the action no longer receives a shouldDeferForSearch / shouldHandleNavigation flag.
+            // Deferral is channel-driven (no shouldDeferForSearch flag), but the action owns post-create navigation, so it receives shouldHandleNavigation.
             const lastTrackExpenseParams = jest.mocked(TrackExpense.trackExpense).mock.calls.at(-1)?.at(0);
             expect(lastTrackExpenseParams && 'shouldDeferForSearch' in lastTrackExpenseParams).toBeFalsy();
-            expect(lastTrackExpenseParams && 'shouldHandleNavigation' in lastTrackExpenseParams).toBeFalsy();
+            expect(lastTrackExpenseParams && 'shouldHandleNavigation' in lastTrackExpenseParams).toBeTruthy();
         });
 
         it('should call requestMoney for non-TRACK (SEND) iouType', () => {
@@ -696,7 +689,7 @@ describe('MoneyRequest', () => {
                 expect.objectContaining({
                     report: baseParams.report,
                     isDraftPolicy: false,
-                    // Action is nav-free — UI owns navigation; draft + optimistic IDs are threaded in.
+                    // The action owns post-create navigation; draft + optimistic IDs are threaded in alongside shouldHandleNavigation.
                     existingTransaction: baseParams.transaction,
                     transactionParams: expect.objectContaining({
                         amount: 0,
@@ -710,7 +703,7 @@ describe('MoneyRequest', () => {
             const distanceTrackExpenseParams = jest.mocked(TrackExpense.trackExpense).mock.calls.at(-1)?.at(0);
             expect(typeof distanceTrackExpenseParams?.optimisticTransactionID).toBe('string');
             expect(typeof distanceTrackExpenseParams?.optimisticChatReportID).toBe('string');
-            expect(distanceTrackExpenseParams && 'shouldHandleNavigation' in distanceTrackExpenseParams).toBeFalsy();
+            expect(distanceTrackExpenseParams && 'shouldHandleNavigation' in distanceTrackExpenseParams).toBeTruthy();
 
             // The function must return after trackExpense and not call createDistanceRequest
             expect(Split.createDistanceRequest).not.toHaveBeenCalled();
@@ -745,8 +738,8 @@ describe('MoneyRequest', () => {
 
             await waitForBatchedUpdates();
 
-            expect(mockCleanupAndNavigateAfterExpenseCreate).toHaveBeenCalledTimes(1);
-            expect(mockCleanupAndNavigateAfterExpenseCreate).toHaveBeenCalledWith(
+            expect(mockCleanupAfterSkipConfirmSubmit).toHaveBeenCalledTimes(1);
+            expect(mockCleanupAfterSkipConfirmSubmit).toHaveBeenCalledWith(
                 expect.objectContaining({
                     transactionID: EXISTING_TRACKED_TRANSACTION_ID,
                 }),
@@ -766,7 +759,7 @@ describe('MoneyRequest', () => {
 
             await waitForBatchedUpdates();
 
-            expect(mockCleanupAndNavigateAfterExpenseCreate).toHaveBeenCalledWith(
+            expect(mockCleanupAfterSkipConfirmSubmit).toHaveBeenCalledWith(
                 expect.objectContaining({
                     transactionID: fakeTransaction.transactionID,
                 }),
diff --git a/tests/actions/IOU/SplitReportTotalsTest.ts b/tests/actions/IOU/SplitReportTotalsTest.ts
index 4b9ad2090c9a..02e97586da8f 100644
--- a/tests/actions/IOU/SplitReportTotalsTest.ts
+++ b/tests/actions/IOU/SplitReportTotalsTest.ts
@@ -2,12 +2,10 @@
 import Onyx from 'react-native-onyx';
 import type {OnyxEntry, OnyxMergeCollectionInput} from 'react-native-onyx';
 import '@libs/actions/IOU/MoneyRequest';
-import {handleNavigateAfterExpenseCreate} from '@libs/actions/IOU/NavigationHelpers';
 import {addPendingNewTransactionIDs} from '@libs/actions/IOU/PendingNewTransactions';
 import {createSplitsAndOnyxData} from '@libs/actions/IOU/Split';
 import {updateSplitTransactionsFromSplitExpensesFlow} from '@libs/actions/IOU/SplitTransactionUpdate';
 import initOnyxDerivedValues from '@libs/actions/OnyxDerived';
-import isReportTopmostSplitNavigator from '@libs/Navigation/helpers/isReportTopmostSplitNavigator';
 import {rand64} from '@libs/NumberUtils';
 import type * as PolicyUtils from '@libs/PolicyUtils';
 import CONST from '@src/CONST';
@@ -428,33 +426,6 @@ describe('actions/IOU', () => {
         });
     });
 
-    it('handleNavigateAfterExpenseCreate', async () => {
-        const mockedIsReportTopmostSplitNavigator = isReportTopmostSplitNavigator as jest.MockedFunction<typeof isReportTopmostSplitNavigator>;
-        const spyOnMergeTransactionIdsHighlightOnSearchRoute = jest.spyOn(require('@libs/actions/Transaction'), 'mergeTransactionIdsHighlightOnSearchRoute');
-        const activeReportID = '1';
-        const transactionID = '1';
-        mockedIsReportTopmostSplitNavigator.mockReturnValue(false);
-
-        handleNavigateAfterExpenseCreate({activeReportID, isFromGlobalCreate: false});
-        expect(spyOnMergeTransactionIdsHighlightOnSearchRoute).toHaveBeenCalledTimes(0);
-
-        handleNavigateAfterExpenseCreate({activeReportID, isFromGlobalCreate: true});
-        expect(spyOnMergeTransactionIdsHighlightOnSearchRoute).toHaveBeenCalledTimes(0);
-
-        mockedIsReportTopmostSplitNavigator.mockReturnValue(true);
-        handleNavigateAfterExpenseCreate({activeReportID, isFromGlobalCreate: true, transactionID});
-        expect(spyOnMergeTransactionIdsHighlightOnSearchRoute).toHaveBeenCalledTimes(0);
-
-        mockedIsReportTopmostSplitNavigator.mockReturnValue(false);
-        handleNavigateAfterExpenseCreate({activeReportID, isFromGlobalCreate: true, transactionID});
-        expect(spyOnMergeTransactionIdsHighlightOnSearchRoute).toHaveBeenCalledTimes(0);
-
-        handleNavigateAfterExpenseCreate({activeReportID, isFromGlobalCreate: true, transactionID, isInvoice: true});
-        expect(spyOnMergeTransactionIdsHighlightOnSearchRoute).toHaveBeenCalledTimes(0);
-
-        spyOnMergeTransactionIdsHighlightOnSearchRoute.mockReset();
-    });
-
     describe('createSplitsAndOnyxData', () => {
         const mockPersonalDetails: PersonalDetailsList = {
             [RORY_ACCOUNT_ID]: {accountID: RORY_ACCOUNT_ID, login: RORY_EMAIL, displayName: 'Rory'},
diff --git a/tests/ui/IOURequestStepAmountDraftTest.tsx b/tests/ui/IOURequestStepAmountDraftTest.tsx
index 818f141dba22..4a8773f39e60 100644
--- a/tests/ui/IOURequestStepAmountDraftTest.tsx
+++ b/tests/ui/IOURequestStepAmountDraftTest.tsx
@@ -13,7 +13,7 @@ import ONYXKEYS from '@src/ONYXKEYS';
 import SCREENS from '@src/SCREENS';
 import type {Report, Transaction} from '@src/types/onyx';
 import * as TrackExpense from '../../src/libs/actions/IOU/TrackExpense';
-import cleanupAndNavigateAfterExpenseCreate from '../../src/libs/Navigation/helpers/cleanupAndNavigateAfterExpenseCreate';
+import cleanupAfterSkipConfirmSubmit from '../../src/libs/Navigation/helpers/cleanupAfterSkipConfirmSubmit';
 import createRandomTransaction from '../utils/collections/transaction';
 import {signInWithTestUser} from '../utils/TestHelper';
 import waitForBatchedUpdates from '../utils/waitForBatchedUpdates';
@@ -96,8 +96,8 @@ jest.mock('@libs/Navigation/Navigation', () => {
 
 jest.mock('@libs/Navigation/helpers/submitWithDismissFirst', () => jest.requireActual('../__mocks__/submitWithDismissFirst'));
 
-// Action-assertion test: post-create navigation is exercised elsewhere; keep the nav helpers inert here.
-jest.mock('@libs/Navigation/helpers/cleanupAndNavigateAfterExpenseCreate', () => jest.fn());
+// Action-assertion test: post-create navigation is exercised elsewhere; keep the cleanup helper inert here.
+jest.mock('@libs/Navigation/helpers/cleanupAfterSkipConfirmSubmit', () => jest.fn());
 jest.mock('@libs/Navigation/helpers/cleanupAfterExpenseCreate', () => jest.fn());
 
 jest.mock('@react-navigation/native', () => {
@@ -254,9 +254,9 @@ describe('IOURequestStepAmount - draft transactions coverage', () => {
             }),
         );
 
-        // The same optimisticTransactionID must reach the action AND post-create cleanup nav, else the destination report highlights the wrong transaction.
+        // The same optimisticTransactionID must reach the action AND post-create cleanup, else the destination report highlights the wrong transaction.
         const requestMoneyArg = jest.mocked(TrackExpense.requestMoney).mock.calls.at(0)?.[0];
-        const cleanupArg = jest.mocked(cleanupAndNavigateAfterExpenseCreate).mock.calls.at(0)?.[0];
+        const cleanupArg = jest.mocked(cleanupAfterSkipConfirmSubmit).mock.calls.at(0)?.[0];
         expect(typeof requestMoneyArg?.optimisticTransactionID).toBe('string');
         expect(cleanupArg?.transactionID).toBe(requestMoneyArg?.optimisticTransactionID);
     });
diff --git a/tests/ui/ScanSkipConfirmationTest.tsx b/tests/ui/ScanSkipConfirmationTest.tsx
index 33e8ea3659dc..89efb1aeccb4 100644
--- a/tests/ui/ScanSkipConfirmationTest.tsx
+++ b/tests/ui/ScanSkipConfirmationTest.tsx
@@ -83,8 +83,8 @@ jest.mock('@libs/Navigation/helpers/submitWithDismissFirst', () => ({
 
 jest.mock('@libs/Navigation/helpers/cleanupAfterSkipConfirmSubmit', () => ({
     __esModule: true,
-    default: (shouldHandleNavigation: boolean, params: Record<string, unknown>) => {
-        mockCleanupAfterSkipConfirmSubmit(shouldHandleNavigation, params);
+    default: (params: Record<string, unknown>) => {
+        mockCleanupAfterSkipConfirmSubmit(params);
     },
 }));
 
@@ -179,7 +179,7 @@ describe('ScanSkipConfirmation submit orchestration', () => {
         });
         await waitForBatchedUpdates();
 
-        // The action layer must not navigate; the view layer drives dismiss-first + cleanup itself.
+        // The view layer threads the UI-resolved optimistic ids into the action and runs cleanup-only after dismiss-first; the action owns post-create navigation.
         expect(mockSubmitWithDismissFirst).toHaveBeenCalledTimes(1);
         expect(mockCreateTransaction).toHaveBeenCalledTimes(1);
 
@@ -188,6 +188,6 @@ describe('ScanSkipConfirmation submit orchestration', () => {
         expect(capturedCreateTransactionArg?.optimisticChatReportID).toBe('optimistic-resolved');
 
         expect(mockCleanupAfterSkipConfirmSubmit).toHaveBeenCalledTimes(1);
-        expect(mockCleanupAfterSkipConfirmSubmit).toHaveBeenCalledWith(true, expect.objectContaining({optimisticChatReportID: 'chat-resolved'}));
+        expect(mockCleanupAfterSkipConfirmSubmit).toHaveBeenCalledWith(expect.objectContaining({optimisticChatReportID: 'chat-resolved'}));
     });
 });
diff --git a/tests/unit/Search/ExpenseFlatSearchViewTest.tsx b/tests/unit/Search/ExpenseFlatSearchViewTest.tsx
index 67f7124f6440..7b8bc0c9657c 100644
--- a/tests/unit/Search/ExpenseFlatSearchViewTest.tsx
+++ b/tests/unit/Search/ExpenseFlatSearchViewTest.tsx
@@ -189,7 +189,6 @@ function renderView(overrides: RenderOverrides = {}) {
                 isMobileSelectionModeEnabled={overrides.isMobileSelectionModeEnabled ?? false}
                 tableHeaderVisible={overrides.tableHeaderVisible ?? false}
                 hasLoadedAllTransactions={overrides.hasLoadedAllTransactions ?? true}
-                newTransactions={[]}
                 onSelectRow={onSelectRow}
                 onEndReached={onEndReached}
                 onLayout={onLayout}
diff --git a/tests/unit/cleanupAfterSkipConfirmSubmitTest.ts b/tests/unit/cleanupAfterSkipConfirmSubmitTest.ts
index 7a4d5c95848f..567755979bec 100644
--- a/tests/unit/cleanupAfterSkipConfirmSubmitTest.ts
+++ b/tests/unit/cleanupAfterSkipConfirmSubmitTest.ts
@@ -28,16 +28,8 @@ describe('cleanupAfterSkipConfirmSubmit', () => {
         jest.clearAllMocks();
     });
 
-    it('should delegate to cleanupAndNavigateAfterExpenseCreate with the full params when shouldHandleNavigation is true', () => {
-        cleanupAfterSkipConfirmSubmit(true, params);
-
-        expect(cleanupAndNavigateAfterExpenseCreate).toHaveBeenCalledTimes(1);
-        expect(cleanupAndNavigateAfterExpenseCreate).toHaveBeenCalledWith(params);
-        expect(cleanupAfterExpenseCreate).not.toHaveBeenCalled();
-    });
-
-    it('should delegate only the cleanup-relevant subset to cleanupAfterExpenseCreate when shouldHandleNavigation is false', () => {
-        cleanupAfterSkipConfirmSubmit(false, params);
+    it('should delegate only the cleanup-relevant subset to cleanupAfterExpenseCreate and never navigate (the write action owns navigation)', () => {
+        cleanupAfterSkipConfirmSubmit(params);
 
         expect(cleanupAfterExpenseCreate).toHaveBeenCalledTimes(1);
         expect(cleanupAfterExpenseCreate).toHaveBeenCalledWith({
diff --git a/tests/unit/hooks/useExpenseSubmission.test.ts b/tests/unit/hooks/useExpenseSubmission.test.ts
index fc303ac2aa89..0b4bc30e9374 100644
--- a/tests/unit/hooks/useExpenseSubmission.test.ts
+++ b/tests/unit/hooks/useExpenseSubmission.test.ts
@@ -210,7 +210,7 @@ describe('useExpenseSubmission orchestrator-suppressed cleanup', () => {
             expect(mockCleanupAndNavigateAfterExpenseCreate).not.toHaveBeenCalled();
         });
 
-        it('calls cleanupAndNavigateAfterExpenseCreate (which composes cleanup) when shouldHandleNavigation=true', async () => {
+        it('does cleanup-only and never cleanupAndNavigateAfterExpenseCreate when shouldHandleNavigation=true (IOU action owns nav/growl)', async () => {
             const {result} = renderHook(() => useExpenseSubmission(buildParams()));
             await waitForBatchedUpdatesWithAct();
 
@@ -220,14 +220,15 @@ describe('useExpenseSubmission orchestrator-suppressed cleanup', () => {
             await waitForBatchedUpdatesWithAct();
 
             expect(mockRequestMoneyAction).toHaveBeenCalledTimes(1);
-            expect(mockCleanupAndNavigateAfterExpenseCreate).toHaveBeenCalledTimes(1);
-            // cleanupAndNavigate is mocked here, so it never calls through to the real cleanupAfterExpenseCreate.
-            expect(mockCleanupAfterExpenseCreate).not.toHaveBeenCalled();
+            // Navigation + the "Expense added" growl are owned by requestMoney itself; the hook only runs the
+            // non-navigation cleanup regardless of shouldHandleNavigation.
+            expect(mockCleanupAfterExpenseCreate).toHaveBeenCalledTimes(1);
+            expect(mockCleanupAndNavigateAfterExpenseCreate).not.toHaveBeenCalled();
         });
 
-        it('passes the existing tracked transaction ID (not a fresh optimistic id) to cleanup for a move-from-track SUBMIT', async () => {
-            // Move-from-track SUBMIT: the action writes the transaction under the EXISTING tracked transaction id,
-            // so cleanup must reference that same id — not a fresh rand64() optimistic one.
+        it('passes the moved transaction linkedTrackedExpenseReportAction to cleanup for a move-from-track SUBMIT', async () => {
+            // Move-from-track SUBMIT: cleanup is cleanup-only now, so it carries the moved transaction's
+            // linkedTrackedExpenseReportAction (used to release the original tracked expense draft).
             const EXISTING_TRACKED_TRANSACTION_ID = 'tracked-transaction-99';
             const linkedTrackedExpenseReportAction = buildReportAction({
                 reportActionID: 'linked-action-1',
@@ -257,16 +258,17 @@ describe('useExpenseSubmission orchestrator-suppressed cleanup', () => {
             });
             await waitForBatchedUpdatesWithAct();
 
-            expect(mockCleanupAndNavigateAfterExpenseCreate).toHaveBeenCalledTimes(1);
-            expect(mockCleanupAndNavigateAfterExpenseCreate).toHaveBeenCalledWith(
+            expect(mockCleanupAndNavigateAfterExpenseCreate).not.toHaveBeenCalled();
+            expect(mockCleanupAfterExpenseCreate).toHaveBeenCalledTimes(1);
+            expect(mockCleanupAfterExpenseCreate).toHaveBeenCalledWith(
                 expect.objectContaining({
-                    transactionID: EXISTING_TRACKED_TRANSACTION_ID,
+                    linkedTrackedExpenseReportAction,
                 }),
             );
         });
 
-        // F2: requestMoney returns the chat it wrote to via {iouReport}; the UI reads that instead of re-deriving it through resolveChatTargetForSubmitCleanup.
-        it('uses iouReport.chatReportID for cleanup nav and does not re-derive it via resolveChatTargetForSubmitCleanup', async () => {
+        // The IOU action owns post-submit navigation now, so the hook no longer derives a chat target for cleanup nav.
+        it('does not derive the chat target via resolveChatTargetForSubmitCleanup (the IOU action owns post-submit nav)', async () => {
             mockRequestMoneyAction.mockReturnValue({iouReport: {reportID: 'iou-1', chatReportID: 'iou-chat-77'}});
 
             const {result} = renderHook(() => useExpenseSubmission(buildParams()));
@@ -278,7 +280,8 @@ describe('useExpenseSubmission orchestrator-suppressed cleanup', () => {
             await waitForBatchedUpdatesWithAct();
 
             expect(mockResolveChatTargetForSubmitCleanup).not.toHaveBeenCalled();
-            expect(mockCleanupAndNavigateAfterExpenseCreate).toHaveBeenCalledWith(expect.objectContaining({optimisticChatReportID: 'iou-chat-77'}));
+            expect(mockCleanupAndNavigateAfterExpenseCreate).not.toHaveBeenCalled();
+            expect(mockCleanupAfterExpenseCreate).toHaveBeenCalledTimes(1);
         });
 
         it('routes tracked per diem SUBMIT through requestMoney so the original tracked expense is moved', async () => {
@@ -350,7 +353,7 @@ describe('useExpenseSubmission orchestrator-suppressed cleanup', () => {
             expect(mockCleanupAndNavigateAfterExpenseCreate).not.toHaveBeenCalled();
         });
 
-        it('calls cleanupAndNavigateAfterExpenseCreate when shouldHandleNavigation=true', async () => {
+        it('does cleanup-only and never cleanupAndNavigateAfterExpenseCreate when shouldHandleNavigation=true (IOU action owns nav/growl)', async () => {
             const {result} = renderHook(() => useExpenseSubmission(buildParams({iouType: CONST.IOU.TYPE.TRACK})));
             await waitForBatchedUpdatesWithAct();
 
@@ -360,8 +363,8 @@ describe('useExpenseSubmission orchestrator-suppressed cleanup', () => {
             await waitForBatchedUpdatesWithAct();
 
             expect(mockTrackExpenseAction).toHaveBeenCalledTimes(1);
-            expect(mockCleanupAndNavigateAfterExpenseCreate).toHaveBeenCalledTimes(1);
-            expect(mockCleanupAfterExpenseCreate).not.toHaveBeenCalled();
+            expect(mockCleanupAfterExpenseCreate).toHaveBeenCalledTimes(1);
+            expect(mockCleanupAndNavigateAfterExpenseCreate).not.toHaveBeenCalled();
         });
 
         it('forwards the per-iteration draft as existingTransaction so getTrackExpenseInformation finds it', async () => {
diff --git a/tests/unit/useSearchHighlightAndScrollTest.ts b/tests/unit/useSearchAutoRefetchTest.ts
similarity index 50%
rename from tests/unit/useSearchHighlightAndScrollTest.ts
rename to tests/unit/useSearchAutoRefetchTest.ts
index 9a7c3e4680e8..2c50a3e5c1c7 100644
--- a/tests/unit/useSearchHighlightAndScrollTest.ts
+++ b/tests/unit/useSearchAutoRefetchTest.ts
@@ -1,8 +1,8 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import {renderHook} from '@testing-library/react-native';
 import Onyx from 'react-native-onyx';
-import useSearchHighlightAndScroll from '@hooks/useSearchHighlightAndScroll';
-import type {UseSearchHighlightAndScroll} from '@hooks/useSearchHighlightAndScroll';
+import useSearchAutoRefetch from '@hooks/useSearchAutoRefetch';
+import type {UseSearchAutoRefetch} from '@hooks/useSearchAutoRefetch';
 import {search} from '@libs/actions/Search';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
@@ -25,14 +25,14 @@ afterEach(() => {
     jest.clearAllMocks();
 });
 
-describe('useSearchHighlightAndScroll', () => {
+describe('useSearchAutoRefetch', () => {
     beforeAll(async () => {
         Onyx.init({
             keys: ONYXKEYS,
         });
     });
 
-    const baseProps: UseSearchHighlightAndScroll = {
+    const baseProps: UseSearchAutoRefetch = {
         shouldUseLiveData: false,
         searchResults: {
             data: {
@@ -70,7 +70,7 @@ describe('useSearchHighlightAndScroll', () => {
     };
 
     it('should not trigger search when collections are empty', () => {
-        renderHook(() => useSearchHighlightAndScroll(baseProps));
+        renderHook(() => useSearchAutoRefetch(baseProps));
         expect(search).not.toHaveBeenCalled();
     });
 
@@ -81,7 +81,7 @@ describe('useSearchHighlightAndScroll', () => {
             previousTransactions: {'1': {transactionID: '1'}},
         };
 
-        const {rerender} = renderHook((props: UseSearchHighlightAndScroll) => useSearchHighlightAndScroll(props), {
+        const {rerender} = renderHook((props: UseSearchAutoRefetch) => useSearchAutoRefetch(props), {
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-expect-error
             initialProps,
@@ -105,7 +105,7 @@ describe('useSearchHighlightAndScroll', () => {
     it('should not trigger search when not focused', () => {
         mockUseIsFocused.mockReturnValue(false);
 
-        const {rerender} = renderHook((props: UseSearchHighlightAndScroll) => useSearchHighlightAndScroll(props), {
+        const {rerender} = renderHook((props: UseSearchAutoRefetch) => useSearchAutoRefetch(props), {
             initialProps: baseProps,
         });
 
@@ -138,7 +138,7 @@ describe('useSearchHighlightAndScroll', () => {
             },
         };
 
-        const {rerender} = renderHook((props: UseSearchHighlightAndScroll) => useSearchHighlightAndScroll(props), {
+        const {rerender} = renderHook((props: UseSearchAutoRefetch) => useSearchAutoRefetch(props), {
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-expect-error
             initialProps: chatProps,
@@ -173,7 +173,7 @@ describe('useSearchHighlightAndScroll', () => {
             },
         };
 
-        const {rerender} = renderHook((props: UseSearchHighlightAndScroll) => useSearchHighlightAndScroll(props), {
+        const {rerender} = renderHook((props: UseSearchAutoRefetch) => useSearchAutoRefetch(props), {
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-expect-error
             initialProps,
@@ -212,7 +212,7 @@ describe('useSearchHighlightAndScroll', () => {
             },
         };
 
-        const {rerender} = renderHook((props: UseSearchHighlightAndScroll) => useSearchHighlightAndScroll(props), {
+        const {rerender} = renderHook((props: UseSearchAutoRefetch) => useSearchAutoRefetch(props), {
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-expect-error
             initialProps: chatProps,
@@ -232,157 +232,4 @@ describe('useSearchHighlightAndScroll', () => {
         rerender(updatedProps);
         expect(search).not.toHaveBeenCalled();
     });
-
-    it('should return multiple new search result keys when there are multiple new expenses', () => {
-        const {rerender, result} = renderHook((props: UseSearchHighlightAndScroll) => useSearchHighlightAndScroll(props), {
-            initialProps: baseProps,
-        });
-        const updatedProps = {
-            ...baseProps,
-            searchResults: {
-                ...baseProps.searchResults,
-                data: {
-                    transactions_1: {
-                        transactionID: '1',
-                    },
-                    transactions_2: {
-                        transactionID: '2',
-                    },
-                },
-            },
-            transactions: {
-                '1': {transactionID: '1'},
-                '2': {transactionID: '2'},
-                '3': {transactionID: '3'},
-            },
-            previousTransactions: {
-                '1': {transactionID: '1'},
-            },
-        };
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-expect-error
-        rerender(updatedProps);
-        expect(result.current.newSearchResultKeys?.size).toBe(2);
-    });
-
-    it('should return new search result keys for manually highlighted expenses', async () => {
-        const spyOnMergeTransactionIdsHighlightOnSearchRoute = jest
-            .spyOn(require('@libs/actions/Transaction'), 'mergeTransactionIdsHighlightOnSearchRoute')
-            .mockImplementationOnce(jest.fn());
-        // We need to mock requestAnimationFrame to mimic long Onyx merge overhead
-        jest.spyOn(global, 'requestAnimationFrame').mockImplementation((callback: FrameRequestCallback) => {
-            callback(performance.now());
-            return 0;
-        });
-
-        await Onyx.merge(ONYXKEYS.TRANSACTION_IDS_HIGHLIGHT_ON_SEARCH_ROUTE, {[baseProps.queryJSON.type]: {'3': true}});
-
-        const {rerender, result} = renderHook((props: UseSearchHighlightAndScroll) => useSearchHighlightAndScroll(props), {
-            initialProps: baseProps,
-        });
-        const updatedProps1 = {
-            ...baseProps,
-            searchResults: {
-                ...baseProps.searchResults,
-                data: {
-                    transactions_1: {
-                        transactionID: '1',
-                    },
-                    transactions_2: {
-                        transactionID: '2',
-                    },
-                },
-            },
-            transactions: {
-                '1': {transactionID: '1'},
-                '2': {transactionID: '2'},
-                '3': {transactionID: '3'},
-            },
-            previousTransactions: {
-                '1': {transactionID: '1'},
-            },
-        } as unknown as UseSearchHighlightAndScroll;
-
-        // When there is no data yet, even if the transactionID has been added to manual highlight transactionIDs,
-        // it still will not be included in newSearchResultKeys.
-        rerender(updatedProps1);
-        expect(result.current.newSearchResultKeys?.size).toBe(2);
-        expect([...(result.current.newSearchResultKeys ?? new Set())]).not.toContain('transactions_3');
-
-        // When the data contains the highlight transactionID, it will be highlighted.
-        const updatedProps2 = {
-            ...updatedProps1,
-            searchResults: {
-                ...updatedProps1.searchResults,
-                data: {
-                    transactions_1: {
-                        transactionID: '1',
-                    },
-                    transactions_2: {
-                        transactionID: '2',
-                    },
-                    transactions_3: {
-                        transactionID: '3',
-                    },
-                },
-            },
-        } as unknown as UseSearchHighlightAndScroll;
-
-        rerender(updatedProps2);
-        expect(result.current.newSearchResultKeys?.size).toBe(1);
-        expect([...(result.current.newSearchResultKeys ?? new Set())]).toContain('transactions_3');
-
-        expect(spyOnMergeTransactionIdsHighlightOnSearchRoute).toHaveBeenCalledWith(baseProps.queryJSON.type, {'3': false});
-    });
-
-    it('should return multiple new search result keys when there are multiple new chats', () => {
-        const chatProps = {
-            ...baseProps,
-            queryJSON: {...baseProps.queryJSON, type: 'chat' as const},
-            reportActions: {
-                reportActions_1: {
-                    '1': {actionName: 'EXISTING', reportActionID: '1'},
-                },
-            },
-        };
-        const {rerender, result} = renderHook((props: UseSearchHighlightAndScroll) => useSearchHighlightAndScroll(props), {
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-expect-error
-            initialProps: chatProps,
-        });
-        const updatedProps = {
-            ...chatProps,
-            searchResults: {
-                ...baseProps.searchResults,
-                data: {
-                    reportActions_1: {
-                        '1': {actionName: 'EXISTING', reportActionID: '1'},
-                    },
-                    reportActions_2: {
-                        '2': {actionName: 'EXISTING', reportActionID: '2'},
-                    },
-                },
-            },
-            reportActions: {
-                reportActions_1: {
-                    '1': {actionName: 'EXISTING', reportActionID: '1'},
-                },
-                reportActions_2: {
-                    '2': {actionName: 'EXISTING', reportActionID: '2'},
-                },
-                reportActions_3: {
-                    '3': {actionName: 'EXISTING', reportActionID: '3'},
-                },
-            },
-            previousReportActions: {
-                reportActions_1: {
-                    '1': {actionName: 'EXISTING', reportActionID: '1'},
-                },
-            },
-        };
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-expect-error
-        rerender(updatedProps);
-        expect(result.current.newSearchResultKeys?.size).toBe(2);
-    });
 });