Align expense creation report eligibility with the save path

src/components/MoneyRequestConfirmationList/sections/ReportField.tsx

@@ -11,7 +11,15 @@ import createDynamicRoute from '@libs/Navigation/helpers/dynamicRoutesUtils/crea
 import Navigation from '@libs/Navigation/Navigation';
 import Parser from '@libs/Parser';
 import {getReportName} from '@libs/ReportNameUtils';
-import {generateReportID, getOutstandingReportsForUser, isMoneyRequestReport, isReportOutstanding, sortOutstandingReportsBySelected} from '@libs/ReportUtils';
+import {
+    canAddTransaction,
+    generateReportID,
+    getNewestOutstandingReportForUser,
+    getOutstandingReportsForUser,
+    isMoneyRequestReport,
+    isReportOutstanding,
+    sortOutstandingReportsBySelected,
+} from '@libs/ReportUtils';
 
 import CONST from '@src/CONST';
 import type {IOUAction, IOUType} from '@src/CONST';
@@ -69,6 +77,7 @@ function ReportField({selectedParticipants, iouType, reportID, reportActionID, a
     const [iouReport] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT}${iouReportIDFromMain}`);
 
     const isUnreported = transactionReportID === CONST.REPORT.UNREPORTED_REPORT_ID;
+    const isCreatingExpense = action === CONST.IOU.ACTION.CREATE;
 
     /**
      * We need to check if the transaction report exists first in order to prevent the outstanding reports from being used.
@@ -81,7 +90,11 @@ function ReportField({selectedParticipants, iouType, reportID, reportActionID, a
         (report1, report2) => sortOutstandingReportsBySelected(report1, report2, undefined, localeCompare),
     );
 
-    const outstandingReportID = isPolicyExpenseChat ? (iouReportIDFromMain ?? availableOutstandingReports.at(0)?.reportID) : reportID;
+    // Match the builder's automatic destination before checking eligibility, rather than falling back to a report it would not use.
+    const defaultOutstandingReport = isCreatingExpense
+        ? getNewestOutstandingReportForUser(policyID, ownerAccountID, rules, reportNameValuePairs, outstandingReportsForPolicy ?? {})
+        : availableOutstandingReports.at(0);
+    const outstandingReportID = isPolicyExpenseChat ? (iouReportIDFromMain ?? defaultOutstandingReport?.reportID) : reportID;
 
     const [selectedReportID, selectedReport] = (() => {
         const reportIDToUse = shouldUseTransactionReport ? transactionReportID : outstandingReportID;
@@ -100,6 +113,9 @@ function ReportField({selectedParticipants, iouType, reportID, reportActionID, a
         } else {
             reportToUse = availableOutstandingReports.find((r) => r?.reportID === reportIDToUse);
         }
+        if (isCreatingExpense && reportToUse && !canAddTransaction(reportToUse, rules)) {
+            return [generateReportID(), undefined] as const;
+        }
         return [reportIDToUse, reportToUse ?? undefined] as const;
     })();
 
@@ -114,12 +130,17 @@ function ReportField({selectedParticipants, iouType, reportID, reportActionID, a
     })();
 
     const outstandingReports = useOutstandingReports(undefined, isFromGlobalCreate && !isPerDiemRequest ? undefined : policyID, ownerAccountID, false, ownerPersonalDetail?.login);
-    // The list offers a new report and, for a new expense, no report at all, so there is always a choice to make.
-    // Editing an expense that is already on a report can hide both (someone else's expense, edited by a non-admin),
-    // so there the row needs another report to choose from. Creating from inside an expense report locks the row,
-    // since the expense can only go on that report.
+    const eligibleOutstandingReports = isCreatingExpense ? outstandingReports.filter((report) => canAddTransaction(report, rules)) : outstandingReports;
+    // Edits on a report can hide the new-report option; other non-creation flows always offer a choice.
     const mayHideListOptions = action === CONST.IOU.ACTION.EDIT && !isUnreported;
-    const shouldReportBeEditable = (!mayHideListOptions || shouldReportFieldBeEditable(outstandingReports, selectedReportID, isUnreported)) && !isMoneyRequestReport(reportID);
+    let hasSelectableReports = (!isCreatingExpense && !mayHideListOptions) || shouldReportFieldBeEditable(eligibleOutstandingReports, selectedReportID, isUnreported);
+    if (isCreatingExpense && !isUnreported) {
+        // Keep a single eligible alternative read-only when the automatic destination is "New report".
+        hasSelectableReports = eligibleOutstandingReports.length > 1;
+    }
+    // When creating an expense in an individual report, the report field becomes read-only
+    // since the destination is already determined and there's no need to show a selectable list.
+    const shouldReportBeEditable = hasSelectableReports && !isMoneyRequestReport(reportID);
     // Editing a saved expense's report and moving a per diem expense both navigate on from the list (to the report, or to
     // the destination step when the workspace changes), so those keep the full page.
     const shouldOpenInDropdown = !!transactionID && shouldReportBeEditable && action !== CONST.IOU.ACTION.EDIT && !isPerDiemRequest;

src/pages/iou/request/step/IOURequestEditReportCommon.tsx

@@ -73,6 +73,8 @@ type IOURequestEditReportCommonProps = {
     selectReport: (item: TransactionGroupListItem, report?: OnyxEntry<Report>) => void;
     removeFromReport?: () => void;
     isEditing?: boolean;
+    /** Uses creation eligibility instead of the admin/manager exceptions for moving saved expenses. Defaults to false. */
+    isCreatingExpense?: boolean;
     isUnreported?: boolean;
     shouldShowNotFoundPage?: boolean;
     createReport?: () => void;
@@ -123,6 +125,7 @@ function IOURequestEditReportCommon({
     transactionPolicyID,
     removeFromReport,
     isEditing = false,
+    isCreatingExpense = false,
     isUnreported,
     shouldShowNotFoundPage: shouldShowNotFoundPageFromProps,
     createReport,
@@ -241,6 +244,9 @@ function IOURequestEditReportCommon({
                       if (isPerDiemRequest && !canSubmitPerDiemExpenseFromWorkspace(policy)) {
                           return false;
                       }
+                      if (isCreatingExpense) {
+                          return canAddTransaction(report, rules);
+                      }
                       if (canAddTransaction(report, rules, undefined, true)) {
                           return true;
                       }

src/pages/iou/request/step/IOURequestStepReport/hooks/useReportPickerActions.ts

@@ -90,6 +90,7 @@ type ReportPickerListProps = Pick<
     | 'transactionPolicyID'
     | 'removeFromReport'
     | 'isEditing'
+    | 'isCreatingExpense'
     | 'isUnreported'
     | 'isPerDiemRequest'
     | 'isTimeRequest'
@@ -321,6 +322,7 @@ function useReportPickerActions({
             transactionPolicyID: targetExpensePolicyID,
             removeFromReport,
             isEditing,
+            isCreatingExpense: isCreateReport,
             isUnreported,
             isPerDiemRequest: transaction ? isPerDiemTransaction : false,
             isTimeRequest: isTimeTransaction,

tests/ui/IOURequestEditReportCommonTest.tsx

@@ -45,6 +45,8 @@ const renderIOURequestEditReportCommon = ({
     isOdometerDistanceRequest = false,
     isDistanceRequest = false,
     isPerDiemRequest = false,
+    isCreatingExpense = false,
+    isEditing = false,
     selectReport = jest.fn(),
     createReport,
     selectNoReport,
@@ -58,6 +60,8 @@ const renderIOURequestEditReportCommon = ({
     isOdometerDistanceRequest?: boolean;
     isDistanceRequest?: boolean;
     isPerDiemRequest?: boolean;
+    isCreatingExpense?: boolean;
+    isEditing?: boolean;
     selectReport?: jest.Mock;
     createReport?: jest.Mock;
     selectNoReport?: jest.Mock;
@@ -83,6 +87,8 @@ const renderIOURequestEditReportCommon = ({
                     onNavigateAway={onNavigateAway}
                     backTo=""
                     isPerDiemRequest={isPerDiemRequest}
+                    isCreatingExpense={isCreatingExpense}
+                    isEditing={isEditing}
                 />
             </ComposeProviders>
         </NavigationContainer>,
@@ -155,6 +161,67 @@ describe('IOURequestEditReportCommon', () => {
             expect(dotIndicators).toHaveLength(0);
         });
 
+        it.each([
+            {isCreatingExpense: true, isEditing: false, shouldShowReport: false},
+            {isCreatingExpense: false, isEditing: true, shouldShowReport: true},
+            {isCreatingExpense: false, isEditing: false, shouldShowReport: true},
+        ])('preserves move permissions but uses save eligibility for creation: %j', async ({isCreatingExpense, isEditing, shouldShowReport}) => {
+            // Given an admin's retracted report containing only non-reimbursable expenses
+            await act(async () => {
+                await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${FAKE_POLICY_ID}`, {
+                    role: CONST.POLICY.ROLE.ADMIN,
+                    autoReporting: true,
+                    autoReportingFrequency: CONST.POLICY.AUTO_REPORTING_FREQUENCIES.INSTANT,
+                    approvalMode: CONST.POLICY.APPROVAL_MODE.OPTIONAL,
+                    reimbursementChoice: CONST.POLICY.REIMBURSEMENT_CHOICES.REIMBURSEMENT_NO,
+                    pendingAction: undefined,
+                });
+                await Onyx.set(`${ONYXKEYS.COLLECTION.TRANSACTION}${FAKE_TRANSACTION_ID}`, {
+                    transactionID: FAKE_TRANSACTION_ID,
+                    reportID: FAKE_REPORT_ID,
+                    amount: -100,
+                    currency: 'USD',
+                    created: '2026-01-01',
+                    merchant: 'Merchant',
+                    reimbursable: false,
+                });
+            });
+            await waitForBatchedUpdatesWithAct();
+
+            // When the same picker opens for creation, editing, or a caller that does not set isEditing
+            renderIOURequestEditReportCommon({selectedReportID: FAKE_REPORT_ID, selectedPolicyID: FAKE_POLICY_ID, isCreatingExpense, isEditing});
+            await waitForBatchedUpdatesWithAct();
+
+            // Then only creation hides the rejected destination, preserving all existing move callers
+            expect(!!screen.queryByText('Expense Report')).toBe(shouldShowReport);
+        });
+
+        it('does not apply moving eligibility to submitted reports during creation', async () => {
+            // Given an instant-submit workspace with payments off and a submitted reimbursable report
+            await act(async () => {
+                await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${FAKE_POLICY_ID}`, {
+                    role: CONST.POLICY.ROLE.ADMIN,
+                    autoReporting: true,
+                    autoReportingFrequency: CONST.POLICY.AUTO_REPORTING_FREQUENCIES.INSTANT,
+                    approvalMode: CONST.POLICY.APPROVAL_MODE.OPTIONAL,
+                    reimbursementChoice: CONST.POLICY.REIMBURSEMENT_CHOICES.REIMBURSEMENT_NO,
+                    pendingAction: undefined,
+                });
+                await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${FAKE_REPORT_ID}`, {
+                    stateNum: CONST.REPORT.STATE_NUM.SUBMITTED,
+                    statusNum: CONST.REPORT.STATUS_NUM.SUBMITTED,
+                });
+            });
+            await waitForBatchedUpdatesWithAct();
+
+            // When the create-flow picker lists destinations
+            renderIOURequestEditReportCommon({selectedReportID: FAKE_REPORT_ID, selectedPolicyID: FAKE_POLICY_ID, isCreatingExpense: true});
+            await waitForBatchedUpdatesWithAct();
+
+            // Then a report accepted only for moving transactions is not offered for creation
+            expect(screen.queryByText('Expense Report')).toBeNull();
+        });
+
         const setUpCommuterExclusionTest = async () => {
             const currentReport: Report = {
                 reportID: 'currentReport',

tests/ui/MoneyRequestReportFooter.tsx

@@ -152,6 +152,14 @@ describe('MoneyRequestConfirmationListFooter', () => {
         return waitForBatchedUpdatesWithAct();
     });
 
+    beforeEach(async () => {
+        // Creation eligibility requires the signed-in user to be the report's submitter.
+        await act(async () => {
+            await Onyx.set(ONYXKEYS.SESSION, {accountID: FAKE_ACCOUNT_ID, email: 'reportfooter@example.com'});
+        });
+        await waitForBatchedUpdatesWithAct();
+    });
+
     afterEach(async () => {
         await act(async () => {
             await Onyx.clear();
@@ -199,7 +207,7 @@ describe('MoneyRequestConfirmationListFooter', () => {
         expect(reportItem.props.accessibilityState).toEqual(expect.objectContaining({disabled: false}));
     });
 
-    it('should allow editing report field when there is only 1 outstanding report and creating from policy chat', async () => {
+    it('should disable report field when there is only 1 outstanding report and creating from policy chat', async () => {
         // Given an expense created in a workspace chat whose workspace has one outstanding report, the one it goes on
         const mockTransactionReport: Transaction = {
             ...mockTransaction,
@@ -228,12 +236,12 @@ describe('MoneyRequestConfirmationListFooter', () => {
 
         await waitForBatchedUpdatesWithAct();
 
-        // Then the field can be changed, since the list always offers a new report next to that one
+        // Then creation keeps the field disabled because there is only one eligible report
         const reportItem = screen.getByTestId('menu-item-Report');
-        expect(reportItem.props.accessibilityState).toEqual(expect.objectContaining({disabled: false}));
+        expect(reportItem.props.accessibilityState).toEqual(expect.objectContaining({disabled: true}));
     });
 
-    it('should allow editing report field when there are no reports available', async () => {
+    it('should disable report field when there are no reports available', async () => {
         // Given an expense being created on a workspace with no outstanding report
         const mockTransactionReport: Transaction = {
             ...mockTransaction,
@@ -253,12 +261,12 @@ describe('MoneyRequestConfirmationListFooter', () => {
 
         await waitForBatchedUpdatesWithAct();
 
-        // Then the field can be changed, since the list offers a new report or no report at all
+        // Then creation keeps the field disabled because there are no eligible reports
         const reportItem = screen.getByTestId('menu-item-Report');
-        expect(reportItem.props.accessibilityState).toEqual(expect.objectContaining({disabled: false}));
+        expect(reportItem.props.accessibilityState).toEqual(expect.objectContaining({disabled: true}));
     });
 
-    it('should allow editing report field when transaction has reportID and creating from FAB with only 1 outstanding report', async () => {
+    it('should disable report field when transaction has reportID and creating from FAB with only 1 outstanding report', async () => {
         // Given an expense created from the global create button that already sits on the only outstanding report
         const mockTransactionReport: Transaction = {
             ...mockTransaction,
@@ -287,9 +295,9 @@ describe('MoneyRequestConfirmationListFooter', () => {
 
         await waitForBatchedUpdatesWithAct();
 
-        // Then the field can be changed, since the list always offers a new report next to that one
+        // Then creation keeps the field disabled because a reported expense requires more than one eligible report
         const reportItem = screen.getByTestId('menu-item-Report');
-        expect(reportItem.props.accessibilityState).toEqual(expect.objectContaining({disabled: false}));
+        expect(reportItem.props.accessibilityState).toEqual(expect.objectContaining({disabled: true}));
     });
 
     it('should allow editing report field when transaction is unReported and creating from FAB with only 1 outstanding report', async () => {