Show New message marker when a user marks their own message as unread

src/components/MoneyRequestReportView/MoneyRequestReportActionsList.tsx

@@ -453,6 +453,7 @@ function MoneyRequestReportActionsList({onLayout}: MoneyRequestReportListProps)
         isScrolledOverThreshold: scrollingVerticalBottomOffset.current >= CONST.REPORT.ACTIONS.ACTION_VISIBLE_THRESHOLD,
         isOffline,
         isReversed: true,
+        manuallyMarkedUnreadReportActionID: report?.manuallyMarkedUnreadReportActionID,
         hasWindowFocus: Visibility.hasFocus(),
     });
 

src/hooks/useUnreadMarker.ts

@@ -45,6 +45,7 @@ type UseUnreadMarkerResult = {
 };
 
 const lastReadTimeSelector = (report: OnyxTypes.Report | undefined) => report?.lastReadTime ?? '';
+const manuallyMarkedUnreadReportActionIDSelector = (report: OnyxTypes.Report | undefined) => report?.manuallyMarkedUnreadReportActionID ?? null;
 
 function useUnreadMarker({
     reportID,
@@ -64,6 +65,10 @@ function useUnreadMarker({
     });
     const reportLastReadTime = reportLastReadTimeValue ?? '';
 
+    const [manuallyMarkedUnreadReportActionID] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT}${reportID}`, {
+        selector: manuallyMarkedUnreadReportActionIDSelector,
+    });
+
     const [unreadMarkerTime, setUnreadMarkerTime] = useState(reportLastReadTime);
 
     useEffect(() => {
@@ -121,6 +126,7 @@ function useUnreadMarker({
         isReversed: false,
         isAnonymousUser,
         prevUnreadMarkerReportActionID,
+        manuallyMarkedUnreadReportActionID,
         hasWindowFocus: Visibility.hasFocus(),
     });
     // Pagination is anchored to the oldest unread on first open; that anchor does not change when the user

src/libs/DebugUtils.ts

@@ -437,6 +437,7 @@ function validateReportDraftProperty(key: keyof Report | keyof ReportNameValuePa
         case 'lastMessageText':
         case 'lastVisibleActionCreated':
         case 'lastReadTime':
+        case 'manuallyMarkedUnreadReportActionID':
         case 'lastMentionedTime':
         case 'policyAvatar':
         case 'policyName':
@@ -611,6 +612,7 @@ function validateReportDraftProperty(key: keyof Report | keyof ReportNameValuePa
                 lastMessageText: CONST.RED_BRICK_ROAD_PENDING_ACTION,
                 lastVisibleActionCreated: CONST.RED_BRICK_ROAD_PENDING_ACTION,
                 lastReadTime: CONST.RED_BRICK_ROAD_PENDING_ACTION,
+                manuallyMarkedUnreadReportActionID: CONST.RED_BRICK_ROAD_PENDING_ACTION,
                 lastReadSequenceNumber: CONST.RED_BRICK_ROAD_PENDING_ACTION,
                 lastMentionedTime: CONST.RED_BRICK_ROAD_PENDING_ACTION,
                 policyAvatar: CONST.RED_BRICK_ROAD_PENDING_ACTION,

src/libs/actions/Report/index.ts

@@ -2855,6 +2855,7 @@ function readNewestAction(reportID: string | undefined, isReportActionsLoaded: b
             key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
             value: {
                 lastReadTime,
+                manuallyMarkedUnreadReportActionID: null,
             },
         },
     ];
@@ -2931,6 +2932,7 @@ function markCommentAsUnread(reportID: string | undefined, reportActions: OnyxEn
 
     const reportValue = {
         lastReadTime,
+        manuallyMarkedUnreadReportActionID: reportAction?.reportActionID ?? null,
         ...(lastActorAccountID && {lastActorAccountID}),
     };
 
@@ -2957,6 +2959,7 @@ function markCommentAsUnread(reportID: string | undefined, reportActions: OnyxEn
             value: {
                 lastReadTime: report?.lastReadTime ?? null,
                 lastActorAccountID: report?.lastActorAccountID ?? null,
+                manuallyMarkedUnreadReportActionID: report?.manuallyMarkedUnreadReportActionID ?? null,
             },
         },
     ];

src/pages/inbox/report/shouldDisplayNewMarkerOnReportAction.ts

@@ -30,6 +30,9 @@ type ShouldDisplayNewMarkerOnReportActionParams = {
 
     /** The reportActionID of the current unread marker, if one exists */
     prevUnreadMarkerReportActionID?: string | null;
+
+    /** The reportActionID the user explicitly marked as unread, if any */
+    manuallyMarkedUnreadReportActionID?: string | null;
     /** Whether the app window is focused */
     hasWindowFocus?: boolean;
 };
@@ -48,6 +51,7 @@ const shouldDisplayNewMarkerOnReportAction = ({
     isScrolledOverThreshold,
     isOffline,
     prevUnreadMarkerReportActionID,
+    manuallyMarkedUnreadReportActionID,
     hasWindowFocus = true,
 }: ShouldDisplayNewMarkerOnReportActionParams): boolean => {
     const isNextMessageUnread = !!nextMessage && isReportActionUnread(nextMessage, unreadMarkerTime);
@@ -62,6 +66,17 @@ const shouldDisplayNewMarkerOnReportAction = ({
         return false;
     }
 
+    // The user explicitly marked THIS action as unread. Anchor the marker here regardless of the
+    // timestamp-based check below: once an optimistic self-message confirms, unreadMarkerTime,
+    // lastReadTime, and created all converge on (or drift past) the confirmed `created`, so
+    // isReportActionUnread wrongly reports it as read. The stored reportActionID is the only signal
+    // stable across that transition. The marked action is the oldest unread by construction
+    // (markCommentAsUnread sets lastReadTime = its created - 1ms), so it remains the correct anchor
+    // even when newer messages arrive after the mark.
+    if (!!manuallyMarkedUnreadReportActionID && message.reportActionID === manuallyMarkedUnreadReportActionID) {
+        return true;
+    }
+
     const isCurrentMessageUnread = isReportActionUnread(message, unreadMarkerTime);
 
     // If the current message is read or the next message is unread, don't show the unread marker.
@@ -84,12 +99,19 @@ const shouldDisplayNewMarkerOnReportAction = ({
     const isPreviouslyOptimistic =
         (isPendingAdd(prevSortedVisibleReportActionsObjects[message.reportActionID]) && !isPendingAdd(message)) ||
         (!!prevSortedVisibleReportActionsObjects[message.reportActionID]?.isOptimisticAction && !message.isOptimisticAction);
-    const shouldIgnoreUnreadForCurrentUserMessage = isNewMessage || isPreviouslyOptimistic;
+    // While a manual mark-as-unread is active, the marked action is the sole anchor (handled by the
+    // `manuallyMarkedUnreadReportActionID` check above, which returns before this branch). Ignore unread
+    // for every *other* self-authored message so a newer self-message sent after the mark can't steal the
+    // marker off the marked one. When no manual mark exists this term is false, so #91940 behavior is unchanged.
+    const shouldIgnoreUnreadForCurrentUserMessage = isNewMessage || isPreviouslyOptimistic || !!manuallyMarkedUnreadReportActionID;
 
     if (isFromCurrentUser) {
-        // When an existing marker is being relocated (e.g. after the original unread message is deleted),
-        // allow the marker to land on a self-authored action.
-        // Otherwise, never anchor the "New" marker above a self-authored action on first open/re-entry.
+        // For a self-authored action, only move/keep the "New" marker when one already exists in this session
+        // (`prevUnreadMarkerReportActionID` is set). The explicit mark-as-unread case is handled earlier by the
+        // stable `manuallyMarkedUnreadReportActionID` check, which anchors the marker on first open/re-entry
+        // regardless of this guard. Without this guard, a persisted self-authored action (e.g. a reimbursable
+        // toggle) whose timestamps have drifted past `lastReadTime` would wrongly show the marker on a cold
+        // open/re-entry — the regression from Expensify/App#91940.
         if (prevUnreadMarkerReportActionID) {
             return !shouldIgnoreUnreadForCurrentUserMessage;
         }
@@ -131,6 +153,9 @@ type GetUnreadMarkerReportActionParams = {
 
     /** The reportActionID of the current unread marker, if one exists */
     prevUnreadMarkerReportActionID?: string | null;
+
+    /** The reportActionID the user explicitly marked as unread, if any */
+    manuallyMarkedUnreadReportActionID?: string | null;
     /** Whether the app window is focused */
     hasWindowFocus?: boolean;
 };
@@ -150,6 +175,7 @@ const getUnreadMarkerReportAction = ({
     isReversed,
     isAnonymousUser = false,
     prevUnreadMarkerReportActionID,
+    manuallyMarkedUnreadReportActionID,
     hasWindowFocus = true,
 }: GetUnreadMarkerReportActionParams): [string | null, number] => {
     if (isAnonymousUser) {
@@ -191,6 +217,7 @@ const getUnreadMarkerReportAction = ({
                 isScrolledOverThreshold,
                 isOffline,
                 prevUnreadMarkerReportActionID,
+                manuallyMarkedUnreadReportActionID,
                 hasWindowFocus,
             });
 

src/selectors/Report.ts

@@ -113,6 +113,7 @@ type ExcludedFields = ValidReportKeys<
         'lastMessageText',
         'lastVisibleActionCreated',
         'lastReadTime',
+        'manuallyMarkedUnreadReportActionID',
         'lastReadSequenceNumber',
         'lastMentionedTime',
         'lastVisibleActionLastModified',

src/types/onyx/Report.ts

@@ -133,6 +133,10 @@ type Report = OnyxCommon.OnyxValueWithOfflineFeedback<
         /** The time when user read the last message */
         lastReadTime?: string;
 
+        /** reportActionID the user explicitly marked as unread. Stable across the optimistic→confirmed
+         *  transition, unlike lastReadTime, so the "New" marker can anchor on a self-authored action. */
+        manuallyMarkedUnreadReportActionID?: string | null;
+
         /** The sequence number of the last report visit */
         lastReadSequenceNumber?: number;
 

src/types/utils/whitelistedReportKeys.ts

@@ -15,6 +15,7 @@ type WhitelistedReport = OnyxCommon.OnyxValueWithOfflineFeedback<
         lastMessageText: unknown;
         lastVisibleActionCreated: unknown;
         lastReadTime: unknown;
+        manuallyMarkedUnreadReportActionID: unknown;
         lastReadSequenceNumber: unknown;
         lastMentionedTime: unknown;
         policyAvatar: unknown;

tests/unit/ReportActionsUtilsTest.ts

@@ -5471,7 +5471,11 @@ describe('ReportActionsUtils', () => {
             ).toBe(false);
         });
 
-        it('returns false when message is from current user and is already present (not new, not optimistic) and no existing marker', () => {
+        it('returns false for a self-authored already-present action on a cold open when no marker exists and it was not explicitly marked unread (Expensify/App#91940 guard)', () => {
+            // A persisted self-authored action (e.g. a reimbursable toggle) whose timestamp reads as unread must
+            // NOT anchor the marker on a cold open/re-entry, where prevUnreadMarkerReportActionID is null. The
+            // explicit mark-as-unread case is handled separately via manuallyMarkedUnreadReportActionID (covered
+            // by the tests below), so this guard prevents the #91940 regression without affecting it.
             const message = makeAction({actorAccountID: currentUserAccountID, reportActionID: 'existing-action-id'});
             const prevSortedVisibleReportActionsObjects = {
                 [message.reportActionID]: makeAction({actorAccountID: currentUserAccountID, reportActionID: 'existing-action-id'}),
@@ -5544,6 +5548,68 @@ describe('ReportActionsUtils', () => {
                 }),
             ).toBe(true);
         });
+
+        it('anchors the marker on the explicitly marked-unread action even after its confirmed created drifts before unreadMarkerTime', () => {
+            // Simulates the offline→online case: an optimistic self-message the user marked unread confirms
+            // with a `created` that lands before unreadMarkerTime, so the timestamp check reads it as "read".
+            // The stable manuallyMarkedUnreadReportActionID must still anchor the marker here.
+            const message = makeAction({actorAccountID: currentUserAccountID, reportActionID: 'marked-action-id', pendingAction: null, created: '2023-01-01 09:00:00.000'});
+            const prevSortedVisibleReportActionsObjects = {
+                [message.reportActionID]: makeAction({
+                    actorAccountID: currentUserAccountID,
+                    reportActionID: 'marked-action-id',
+                    pendingAction: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
+                }),
+            };
+            expect(
+                shouldDisplayNewMarkerOnReportAction({
+                    ...baseParams,
+                    message,
+                    prevSortedVisibleReportActionsObjects,
+                    manuallyMarkedUnreadReportActionID: 'marked-action-id',
+                    isOffline: false,
+                }),
+            ).toBe(true);
+        });
+
+        it('does not anchor the marker on a just-sent self-message when no action is marked unread', () => {
+            // Same confirmed self-message, but nothing is marked unread. The stable-id override is skipped and
+            // the existing just-sent suppression applies, keeping the #91443 fix intact.
+            const message = makeAction({actorAccountID: currentUserAccountID, reportActionID: 'confirmed-action-id', pendingAction: null});
+            const prevSortedVisibleReportActionsObjects = {
+                [message.reportActionID]: makeAction({
+                    actorAccountID: currentUserAccountID,
+                    reportActionID: 'confirmed-action-id',
+                    pendingAction: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
+                }),
+            };
+            expect(
+                shouldDisplayNewMarkerOnReportAction({
+                    ...baseParams,
+                    message,
+                    prevSortedVisibleReportActionsObjects,
+                    manuallyMarkedUnreadReportActionID: null,
+                    isOffline: false,
+                }),
+            ).toBe(false);
+        });
+
+        it('keeps the marker on the explicitly marked-unread action even when a newer message is present', () => {
+            // The marked action is the oldest unread by construction (lastReadTime = its created - 1ms), so it
+            // stays the anchor regardless of an adjacent unread message — a newer message arriving after the mark
+            // must not steal the marker off the message the user deliberately marked unread.
+            const message = makeAction({actorAccountID: currentUserAccountID, reportActionID: 'marked-action-id', created: '2023-01-01 11:00:00.000'});
+            const nextMessage = makeAction({created: '2023-01-01 11:30:00.000'});
+            expect(
+                shouldDisplayNewMarkerOnReportAction({
+                    ...baseParams,
+                    message,
+                    nextMessage,
+                    manuallyMarkedUnreadReportActionID: 'marked-action-id',
+                    isOffline: false,
+                }),
+            ).toBe(true);
+        });
     });
 
     describe('getUnreadMarkerReportAction', () => {