[Due for payment 2026-03-12][$250] Chat - Message sent in offline is not shown in reports page

[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.16-4
Reproducible in staging?: Yes
Reproducible in production?: Yes
If this was caught during regression testing, add the test name, ID and link from BrowserStack: N/A
Email or phone of affected tester (no customers): dreamnitethedragon@gmail.com
Issue reported by: Applause Internal Team
Bug source: Exploratory - Significant User Experience Deterioration
Device used: Redminote 10S Android 13
App Component: Money Requests

Action Performed:

1. Launch app
2. Go to reports - expense ( select from Type dropdown)
3. Go offline
4. Add an expense (selecting 1:1 user)
5. Note expense added in offline is shown in reports page
6. Go online
7. Go to reports - chat ( select from Type dropdown)
8. Go offline
9. Send a message (selecting 1:1 user)
10. Note message sent in offline is not shown in reports page

Expected Result:

Message sent in offline must be shown in reports page.

Actual Result:

Message sent in offline is not shown in reports page like expense.

Note:
Similarly task created in offline is also not shown in reports page.

Workaround:

Unknown

Platforms:

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

Screenshots/Videos

Bug7073777_1770740260154.Screenrecorder-2026-02-10-21-34-49-996.mp4

View all open jobs on GitHub

Issue Owner

Current Issue Owner: @johncschuster

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022021291443723323592
• Upwork Job ID: 2021291443723323592
• Last Price Increase: 2026-02-17

[melvin-bot]

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

[melvin-bot]

Triggered auto assignment to @johncschuster (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.

[melvin-bot]

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

[harjot96]

Proposal

Please re-state the problem that we are trying to solve in this issue.
When a user sends a message or creates a task while offline, the new item does not appear in the Reports (Search) page list. This occurs because the ONYXKEYS.COLLECTION.SNAPSHOT key, which drives the data for the Search page, is not being updated optimistically for these actions. The items only appear after the device goes online and the server responds.

Solution

Manually update the ONYXKEYS.COLLECTION.SNAPSHOT Onyx key with optimistic data when a user adds a comment or creates a task, similar to how it is currently handled for Expenses.

1. For Messages (Chats):
   In src/libs/actions/Report/index.ts, inside the addActions function, we now retrieve the current search query. If the current search type is CHAT, we optimistically merge the new report and report actions into the current snapshot hash.

2. For Tasks:
   In src/libs/actions/Task.ts, inside the createTaskAndNavigate function, we check if the current search type is CHAT or TASK. If so, we optimistically merge the new task report, the updated parent report, and the created report actions into the current snapshot hash.

This ensures that offline actions are immediately reflected in the UI, providing a consistent "offline-first" experience across all report types.

Changes

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

Updated addActions to include optimistic snapshot updates.

// ... imports
import {getCurrentSearchQueryJSON} from '@libs/SearchQueryUtils';

// ... inside addActions function
    const currentSearchQueryJSON = getCurrentSearchQueryJSON();
    if (currentSearchQueryJSON?.type === CONST.SEARCH.DATA_TYPES.CHAT) {
        // @ts-expect-error - will be solved in https://github.com/Expensify/App/issues/73830
        optimisticData.push({
            onyxMethod: Onyx.METHOD.MERGE,
            key: `${ONYXKEYS.COLLECTION.SNAPSHOT}${currentSearchQueryJSON.hash}`,
            value: {
                data: {
                    [`${ONYXKEYS.COLLECTION.REPORT}${reportID}`]: optimisticReport,
                    [`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`]: optimisticReportActions,
                },
            },
        });
    }
// ...

2. src/libs/actions/Task.ts

Updated createTaskAndNavigate to include optimistic snapshot updates.

// ... imports
import {getCurrentSearchQueryJSON} from '@libs/SearchQueryUtils';

// ... inside createTaskAndNavigate function
    const currentSearchQueryJSON = getCurrentSearchQueryJSON();
    if (currentSearchQueryJSON && (currentSearchQueryJSON.type === CONST.SEARCH.DATA_TYPES.CHAT || currentSearchQueryJSON.type === CONST.SEARCH.DATA_TYPES.TASK)) {
        // @ts-expect-error - will be solved in https://github.com/Expensify/App/issues/73830
        optimisticData.push({
            onyxMethod: Onyx.METHOD.MERGE,
            key: `${ONYXKEYS.COLLECTION.SNAPSHOT}${currentSearchQueryJSON.hash}`,
            value: {
                data: {
                    [`${ONYXKEYS.COLLECTION.REPORT}${optimisticTaskReport.reportID}`]: {
                        ...optimisticTaskReport,
                        pendingFields: {
                            createChat: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
                            reportName: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
                            description: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
                            managerID: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
                        },
                    },
                    [`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${optimisticTaskReport.reportID}`]: {[optimisticTaskCreatedAction.reportActionID]: optimisticTaskCreatedAction as OnyxTypes.ReportAction},
                    [`${ONYXKEYS.COLLECTION.REPORT}${parentReportID}`]: optimisticParentReport,
                    [`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${parentReportID}`]: {[optimisticAddCommentReport.reportAction.reportActionID]: optimisticAddCommentReport.reportAction as OnyxTypes.ReportAction},
                },
            },
        });
    }
// ...

[abbasifaizan70]

Proposal

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

The message sent while offline must be shown on the Reports page when viewing Reports → Chat.

---

What is the root cause of that problem?

Chat search results on the Reports page come only from the search API snapshot stored in Onyx. When the user is offline, the search either does not run or returns stale data, so the snapshot never contains the newly created chat or the message. The UI only renders what is in that snapshot, so offline-created chats never appear.

RCA – Code that causes the issue:

1. SearchContext returns only snapshot data for Chat type (no merge with local Onyx).

   currentSearchResults is built from the snapshot keyed by search hash. For non–to-do searches it returns the snapshot as-is. There is no merge of chat reports that exist in Onyx (e.g. created or updated offline) but are not in the snapshot.

App/src/components/Search/SearchContext.tsx

Lines 79 to 109 in 580c98f

	const [snapshotSearchResults] = useOnyx(`${ONYXKEYS.COLLECTION.SNAPSHOT}${searchContextData.currentSearchHash}`, {canBeMissing: true});
	const todoSearchResultsData = useTodos();
	const currentSearchKey = searchContextData.currentSearchKey;
	const currentSearchHash = searchContextData.currentSearchHash;
	const {accountID} = useCurrentUserPersonalDetails();
	const suggestedSearches = useMemo(() => getSuggestedSearches(accountID), [accountID]);
	const shouldUseLiveData = !!currentSearchKey && isTodoSearch(currentSearchHash, suggestedSearches);
	// If viewing a to-do search, use live data from useTodos, otherwise return the snapshot data
	// We do this so that we can show the counters for the to-do search results without visiting the specific to-do page, e.g. show `Approve [3]` while viewing the `Submit` to-do search.
	const currentSearchResults = useMemo((): SearchResults | undefined => {
	if (shouldUseLiveData) {
	const liveData = todoSearchResultsData[currentSearchKey as keyof typeof todoSearchResultsData];
	const searchInfo: SearchResultsInfo = {
	...(snapshotSearchResults?.search ?? defaultSearchInfo),
	count: liveData.metadata.count,
	total: liveData.metadata.total,
	currency: liveData.metadata.currency,
	};
	const hasResults = Object.keys(liveData.data).length > 0;
	// For to-do searches, always return a valid SearchResults object (even with empty data)
	// This ensures we show the empty state instead of loading/blocking views
	return {
	search: {...searchInfo, isLoading: false, hasResults},
	data: liveData.data,
	};
	}
	return snapshotSearchResults ?? undefined;
	}, [shouldUseLiveData, currentSearchKey, todoSearchResultsData, snapshotSearchResults]);

Code in RCA (issue):

const [snapshotSearchResults] = useOnyx(`${ONYXKEYS.COLLECTION.SNAPSHOT}${searchContextData.currentSearchHash}`, {canBeMissing: true});
const todoSearchResultsData = useTodos();
// ... no useOnyx for REPORT or REPORT_ACTIONS

const currentSearchResults = useMemo((): SearchResults | undefined => {
    if (shouldUseLiveData) {
        // ... todo path
    }
    return snapshotSearchResults ?? undefined;  // Chat type: only snapshot, no local merge
}, [shouldUseLiveData, currentSearchKey, todoSearchResultsData, snapshotSearchResults]);

So for Reports → Chat, currentSearchResults.data is only the snapshot. Any chat created or updated offline (and thus only in Onyx) is never included.

2. Chat list is built only from the data passed in (snapshot).

   getReportActionsSections(data) iterates only over keys in data (report action entries, reports, etc.). If the offline chat’s report and report actions are not in data, they are never rendered.

   App/src/libs/SearchUIUtils.ts

   Lines 1935 to 1971 in 580c98f

   	for (const key in data) {
   	if (isReportActionEntry(key)) {
   	const reportActions = Object.values(data[key]);
   	n += reportActions.length;
   	for (const reportAction of reportActions) {
   	const from = reportAction.accountID ? (data.personalDetailsList?.[reportAction.accountID] ?? emptyPersonalDetails) : emptyPersonalDetails;
   	const report = data[`${ONYXKEYS.COLLECTION.REPORT}${reportAction.reportID}`] ?? {};
   	const policy = data[`${ONYXKEYS.COLLECTION.POLICY}${report.policyID}`] ?? {};
   	const originalMessage = isMoneyRequestAction(reportAction) ? getOriginalMessage<typeof CONST.REPORT.ACTIONS.TYPE.IOU>(reportAction) : undefined;
   	const isSendingMoney = isMoneyRequestAction(reportAction) && originalMessage?.type === CONST.IOU.REPORT_ACTION_TYPE.PAY && originalMessage?.IOUDetails;
   	const isReportArchived = isArchivedReport(data[`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${report.reportID}`]);
   	const invoiceReceiverPolicy: OnyxTypes.Policy | undefined =
   	report?.invoiceReceiver?.type === CONST.REPORT.INVOICE_RECEIVER_TYPE.BUSINESS ? data[`${ONYXKEYS.COLLECTION.POLICY}${report.invoiceReceiver.policyID}`] : undefined;
   	if (
   	!shouldReportActionBeVisible(reportAction, reportAction.reportActionID, canUserPerformWriteAction(report, isReportArchived)) ||
   	isDeletedAction(reportAction) ||
   	isResolvedActionableWhisper(reportAction) ||
   	reportAction.actionName === CONST.REPORT.ACTIONS.TYPE.CLOSED ||
   	isCreatedAction(reportAction) ||
   	isWhisperActionTargetedToOthers(reportAction) ||
   	(isMoneyRequestAction(reportAction) && !!report?.isWaitingOnBankAccount && originalMessage?.type === CONST.IOU.REPORT_ACTION_TYPE.PAY && !isSendingMoney)
   	) {
   	continue;
   	}
   	reportActionItems.push({
   	...reportAction,
   	from,
   	// eslint-disable-next-line @typescript-eslint/no-deprecated
   	reportName: getSearchReportName({report, policy, personalDetails: data.personalDetailsList, transactions, invoiceReceiverPolicy, reports, policies, isReportArchived}),
   	formattedFrom: from?.displayName ?? from?.login ?? '',
   	date: reportAction.created,
   	keyForList: reportAction.reportActionID,
   	} as ReportActionListItemType);
   	}
   	}

   Code in RCA (issue):

   for (const key in data) {
       if (isReportActionEntry(key)) {
           const reportActions = Object.values(data[key]);
           // ... only processes report actions that are already in `data`
           for (const reportAction of reportActions) {
               const report = data[`${ONYXKEYS.COLLECTION.REPORT}${reportAction.reportID}`] ?? {};
               // If report/actions for offline chat are not in `data`, they are never shown

   So the list is strictly “what’s in data”. With Chat type, data is the snapshot only; offline chats are missing from the list.

Summary:
Reports → Chat uses only API snapshot data. Offline-created chats live only in Onyx and are never merged into the data passed to the list. Expenses work because expense flows already merge/optimistic-update the snapshot or use live Onyx data in other code paths.

---

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

When the Reports search type is Chat, merge into the search results any local chat reports from Onyx that are not already in the snapshot. That way, chats created or updated offline (e.g. 1:1 with a sent message) appear in Reports → Chat without waiting for the next successful API search.

All changes are in one file: App/src/components/Search/SearchContext.tsx.

---

Change 1 – Imports: add isChatReport and isPolicyExpenseChat

App/src/components/Search/SearchContext.tsx

Lines 7 to 8 in 580c98f

	import {isMoneyRequestReport} from '@libs/ReportUtils';
	import {getSuggestedSearches, isTodoSearch, isTransactionListItemType, isTransactionReportGroupListItemType} from '@libs/SearchUIUtils';

Old code:

import {isMoneyRequestReport} from '@libs/ReportUtils';

New code:

import {isChatReport, isMoneyRequestReport, isPolicyExpenseChat} from '@libs/ReportUtils';

---

Change 2 – Subscribe to Onyx REPORT, REPORT_ACTIONS, and PERSONAL_DETAILS_LIST

App/src/components/Search/SearchContext.tsx

Lines 79 to 80 in 580c98f

	const [snapshotSearchResults] = useOnyx(`${ONYXKEYS.COLLECTION.SNAPSHOT}${searchContextData.currentSearchHash}`, {canBeMissing: true});
	const todoSearchResultsData = useTodos();

New code:

    const [snapshotSearchResults] = useOnyx(`${ONYXKEYS.COLLECTION.SNAPSHOT}${searchContextData.currentSearchHash}`, {canBeMissing: true});
    const todoSearchResultsData = useTodos();
    const [allReports] = useOnyx(ONYXKEYS.COLLECTION.REPORT, {canBeMissing: true});
    const [allReportActions] = useOnyx(ONYXKEYS.COLLECTION.REPORT_ACTIONS, {canBeMissing: true});
    const [personalDetailsList] = useOnyx(ONYXKEYS.PERSONAL_DETAILS_LIST, {canBeMissing: true});

---

Change 3 – When type is Chat, merge local chat reports into snapshot data

App/src/components/Search/SearchContext.tsx

Lines 90 to 109 in 580c98f

	const currentSearchResults = useMemo((): SearchResults | undefined => {
	if (shouldUseLiveData) {
	const liveData = todoSearchResultsData[currentSearchKey as keyof typeof todoSearchResultsData];
	const searchInfo: SearchResultsInfo = {
	...(snapshotSearchResults?.search ?? defaultSearchInfo),
	count: liveData.metadata.count,
	total: liveData.metadata.total,
	currency: liveData.metadata.currency,
	};
	const hasResults = Object.keys(liveData.data).length > 0;
	// For to-do searches, always return a valid SearchResults object (even with empty data)
	// This ensures we show the empty state instead of loading/blocking views
	return {
	search: {...searchInfo, isLoading: false, hasResults},
	data: liveData.data,
	};
	}
	return snapshotSearchResults ?? undefined;
	}, [shouldUseLiveData, currentSearchKey, todoSearchResultsData, snapshotSearchResults]);

New code:

    // When viewing Chat search, merge in chat reports from Onyx that are not in the snapshot (e.g. messages sent offline) so they appear in the Reports page.
    const currentSearchResults = useMemo((): SearchResults | undefined => {
        if (shouldUseLiveData) {
            const liveData = todoSearchResultsData[currentSearchKey as keyof typeof todoSearchResultsData];
            const searchInfo: SearchResultsInfo = {
                ...(snapshotSearchResults?.search ?? defaultSearchInfo),
                count: liveData.metadata.count,
                total: liveData.metadata.total,
                currency: liveData.metadata.currency,
            };
            const hasResults = Object.keys(liveData.data).length > 0;
            return {
                search: {...searchInfo, isLoading: false, hasResults},
                data: liveData.data,
            };
        }

        const snapshot = snapshotSearchResults;
        if (!snapshot?.data || snapshot.search?.type !== CONST.SEARCH.DATA_TYPES.CHAT) {
            return snapshot ?? undefined;
        }

        // Merge in chat reports from Onyx that are not in the search snapshot (e.g. 1:1 chats created or messages sent while offline)
        const snapshotData = snapshot.data as Record<string, unknown>;
        const mergedData = {...snapshotData};

        const reportKey = (reportID: string) => `${ONYXKEYS.COLLECTION.REPORT}${reportID}`;
        const reportActionsKey = (reportID: string) => `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`;

        for (const report of Object.values(allReports ?? {})) {
            if (!report?.reportID || !isChatReport(report) || report.parentReportID || isPolicyExpenseChat(report)) {
                continue;
            }
            const rKey = reportKey(report.reportID);
            if (mergedData[rKey] != null) {
                continue;
            }
            const actions = allReportActions?.[reportActionsKey(report.reportID)];
            if (!actions || Object.keys(actions).length === 0) {
                continue;
            }
            mergedData[rKey] = report;
            mergedData[reportActionsKey(report.reportID)] = actions;
        }

        // Ensure personalDetailsList is present for display (e.g. "from" in chat list items)
        if (personalDetailsList && !mergedData[ONYXKEYS.PERSONAL_DETAILS_LIST]) {
            mergedData[ONYXKEYS.PERSONAL_DETAILS_LIST] = personalDetailsList;
        } else if (personalDetailsList && mergedData[ONYXKEYS.PERSONAL_DETAILS_LIST]) {
            mergedData[ONYXKEYS.PERSONAL_DETAILS_LIST] = {...(mergedData[ONYXKEYS.PERSONAL_DETAILS_LIST] as Record<string, unknown>), ...personalDetailsList};
        }

        return {...snapshot, data: mergedData};
    }, [
        shouldUseLiveData,
        currentSearchKey,
        todoSearchResultsData,
        snapshotSearchResults,
        allReports,
        allReportActions,
        personalDetailsList,
    ]);

---

What alternative solutions did you explore? (Optional)

• Re-run or adapt search when coming back online: Would require extra API calls and handling for “partial” offline results; merging from Onyx is simpler and keeps the list consistent as soon as the user views Reports → Chat.
• Merge at getReportActionsSections / Search component level: Possible, but merging in SearchContext keeps a single source of truth for “current search results” and avoids passing allReports / allReportActions down into the Search UI layer.

[twinkle-react]

Proposal

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

A chat message sent while offline does not appear in the Reports list when filtering by Chat. Expenses created offline appear correctly, but offline-sent chat messages do not show up in the list.

What is the root cause of that problem?

In this flow, addComment → addActions builds optimistic child report actions and calls getOptimisticDataForAncestors, but this helper in src/libs/ReportUtils.ts assumes that updating only REPORT_ACTIONS is enough. This assumption is wrong because the Reports list depends on report-level fields like lastVisibleActionCreated. Since the optimistic REPORT merge is missing, the report metadata is not updated, and the offline message is not surfaced.

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

State the single invariant you’re enforcing
When adding optimistic child actions, ancestor reports must receive atomic optimistic updates for both ancestor REPORT_ACTIONS and ancestor REPORT metadata so listing and sorting code sees the change immediately.

Point to the earliest incorrect assumption
getOptimisticDataForAncestors assumed that updating only ${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${ancestorReportID} is enough for listing UIs. This is the earliest incorrect assumption.

Apply the smallest shared-layer fix
Modify getOptimisticDataForAncestors in src/libs/ReportUtils.ts to return both:

• an Onyx MERGE for ${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${ancestorReportID}, and
• an Onyx MERGE for ${ONYXKEYS.COLLECTION.REPORT}${ancestorReportID} setting lastVisibleActionCreated.

This keeps the fix in one shared helper used by all callers.

Show the exact code delta and scope
Files changed

• src/libs/ReportUtils.ts

Function / logic modified

• getOptimisticDataForAncestors(ancestors: Ancestor[], lastVisibleActionCreated: string, type: string)

Scope size

• One file changed. One helper updated. Small additive change.

Edited function (exact code excerpt):

function getOptimisticDataForAncestors(ancestors: Ancestor[], lastVisibleActionCreated: string, type: string): Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS>> {
    let previousActionDeleted = false;
    // For each ancestor we need to update both:
    // 1) the ancestor's reportAction entry (child counts, etc)
    // 2) the ancestor's report metadata so list views that read report-level fields (eg. lastVisibleActionCreated)
    // return a flattened array of Onyx updates for both keys.
    return ancestors.flatMap(({report: ancestorReport, reportAction: ancestorReportAction}, index) => {
        const updatedReportAction = updateOptimisticParentReportAction(
            ancestorReportAction,
            lastVisibleActionCreated,
            type,
            previousActionDeleted ? index + 1 : undefined,
        );
        previousActionDeleted = isDeletedAction(ancestorReportAction) && updatedReportAction.childVisibleActionCount === 0;

        const reportActionUpdate: OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS> = {
            onyxMethod: Onyx.METHOD.MERGE,
            key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${ancestorReport.reportID}`,
            value: {
                [ancestorReportAction.reportActionID]: updatedReportAction,
            },
        };

        const reportUpdate: OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT> = {
            onyxMethod: Onyx.METHOD.MERGE,
            key: `${ONYXKEYS.COLLECTION.REPORT}${ancestorReport.reportID}`,
            value: {
                // Update the ancestor report's lastVisibleActionCreated so list screens which rely on report-level
                // metadata will surface the optimistic change immediately while offline.
                lastVisibleActionCreated: lastVisibleActionCreated,
            },
        };

        return [reportActionUpdate, reportUpdate];
    });
}

Note risk and ownership

• Owner: Report and Actions shared utilities in src/libs/ReportUtils.ts.
• Risk: Low. The change is additive and centralized. Revert is one file.
• Teams to notify: Report and Actions, LHN and OptionsList owners.

Implementation note
No callers need changes. Callers already pass the output of getOptimisticDataForAncestors into optimisticData. API.prepareRequest applies this via Onyx.update, so adding the REPORT merge makes the change visible while offline.

What alternative solutions did you explore? (Optional)

• Central shared helper change.
• Caller-side patches.
• UI recomputation of REPORT_ACTIONS.

[annaweber830]

Proposal

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

When a user is on Reports with the Type: Chat filter and then goes offline, a newly sent message in a 1:1 chat does not appear in the current reports list. The same stale-list behavior also happens for offline-created tasks, while offline expense creation is already reflected immediately.

What is the root cause of that problem?

Offline chat/task creation updates report and reportActions Onyx collections, but it does not optimistically merge those changes into the currently opened search snapshot (snapshot_<hash>), which is what the Reports page is rendering.

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

Lines 725 to 736 in d1affbe

	const optimisticData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS | typeof ONYXKEYS.PERSONAL_DETAILS_LIST>> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
	value: optimisticReport,
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
	value: optimisticReportActions as ReportActions,
	},
	];

const optimisticData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS | typeof ONYXKEYS.PERSONAL_DETAILS_LIST>> = [
    {
        onyxMethod: Onyx.METHOD.MERGE,
        key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
        value: optimisticReport,
    },
    {
        onyxMethod: Onyx.METHOD.MERGE,
        key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
        value: optimisticReportActions as ReportActions,
    },
];

By contrast, expense creation has explicit search-snapshot optimistic merges, which is why offline expenses appear immediately in Reports:

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

Lines 12055 to 12090 in d1affbe

	return {
	optimisticData: [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.SNAPSHOT}${currentSearchQueryJSON.hash}` as const,
	value: {
	// @ts-expect-error - will be solved in https://github.com/Expensify/App/issues/73830
	data: {
	[ONYXKEYS.PERSONAL_DETAILS_LIST]: {
	[toAccountID]: {
	accountID: toAccountID,
	displayName: participant?.displayName,
	login: participant?.login,
	},
	[fromAccountID]: {
	accountID: fromAccountID,
	avatar: deprecatedCurrentUserPersonalDetails?.avatar,
	displayName: deprecatedCurrentUserPersonalDetails?.displayName,
	login: deprecatedCurrentUserPersonalDetails?.login,
	},
	},
	[`${ONYXKEYS.COLLECTION.TRANSACTION}${transaction.transactionID}`]: {
	accountID: fromAccountID,
	managerID: toAccountID,
	...(transactionThreadReportID && {transactionThreadReportID}),
	...(isFromOneTransactionReport && {isFromOneTransactionReport}),
	...transaction,
	},
	...(policy && {[`${ONYXKEYS.COLLECTION.POLICY}${policy.id}`]: policy}),
	...(iouReport && {[`${ONYXKEYS.COLLECTION.REPORT}${iouReport.reportID}`]: iouReport}),
	...(iouReport && iouAction && {[`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${iouReport.reportID}`]: {[iouAction.reportActionID]: iouAction}}),
	},
	},
	},
	],
	successData,

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

Add optimistic snapshot_<hash> merges for chat/task creation when the active search query is a chat reports query, reusing the same pattern already used by expense flows.

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

Lines 725 to 817 in d1affbe

	const optimisticData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS | typeof ONYXKEYS.PERSONAL_DETAILS_LIST>> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
	value: optimisticReport,
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
	value: optimisticReportActions as ReportActions,
	},
	];
	optimisticData.push(...getOptimisticDataForAncestors(ancestors, currentTime, CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD));
	const successReportActions: OnyxCollection<NullishDeep<ReportAction>> = {};
	for (const [actionKey] of Object.entries(optimisticReportActions)) {
	successReportActions[actionKey] = {pendingAction: null, isOptimisticAction: null};
	}
	const successData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS>> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
	value: successReportActions,
	},
	];
	let failureReport: Partial<Report> = {
	lastMessageText: '',
	lastVisibleActionCreated: '',
	};
	const {lastMessageText = ''} = ReportActionsUtils.getLastVisibleMessage(reportID);
	if (lastMessageText) {
	const lastVisibleActionCreated = lastVisibleAction?.created;
	failureReport = {
	lastMessageText,
	lastVisibleActionCreated,
	lastActorAccountID,
	};
	}
	const failureReportActions: Record<string, OptimisticAddCommentReportAction | ReportAction | null> = {};
	for (const [actionKey, action] of Object.entries(optimisticReportActions)) {
	failureReportActions[actionKey] = {
	// eslint-disable-next-line @typescript-eslint/non-nullable-type-assertion-style
	...(action as OptimisticAddCommentReportAction),
	errors: getMicroSecondOnyxErrorWithTranslationKey('report.genericAddCommentFailureMessage'),
	};
	}
	// In case of error bring back the follow up buttons to the cast comment
	if (lastActorAccountID === CONST.ACCOUNT_ID.CONCIERGE && lastActionReportActionID) {
	failureReportActions[lastActionReportActionID] = lastVisibleAction;
	}
	// In case of error, remove the optimistic Concierge response
	if (pregeneratedResponseParams) {
	failureReportActions[pregeneratedResponseParams.optimisticConciergeReportActionID] = null;
	}
	const failureData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS>> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
	value: failureReport,
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
	value: failureReportActions as ReportActions,
	},
	];
	// Update the timezone if it's been 5 minutes from the last time the user added a comment
	if (DateUtils.canUpdateTimezone() && currentUserAccountID) {
	const timezone = DateUtils.getCurrentTimezone(timezoneParam);
	parameters.timezone = JSON.stringify(timezone);
	optimisticData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: ONYXKEYS.PERSONAL_DETAILS_LIST,
	value: {[currentUserAccountID]: {timezone}},
	});
	DateUtils.setTimezoneUpdated();
	}
	API.write(commandName, parameters, {
	optimisticData,
	successData,
	failureData,
	});
	notifyNewAction(notifyReportID, lastAction, lastAction?.actorAccountID === currentUserAccountID);

Current code:

const optimisticData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS | typeof ONYXKEYS.PERSONAL_DETAILS_LIST>> = [
    {
        onyxMethod: Onyx.METHOD.MERGE,
        key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
        value: optimisticReport,
    },
    {
        onyxMethod: Onyx.METHOD.MERGE,
        key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
        value: optimisticReportActions as ReportActions,
    },
];

Updated code:

const optimisticData: Array<
    OnyxUpdate<
        | typeof ONYXKEYS.COLLECTION.REPORT
        | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS
        | typeof ONYXKEYS.PERSONAL_DETAILS_LIST
        | typeof ONYXKEYS.COLLECTION.SNAPSHOT
    >
> = [
    {
        onyxMethod: Onyx.METHOD.MERGE,
        key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
        value: optimisticReport,
    },
    {
        onyxMethod: Onyx.METHOD.MERGE,
        key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
        value: optimisticReportActions as ReportActions,
    },
];

const currentSearchQueryJSON = getCurrentSearchQueryJSON();
if (currentSearchQueryJSON?.type === CONST.SEARCH.DATA_TYPES.CHAT) {
    optimisticData.push({
        onyxMethod: Onyx.METHOD.MERGE,
        key: `${ONYXKEYS.COLLECTION.SNAPSHOT}${currentSearchQueryJSON.hash}`,
        value: {
            data: {
                [`${ONYXKEYS.COLLECTION.REPORT}${reportID}`]: optimisticReport,
                [`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`]: optimisticReportActions,
            },
        },
    });
}

Apply the same snapshot-merge pattern for task creation in createTaskAndNavigate() so task-created actions also become immediately visible in Type: Chat reports:

App/src/libs/actions/Task.ts

Lines 131 to 315 in d1affbe

	const optimisticData: Array<
	OnyxUpdate<
	typeof ONYXKEYS.COLLECTION.REPORT | typeof ONYXKEYS.COLLECTION.REPORT_METADATA | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS | typeof ONYXKEYS.NVP_QUICK_ACTION_GLOBAL_CREATE
	>
	> = [
	{
	onyxMethod: Onyx.METHOD.SET,
	key: `${ONYXKEYS.COLLECTION.REPORT}${optimisticTaskReport.reportID}`,
	value: {
	...optimisticTaskReport,
	pendingFields: {
	createChat: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
	reportName: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
	description: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
	managerID: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
	},
	},
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_METADATA}${optimisticTaskReport.reportID}`,
	value: {
	isOptimisticReport: true,
	},
	},
	{
	onyxMethod: Onyx.METHOD.SET,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${optimisticTaskReport.reportID}`,
	value: {[optimisticTaskCreatedAction.reportActionID]: optimisticTaskCreatedAction as OnyxTypes.ReportAction},
	},
	];
	// FOR TASK REPORT
	const successData: Array<
	OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT | typeof ONYXKEYS.COLLECTION.REPORT_METADATA | typeof ONYXKEYS.PERSONAL_DETAILS_LIST | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS>
	> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT}${optimisticTaskReport.reportID}`,
	value: {
	pendingFields: {
	createChat: null,
	reportName: null,
	description: null,
	managerID: null,
	},
	// BE will send a different participant. We clear the optimistic one to avoid duplicated entries
	participants: {[assigneeAccountID]: null},
	},
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_METADATA}${optimisticTaskReport.reportID}`,
	value: {
	isOptimisticReport: false,
	},
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${optimisticTaskReport.reportID}`,
	value: {[optimisticTaskCreatedAction.reportActionID]: {pendingAction: null}},
	},
	];
	// FOR TASK REPORT
	const failureData: Array<
	OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS | typeof ONYXKEYS.PERSONAL_DETAILS_LIST | typeof ONYXKEYS.NVP_QUICK_ACTION_GLOBAL_CREATE>
	> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT}${optimisticTaskReport.reportID}`,
	value: null,
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${optimisticTaskReport.reportID}`,
	value: null,
	},
	];
	if (assigneeChatReport && assigneeChatReportID) {
	assigneeChatReportOnyxData = ReportUtils.getTaskAssigneeChatOnyxData(
	currentUserAccountID,
	assigneeAccountID,
	taskReportID,
	assigneeChatReportID,
	parentReportID,
	title,
	assigneeChatReport,
	);
	optimisticData.push(...assigneeChatReportOnyxData.optimisticData);
	successData.push(...assigneeChatReportOnyxData.successData);
	failureData.push(...assigneeChatReportOnyxData.failureData);
	}
	// Now that we've created the optimistic chat report and chat reportActions, we can update the parent report data
	// FOR PARENT REPORT (SHARE DESTINATION)
	optimisticData.push(
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT}${parentReportID}`,
	value: optimisticParentReport,
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${parentReportID}`,
	value: {[optimisticAddCommentReport.reportAction.reportActionID]: optimisticAddCommentReport.reportAction as OnyxTypes.ReportAction},
	},
	);
	const shouldUpdateNotificationPreference = !isEmptyObject(parentReport) && ReportUtils.isHiddenForCurrentUser(parentReport);
	if (shouldUpdateNotificationPreference) {
	optimisticData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT}${parentReportID}`,
	value: {
	participants: {
	[currentUserAccountID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
	},
	},
	});
	}
	// FOR QUICK ACTION NVP
	optimisticData.push({
	onyxMethod: Onyx.METHOD.SET,
	key: ONYXKEYS.NVP_QUICK_ACTION_GLOBAL_CREATE,
	value: {
	action: CONST.QUICK_ACTIONS.ASSIGN_TASK,
	chatReportID: parentReportID,
	isFirstQuickAction: isEmptyObject(quickAction),
	targetAccountID: assigneeAccountID,
	},
	});
	failureData.push({
	onyxMethod: Onyx.METHOD.SET,
	key: ONYXKEYS.NVP_QUICK_ACTION_GLOBAL_CREATE,
	value: quickAction ?? null,
	});
	// If needed, update optimistic data for parent report action of the parent report.
	optimisticData.push(...ReportUtils.getOptimisticDataForAncestors(ancestors, currentTime, CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD));
	// FOR PARENT REPORT (SHARE DESTINATION)
	successData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${parentReportID}`,
	value: {[optimisticAddCommentReport.reportAction.reportActionID]: {pendingAction: null, isOptimisticAction: null}},
	});
	// FOR PARENT REPORT (SHARE DESTINATION)
	failureData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${parentReportID}`,
	value: {
	[optimisticAddCommentReport.reportAction.reportActionID]: {
	errors: ErrorUtils.getMicroSecondOnyxErrorWithTranslationKey('task.genericCreateTaskFailureMessage'),
	},
	},
	});
	failureData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT}${parentReportID}`,
	value: {
	hasOutstandingChildTask: parentReport?.hasOutstandingChildTask,
	},
	});
	const parameters: CreateTaskParams = {
	parentReportActionID: optimisticAddCommentReport.reportAction.reportActionID,
	parentReportID,
	taskReportID: optimisticTaskReport.reportID,
	createdTaskReportActionID: optimisticTaskCreatedAction.reportActionID,
	htmlTitle: optimisticTaskReport.reportName,
	description: optimisticTaskReport.description,
	assignee: assigneeEmail,
	assigneeAccountID,
	assigneeChatReportID,
	assigneeChatReportActionID: assigneeChatReportOnyxData?.optimisticAssigneeAddComment?.reportAction.reportActionID,
	assigneeChatCreatedReportActionID: assigneeChatReportOnyxData?.optimisticChatCreatedReportAction?.reportActionID,
	};
	playSound(SOUNDS.DONE);
	API.write(WRITE_COMMANDS.CREATE_TASK, parameters, {optimisticData, successData, failureData});

What alternative solutions did you explore? (Optional)

I considered forcing a search re-fetch whenever an offline chat/task optimistic action is created, but this is less reliable offline and inconsistent with the existing optimistic-search architecture. Updating the active snapshot directly is smaller, consistent with expense behavior, and keeps the UI responsive without extra network dependence.