[$500] LHN - Report Remains Marked as Unread After Returning Online Despite Message Being Read Offline

[lanitochka17]

If you haven’t already, check out our contributing guidelines for onboarding and email contributors@expensify.com to request to join our Slack channel!

---

Version Number: v9.3.4-0
Reproducible in staging?: Yes
Reproducible in production?: Yes
If this was caught during regression testing, add the test name, ID and link from BrowserStack: #79632
Email or phone of affected tester (no customers): applausetester+dp501@applause.expensifail.com
Issue reported by: Applause Internal Team
Bug source: Pull Request QA execution
Device used: Mac / Safari
App Component: Left Hand Navigation (LHN)

Action Performed:

1. Create a report with multiple expense items.
2. Open the report.
3. Switch the app to offline mode.
4. Send several messages within the report.
5. Mark the last message as unread.
6. Navigate to the Inbox, then reopen the same report so the message becomes marked as read.
7. Open any other report.
8. Switch the app back online.

Expected Result:

The report should be displayed as read in the LHN, since the message was opened and read before going online.

Actual Result:

After returning online, the report is displayed as unread (bold) in the LHN, even though the message was previously read.

Workaround:

Unknown

Platforms:

• Android: App
• Android: mWeb Chrome
• iOS: App
• iOS: mWeb Safari
• iOS: mWeb Chrome
• Windows: Chrome
• MacOS: Chrome / Safari

Screenshots/Videos

Bug7051514_1768614481972.5_36_PM_2026-01-16.mp4

View all open jobs on GitHub

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022014478668144857937
• Upwork Job ID: 2014478668144857937
• Last Price Increase: 2026-02-25
• Automatic offers:
• situchan | Contributor | 110268112

Issue Owner

Current Issue Owner: @abdulrahuman5196

[melvin-bot]

Triggered auto assignment to @stephanieelliott (Bug), see https://stackoverflow.com/c/expensify/questions/14418 for more details. Please add this bug to a GH project, as outlined in the SO.

[annaweber830]

Proposal

Please re-state the problem that we are trying to solve in this issue.

When a workspace is renamed, the corresponding #announce room label in Search recent chats does not refresh immediately and keeps showing the previous workspace name. Users should see the updated workspace name in recent chats as soon as the rename happens.

What is the root cause of that problem?

The cached options used by Search are updated from report and report-action collection deltas, not from policy deltas, so a policy-name-only change can leave the rendered option stale.

App/src/components/OptionListContextProvider.tsx

Lines 54 to 56 in 8af1e14

	const [reports, {sourceValue: changedReports}] = useOnyx(ONYXKEYS.COLLECTION.REPORT);
	const prevReports = usePrevious(reports);
	const [, {sourceValue: changedReportActions}] = useOnyx(ONYXKEYS.COLLECTION.REPORT_ACTIONS);

const [reports, {sourceValue: changedReports}] = useOnyx(ONYXKEYS.COLLECTION.REPORT);
const prevReports = usePrevious(reports);
const [, {sourceValue: changedReportActions}] = useOnyx(ONYXKEYS.COLLECTION.REPORT_ACTIONS);

App/src/components/OptionListContextProvider.tsx

Lines 111 to 141 in 8af1e14

	useEffect(() => {
	if (!changedReportsEntries || !areOptionsInitialized.current) {
	return;
	}
	setOptions((prevOptions) => {
	const changedReportKeys = Object.keys(changedReportsEntries);
	if (changedReportKeys.length === 0) {
	return prevOptions;
	}
	const updatedReportsMap = new Map(prevOptions.reports.filter((report) => report && report.reportID).map((report) => [report.reportID, report]));
	for (const reportKey of changedReportKeys) {
	const report = changedReportsEntries[reportKey];
	const reportID = reportKey.replace(ONYXKEYS.COLLECTION.REPORT, '');
	const privateIsArchived = privateIsArchivedMap[`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${reportID}`];
	const {reportOption} = processReport(report, personalDetails, privateIsArchived, currentUserAccountID, reportAttributes?.reports);
	if (reportOption) {
	updatedReportsMap.set(reportID, reportOption);
	} else {
	updatedReportsMap.delete(reportID);
	}
	}
	return {
	...prevOptions,
	reports: Array.from(updatedReportsMap.values()),
	};
	});
	}, [changedReportsEntries, personalDetails, currentUserAccountID, reportAttributes?.reports, privateIsArchivedMap]);

useEffect(() => {
    if (!changedReportsEntries || !areOptionsInitialized.current) {
        return;
    }

    setOptions((prevOptions) => {
        const changedReportKeys = Object.keys(changedReportsEntries);
        if (changedReportKeys.length === 0) {
            return prevOptions;
        }
        // ...rebuild only changed report options
    });
}, [changedReportsEntries, personalDetails, currentUserAccountID, reportAttributes?.reports, privateIsArchivedMap]);

updateWorkspaceGeneralSettings() currently merges the new policy name into policy_{policyID} only, which causes this issue because search option entries for workspace chats are not recalculated unless the related report objects also change.

What changes do you think we should make in order to solve the problem?

Update updateWorkspaceGeneralSettings() to also merge policyName into every workspace report (report_{reportID}) for that policy in both optimistic and failure paths. This reuses the existing report-delta driven update path in OptionListContextProvider, so the recent chat label refreshes immediately after a workspace rename.

App/src/libs/actions/Policy/Policy.ts

Lines 1879 to 1905 in 8af1e14

	const persistedRequests = PersistedRequests.getAll();
	const createWorkspaceRequestChangedIndex = persistedRequests.findIndex(
	(request) => request.data?.policyID === policyID && request.command === WRITE_COMMANDS.CREATE_WORKSPACE && request.data?.policyName !== name,
	);
	const createWorkspaceRequest = persistedRequests.at(createWorkspaceRequestChangedIndex);
	if (createWorkspaceRequest && createWorkspaceRequestChangedIndex !== -1) {
	const workspaceRequest = {
	...createWorkspaceRequest,
	data: {
	...createWorkspaceRequest.data,
	policyName: name,
	},
	};
	Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${policyID}`, {
	name,
	});
	PersistedRequests.update(createWorkspaceRequestChangedIndex, workspaceRequest);
	return;
	}
	API.write(WRITE_COMMANDS.UPDATE_WORKSPACE_GENERAL_SETTINGS, params, {
	optimisticData,
	finallyData,
	failureData,
	});

Current code:

const persistedRequests = PersistedRequests.getAll();
const createWorkspaceRequestChangedIndex = persistedRequests.findIndex(
    (request) => request.data?.policyID === policyID && request.command === WRITE_COMMANDS.CREATE_WORKSPACE && request.data?.policyName !== name,
);

const createWorkspaceRequest = persistedRequests.at(createWorkspaceRequestChangedIndex);
if (createWorkspaceRequest && createWorkspaceRequestChangedIndex !== -1) {
    const workspaceRequest = {
        ...createWorkspaceRequest,
        data: {
            ...createWorkspaceRequest.data,
            policyName: name,
        },
    };
    Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${policyID}`, {
        name,
    });

    PersistedRequests.update(createWorkspaceRequestChangedIndex, workspaceRequest);
    return;
}

API.write(WRITE_COMMANDS.UPDATE_WORKSPACE_GENERAL_SETTINGS, params, {
    optimisticData,
    finallyData,
    failureData,
});

Updated code:

const workspaceReports = namePendingAction ? ReportUtils.getAllWorkspaceReports(policyID) : [];
const reportOptimisticData: OnyxUpdate[] = workspaceReports
    .filter((report): report is Report => !!report?.reportID)
    .map((report) => ({
        onyxMethod: Onyx.METHOD.MERGE,
        key: `${ONYXKEYS.COLLECTION.REPORT}${report.reportID}`,
        value: {policyName: name},
    }));
const reportFailureData: OnyxUpdate[] = workspaceReports
    .filter((report): report is Report => !!report?.reportID)
    .map((report) => ({
        onyxMethod: Onyx.METHOD.MERGE,
        key: `${ONYXKEYS.COLLECTION.REPORT}${report.reportID}`,
        value: {policyName: policy?.name ?? null},
    }));

const persistedRequests = PersistedRequests.getAll();
const createWorkspaceRequestChangedIndex = persistedRequests.findIndex(
    (request) => request.data?.policyID === policyID && request.command === WRITE_COMMANDS.CREATE_WORKSPACE && request.data?.policyName !== name,
);

const createWorkspaceRequest = persistedRequests.at(createWorkspaceRequestChangedIndex);
if (createWorkspaceRequest && createWorkspaceRequestChangedIndex !== -1) {
    const workspaceRequest = {
        ...createWorkspaceRequest,
        data: {
            ...createWorkspaceRequest.data,
            policyName: name,
        },
    };
    Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${policyID}`, {name});
    if (reportOptimisticData.length) {
        Onyx.update(reportOptimisticData);
    }
    PersistedRequests.update(createWorkspaceRequestChangedIndex, workspaceRequest);
    return;
}

API.write(WRITE_COMMANDS.UPDATE_WORKSPACE_GENERAL_SETTINGS, params, {
    optimisticData: [...optimisticData, ...reportOptimisticData],
    finallyData,
    failureData: [...failureData, ...reportFailureData],
});

This is a minimal fix in the workspace-rename flow, avoids broad option-list recomputation on every policy mutation, and directly updates the report fields that Search uses for recent chat labels.

What alternative solutions did you explore? (Optional)

Adding a policy subscription in OptionListContextProvider and calling loadOptions() when any policy name changes. I did not choose this because it broadens recomputation scope for all policy updates, while updating workspace reports in the rename action is narrower and aligns with existing report-driven option updates.

[melvin-bot]

Job added to Upwork: https://www.upwork.com/jobs/~022014478668144857937

[melvin-bot]

Triggered auto assignment to Contributor-plus team member for initial proposal review - @abdulrahuman5196 (External)

[marufsharifi]

Proposal

Please re-state the problem that we are trying to solve in this issue.

When a user reads a report while offline, the report can reappear as unread (bold in LHN) after reconnecting, even though the user already read it before going online.

What is the root cause of that problem?

This is caused by a timestamp-only unread check combined with delayed offline request replay:

1. ReadNewestAction captures lastReadTime at offline read-time and queues that value for later send:

App/src/libs/actions/Report/index.ts

Lines 1923 to 1950 in 1e72ec1

	function readNewestAction(reportID: string | undefined, shouldResetUnreadMarker = false) {
	if (!reportID) {
	return;
	}
	const lastReadTime = NetworkConnection.getDBTimeWithSkew();
	const optimisticData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT>> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
	value: {
	lastReadTime,
	},
	},
	];
	const parameters: ReadNewestActionParams = {
	reportID,
	lastReadTime,
	};
	API.writeWithNoDuplicatesConflictAction(
	WRITE_COMMANDS.READ_NEWEST_ACTION,
	parameters,
	{optimisticData},
	(request) => request.command === WRITE_COMMANDS.READ_NEWEST_ACTION && request.data?.reportID === parameters.reportID,
	);

2. The request is marked as initiatedOffline and replayed later when online:

App/src/libs/API/index.ts

Lines 119 to 123 in 1e72ec1

	const request: SetRequired<OnyxRequest<TKey>, 'data'> = {
	command,
	data,
	initiatedOffline: isOffline(),
	requestID: requestIndex++,

SequentialQueue.ts

App/src/libs/Network/SequentialQueue.ts

Lines 171 to 194 in 1e72ec1

	const requestToProcess = processNextPersistedRequest();
	if (!requestToProcess) {
	Log.info('[SequentialQueue] Unable to process. No next request to handle.');
	return Promise.resolve();
	}
	Log.info('[SequentialQueue] Starting to process request', false, {
	command: requestToProcess.command,
	isRollback: requestToProcess.isRollback ?? false,
	persistWhenOngoing: requestToProcess.persistWhenOngoing ?? false,
	});
	currentProcessSpan = Sentry.startInactiveSpan({
	name: CONST.TELEMETRY.SPAN_SEQUENTIAL_QUEUE_PROCESS,
	op: CONST.TELEMETRY.SPAN_SEQUENTIAL_QUEUE_PROCESS,
	parentSpan: currentFlushSpan,
	attributes: {
	[CONST.TELEMETRY.ATTRIBUTE_COMMAND]: requestToProcess.command,
	},
	});
	// Set the current request to a promise awaiting its processing so that getCurrentRequest can be used to take some action after the current request has processed.
	currentRequestPromise = processWithMiddleware(requestToProcess, true)
	.then((response) => {

3. Unread state is derived by timestamp comparison (lastReadTime < lastVisibleActionCreated), so when synced message times end up newer, report becomes unread again:

App/src/libs/ReportUtils.ts

Lines 8873 to 8891 in 1e72ec1

	function isUnread(report: OnyxEntry<Report>, oneTransactionThreadReport: OnyxEntry<Report>, isReportArchived: boolean | undefined): boolean {
	if (!report) {
	return false;
	}
	if (isEmptyReport(report, isReportArchived)) {
	return false;
	}
	if (!report.lastReadTime) {
	return true;
	}
	// lastVisibleActionCreated and lastReadTime are both datetime strings and can be compared directly
	const lastVisibleActionCreated = getReportLastVisibleActionCreated(report, oneTransactionThreadReport);
	const lastReadTime = report.lastReadTime ?? '';
	const lastMentionedTime = report.lastMentionedTime ?? '';
	// If the user was mentioned and the comment got deleted the lastMentionedTime will be more recent than the lastVisibleActionCreated
	return lastReadTime < (lastVisibleActionCreated ?? '') || lastReadTime < lastMentionedTime;

What changes do you think we should make in order to solve the problem?

1: Update isUnread to avoid self-authored false-unread while preserving mentions

• Keep mention-based unread (lastMentionedTime) as highest priority.
• For non-mention unread, if latest visible action is by current user, treat as read.
• If latest visible action is by another user, keep unread behavior unchanged.

diff --git a/src/libs/ReportUtils.ts b/src/libs/ReportUtils.ts
@@ -8886,9 +8886,23 @@ function isUnread(report: OnyxEntry<Report>, oneTransactionThreadReport: OnyxEnt
     const lastVisibleActionCreated = getReportLastVisibleActionCreated(report, oneTransactionThreadReport);
     const lastReadTime = report.lastReadTime ?? '';
     const lastMentionedTime = report.lastMentionedTime ?? '';
+    const isUnreadByLastVisibleAction = lastReadTime < (lastVisibleActionCreated ?? '');
+    const isUnreadByMention = lastReadTime < lastMentionedTime;
 
-    // If the user was mentioned and the comment got deleted the lastMentionedTime will be more recent than the lastVisibleActionCreated
-    return lastReadTime < (lastVisibleActionCreated ?? '') || lastReadTime < lastMentionedTime;
+    if (isUnreadByMention) {
+        return true;
+    }
+
+    if (!isUnreadByLastVisibleAction) {
+        return false;
+    }
+
+    const lastActorAccountID = getReportLastActorAccountID(report, oneTransactionThreadReport);
+    if (currentUserAccountID && lastActorAccountID === currentUserAccountID) {
+        return false;
+    }
+
+    return true;
 }

2: Add helper to resolve latest actor across parent report vs transaction thread

• We already compare latest visible timestamps across report/thread.
• This helper returns the actor for whichever side is actually latest, so unread logic is accurate in thread cases.

diff --git a/src/libs/ReportUtils.ts b/src/libs/ReportUtils.ts
@@ -12161,6 +12175,17 @@ function getReportLastVisibleActionCreated(report: OnyxEntry<Report>, oneTransac
     return reportLastVisibleActionCreated > threadLastVisibleActionCreated ? reportLastVisibleActionCreated : threadLastVisibleActionCreated;
 }
 
+function getReportLastActorAccountID(report: OnyxEntry<Report>, oneTransactionThreadReport: OnyxEntry<Report>) {
+    const reportLastVisibleActionCreated = report?.lastVisibleActionCreated ?? '';
+    const threadLastVisibleActionCreated = oneTransactionThreadReport?.lastVisibleActionCreated ?? '';
+
+    if (threadLastVisibleActionCreated > reportLastVisibleActionCreated) {
+        return oneTransactionThreadReport?.lastActorAccountID ?? report?.lastActorAccountID;
+    }
+
+    return report?.lastActorAccountID ?? oneTransactionThreadReport?.lastActorAccountID;
+}

3: Add unit tests for bug + regression coverage

• Validates original bug scenario (self latest action should not force unread).
• Validates regression scenario (other-user latest action must remain unread).
• Validates mention behavior still works.
• Validates transaction-thread latest-action case.

diff --git a/tests/unit/ReportUtilsTest.ts b/tests/unit/ReportUtilsTest.ts
@@ -107,6 +107,7 @@ import {
     isReportIneligibleForMoveExpenses,
     isReportOutstanding,
     isRootGroupChat,
+    isUnread,
@@ -2579,6 +2580,74 @@ describe('ReportUtils', () => {
+    describe('isUnread', () => {
+        it('returns false when last unread-driving action is from current user', () => { ... });
+        it('returns true when last unread-driving action is from another user', () => { ... });
+        it('returns true when the latest visible action is in transaction thread and authored by another user', () => { ... });
+        it('returns true for mention even when latest action is from current user', () => { ... });
+    });

What alternative solutions did you explore? (Optional)

1. Queue-aware bounded ReadNewestAction reconciliation (FE-only)
   Keep isUnread() unchanged and adjust queued offline READ_NEWEST_ACTION payloads at replay-time.

• Scope only READ_NEWEST_ACTION requests with initiatedOffline === true.
• Recompute lastReadTime with a bounded rule:
  • reconciledLastReadTime = max(originalLastReadTime, latestOwnOfflineOutgoingMessageTimeForSameReportBeforeThisRead)
• Do not restamp to “now”.
• If no prior same-report offline outgoing message writes exist, keep the original lastReadTime.

changes needed:

diff --git a/src/libs/Network/SequentialQueue.ts b/src/libs/Network/SequentialQueue.ts
@@ function process(): Promise<void> {
     const requestToProcess = processNextPersistedRequest();
@@
+    if (requestToProcess.command === WRITE_COMMANDS.READ_NEWEST_ACTION && requestToProcess.initiatedOffline) {
+        const reportID = requestToProcess.data?.reportID;
+        const originalLastReadTime = requestToProcess.data?.lastReadTime ?? '';
+        const latestOwnOfflineOutgoingMessageTime = getLatestOwnOfflineOutgoingMessageTimeForReport(reportID, requestToProcess.requestID);
+
+        if (latestOwnOfflineOutgoingMessageTime && latestOwnOfflineOutgoingMessageTime > originalLastReadTime) {
+            requestToProcess.data = {
+                ...(requestToProcess.data ?? {}),
+                lastReadTime: latestOwnOfflineOutgoingMessageTime,
+            };
+        }
+    }

diff --git a/src/libs/Network/SequentialQueue.ts b/src/libs/Network/SequentialQueue.ts
@@
+function getLatestOwnOfflineOutgoingMessageTimeForReport(reportID: string, beforeRequestID: number): string | undefined {
+    // scan persisted requests up to beforeRequestID
+    // filter same reportID + initiatedOffline + outgoing message commands
+    // return max clientCreatedTime/created for those requests
+}

This addresses offline replay ordering by aligning read-time with already-queued same-report user message writes, while avoiding over-broad read-time bumps that can auto-read truly new incoming messages.