[$250] Imported personal card expenses not merging or reporting + incorrect icon post-merge

[m-natarajan]

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: 9.3.64-31
Reproducible in staging?: Needs Reproduction (Reproduction requires personal card with transactions)
Reproducible in production?: Needs Reproduction
If this was caught during regression testing, add the test name, ID and link from BrowserStack:
Email or phone of affected tester (no customers):
Logs: https://stackoverflow.com/c/expensify/questions/4856
Expensify/Expensify Issue URL:
Issue reported by: @RachCHopkins
Slack conversation (hyperlinked to channel name): #Expensify Bugs

Action Performed:

1. Expensify account with Collect workspace (default)
2. Submissions set to Manually
3. Receipt in that account
4. Import personal card transactions from CSV

Expected Result:

Card transactions import and add to a Draft Report
Receipts merge with card transactions
Card icon is shown

Actual Result:

Card transactions import and are unreported
Receipts are unmerged
After manual merge, the cash icon is the one displayed

Workaround:

Unknown

Platforms:

Select the officially supported platforms where the issue was reproduced:

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

Screenshots/Videos

View all open jobs on GitHub

Issue Owner

Current Issue Owner: @lakchote

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022050199153104348055
• Upwork Job ID: 2050199153104348055
• Last Price Increase: 2026-05-01

[MelvinBot]

Proposal

What is the root cause of that problem?

All three symptoms trace back to isFromCreditCardImport() explicitly returning false for CSV-imported transactions (bank === 'upload'):

if (transaction?.bank === CONST.COMPANY_CARD.FEED_BANK_NAME.UPLOAD) {
    return false;
}

This single exclusion cascades into all three symptoms:

1. Unreported transactions: buildOptimisticTransactions() sets reportID: '0' (unreported) on all CSV imports. No draft report is created client-side — the flow relies on the backend to assign transactions to reports.

2. No auto-merge with receipts: Since isFromCreditCardImport returns false for CSV imports, the merge matching system doesn't recognize them as card transactions. Receipts only auto-merge with transactions the system identifies as card imports.

3. Cash icon after manual merge: selectTargetAndSourceTransactionsForMerge() prioritizes isFromCreditCardImport transactions as the merge target (to preserve card metadata). Since CSV imports return false, the receipt/cash transaction can become the target instead, losing cardName/bank fields. Then getTransactionType() falls through to CASH because cardName is missing or includes 'Cash Expense'.

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

Symptom 3 (icon + merge target): The fix is in isFromCreditCardImport() — CSV-imported card transactions with bank === 'upload' that also have a valid cardID (or other card indicators set during import) should return true. This would fix both the merge target selection (card transaction becomes target, preserving card metadata) and the icon display.

A possible approach: instead of unconditionally returning false for bank === 'upload', check whether the transaction has a cardID set (which CSV imports do via buildOptimisticTransactions). If cardID is present and non-zero, the transaction is a card import regardless of bank type.

Symptoms 1 and 2 (unreported + no auto-merge): These likely involve backend logic (the ImportCSVTransactions command handler and server-side merge matching). The client-side reportID: '0' may be intentional as an optimistic placeholder expecting the backend to assign reports. Investigation of the backend ImportCSVTransactions handler would clarify whether report creation and auto-merge should happen server-side.

What alternative solutions did you explore? (Optional)

• Adding a new bank type constant (e.g., 'csv-card') distinct from 'upload' to differentiate CSV card imports from other uploads — rejected as higher scope and would require backend changes.
• Creating a draft report optimistically client-side in importTransactionsFromCSV — possible but the backend may already handle this, and duplicating report creation logic could cause conflicts.

Investigation details

Key code locations:

• isFromCreditCardImport() — the bank === 'upload' early return
• buildOptimisticTransactions() — sets reportID: '0' and cardID
• selectTargetAndSourceTransactionsForMerge() — target selection uses isFromCreditCardImport
• getMergeableDataAndConflictFields() — amount preservation only for card imports
• getTransactionType() — icon determination

Data flow for the icon bug:

1. CSV import creates transaction with bank='upload', cardID set, cardName set
2. Receipt creates a separate cash transaction
3. Manual merge: selectTargetAndSourceTransactionsForMerge doesn't prioritize CSV import as target
4. Receipt (cash) transaction becomes target → card metadata lost in merged result
5. getTransactionType sees no cardName → returns CASH → cash icon displayed

Note on isFromCreditCardImport comment: The existing code comment says the upload check is to "avoid search snapshot inconsistency," suggesting this exclusion was intentional for search display purposes but may not have accounted for merge behavior.

---

Next Steps for Contributor+ team: Reply with @MelvinBot implement this to create a draft PR, @MelvinBot <your feedback> to refine this analysis, or explain why you are rejecting Melvin's proposal.

[melvin-bot]

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

[melvin-bot]

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

[nabi-ebrahimi]

Proposal

What is the root cause of that problem?

There are two separate code paths behind the symptoms.

For reporting and automatic receipt matching, the App-side CSV import flow sends the ImportCSVTransactions command and creates optimistic transactions with reportID: '0' only. It does not create a draft report or run local receipt matching. That happens outside the public App code path. The relevant App code is buildOptimisticTransactions() and importTransactionsFromCSV(). A pure App PR cannot fully fix the “unreported” and “not auto-merged with receipts” behavior without a matching ImportCSVTransactions backend change.

For the incorrect icon after manual merge, the root cause is in the merge target selection. isFromCreditCardImport() intentionally returns false for bank === 'upload' to avoid search snapshot regressions. But selectTargetAndSourceTransactionsForMerge() only prioritizes transactions recognized by isFromCreditCardImport(), so an imported personal card transaction can lose to the cash receipt transaction as the merge target. Since buildMergedTransactionData() preserves metadata from the target transaction, the merged result can lose the card fields and getTransactionType() falls back to cash.

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

Keep the existing isFromCreditCardImport() upload exclusion, because current tests cover the search snapshot regression where upload transactions must not become normal card imports. Instead, make merge target selection handle imported personal card transactions narrowly.

• Add a local helper in MergeTransactionUtils that identifies uploaded personal card transactions by bank === CONST.PERSONAL_CARDS.BANK_NAME.CSV, a real cardID, and a non-cash cardName.
• Use that helper in selectTargetAndSourceTransactionsForMerge() so an imported personal card transaction is preserved as the merge target when merging with a cash receipt.
• Use the same helper in getMergeableDataAndConflictFields() so amount/currency and reimbursable values are preserved from the imported personal card transaction once it is the target.
• Do not change areTransactionsEligibleForMerge() or isFromCreditCardImport(), so the existing upload/search snapshot behavior remains intact.
• The remaining unreported and auto-merge symptoms require a backend fix in ImportCSVTransactions to assign imported personal card transactions to the correct draft report and run the same receipt matching behavior as other personal card imports.

Tests that should be added:

• selectTargetAndSourceTransactionsForMerge() keeps an uploaded personal card transaction as target when merging it with a cash receipt transaction.
• getMergeableDataAndConflictFields() preserves amount/currency and reimbursable from an uploaded personal card transaction target.
• Existing tests proving upload/search snapshot transactions are not treated as regular credit card imports should continue to pass.

MelvinBot’s proposal identifies the right shared utility area, but changing isFromCreditCardImport() to return true for bank === 'upload' plus cardID is regressive. The current test coverage explicitly protects upload transactions from being treated as normal card imports after search snapshot data adds transactionType: card.

The proposal to change the CSV import bank to a generic credit-card feed is not valid in the current code path. The repo has CONST.PERSONAL_CARDS.BANK_NAME.CSV set to upload, and there is no CONST.COMPANY_CARD.FEED_BANK_NAME.CREDIT_CARD constant to switch to.

What alternative solutions did you explore? (Optional)

[github-actions]

⚠️ @nabi-ebrahimi Thanks for your proposal. Please update it to follow the proposal template, as proposals are only reviewed if they follow that format (note the mandatory sections).

[github-actions]

⚠️ @aswin-s Your proposal is a duplicate of an already existing proposal and has been automatically withdrawn to prevent spam. Please review the existing proposals before submitting a new one.

[Yatin-Bhatti]

Proposal

What is the root cause of that problem?

The root cause is a Classification Logic Gap within the transaction ingestion pipeline. Currently, the application utilizes a Source-Exclusive Heuristic to identify credit card transactions.

The utility isFromCreditCardImport() is hard-coded to return false if the transaction source is bank === 'upload'. This creates a logical paradox for personal card imports: while these transactions are technically "uploaded" via CSV, they are semantically "Credit Card Transactions."
Because of this rigid classification:

1. Reporting Gap: The optimistic data builder (buildOptimisticTransactions) sees the "Upload" status and defaults the reportID to '0' (unreported) instead of routing it to an active Draft Report.
2. Merge Gap: The auto-merge system fails to trigger because it only looks for matches between "Receipts" and "Card Transactions." Since the CSV import is classified as a manual upload, the "Smart-Match" logic ignores it.
3. Visual Regression: During a manual merge, the system fails to identify the CSV import as the "Authoritative Metadata Source." It allows the cash/receipt transaction to become the "Target," which wipes the card-specific metadata and causes the icon to revert to a cash symbol.

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

I propose a Semantic Metadata Alignment strategy to ensure that "Personal Card" CSV imports are treated with the same functional priority as direct bank feeds:

1. Implement Intent-Based Tagging: During the CSV import flow (specifically within importTransactionsFromCSV in IOU.ts), I will ensure that the generated transactions are tagged with a specific origin: 'PERSONAL_CARD_CSV' or a persistent cardID reference.

2. Refactor the Classification Utility: I will update isFromCreditCardImport in TransactionUtils.ts to move away from a "Bank-Name-Only" check. The new logic will return true if the transaction possesses a valid cardID, regardless of whether the bank string is set to 'upload'.

3. Automated Report Grouping: I will update buildOptimisticTransactions to check for this new classification. If the transaction is a card-based import, the logic will programmatically resolve the correct Draft Report ID for the policy, ensuring the expenses are not orphaned as "unreported."

4. Preserve Card Identity in Merges: I will align the selectTargetAndSourceTransactionsForMerge logic to prioritize any transaction with a cardID. This ensures that when a user merges a receipt with a CSV-imported expense, the "Card" identity (and its icon) is preserved as the primary representation.

What alternative solutions did you explore? (Optional)

I considered a "Frontend-only" fix in MergeTransactionUtils. However, I rejected this because it would only fix the Icon issue and would leave the Unreported/Merge issues broken. I also reviewed the possibility of changing the bank name string from 'upload' to something else, but rejected it because it would break existing backend search filters that rely on that specific string. The Semantic Tagging approach is superior because it fixes the data classification at the source, allowing all downstream features (LHN, Search, and Merging) to function correctly and consistently.

[emkhalid]

Proposal

What is the root cause of that problem?

src/libs/actions/ImportTransactions.ts creates optimistic CSV-imported transactions with a cardID, but it does not put the card identity on the transaction itself. It also hardcodes reportID: '0', so the imported transactions are initially represented as unreported transactions with no cardName or bank.

App/src/libs/actions/ImportTransactions.ts

Lines 289 to 307 in 5d9c146

	function buildOptimisticTransactions(transactionList: TransactionFromCSV[], cardID: number, currency: string, isReimbursable: boolean): Transaction[] {
	return transactionList.map(
	(csvTransaction) =>
	({
	transactionID: csvTransaction.transactionID,
	cardID,
	created: csvTransaction.created,
	merchant: csvTransaction.merchant,
	amount: csvTransaction.amount,
	currency,
	category: csvTransaction.category ?? '',
	reimbursable: isReimbursable,
	pendingAction: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
	comment: {
	comment: '',
	},
	reportID: '0',
	}) as Transaction,
	);

That means the transaction row has no durable card metadata to preserve if it later goes through merge logic. A CSV personal card transaction can have a valid cardID, but the transaction object still looks like a generic unreported expense for display and merge purposes.

src/libs/MergeTransactionUtils.ts builds the merged transaction preview by spreading only targetTransaction and then applying selected merge fields. It does not receive or inspect sourceTransaction, so if the receipt/cash transaction is the target, the card metadata from the imported card transaction is dropped.

App/src/libs/MergeTransactionUtils.ts

Lines 361 to 398 in 5d9c146

	function buildMergedTransactionData(targetTransaction: OnyxEntry<Transaction>, mergeTransaction: OnyxEntry<MergeTransaction>): Transaction | null {
	if (!targetTransaction || !mergeTransaction) {
	return null;
	}
	return {
	...targetTransaction,
	amount: mergeTransaction.amount,
	modifiedAmount: mergeTransaction.amount,
	modifiedCurrency: mergeTransaction.currency,
	merchant: mergeTransaction.merchant,
	modifiedMerchant: mergeTransaction.merchant,
	category: mergeTransaction.category,
	tag: mergeTransaction.tag,
	comment: {
	...targetTransaction.comment,
	comment: mergeTransaction.description,
	customUnit: mergeTransaction.customUnit,
	waypoints: mergeTransaction.waypoints,
	attendees: mergeTransaction.attendees,
	...(mergeTransaction.odometerStart !== undefined && {odometerStart: mergeTransaction.odometerStart}),
	...(mergeTransaction.odometerEnd !== undefined && {odometerEnd: mergeTransaction.odometerEnd}),
	...(mergeTransaction.odometerStartImage !== undefined && {odometerStartImage: mergeTransaction.odometerStartImage}),
	...(mergeTransaction.odometerEndImage !== undefined && {odometerEndImage: mergeTransaction.odometerEndImage}),
	},
	reimbursable: mergeTransaction.reimbursable,
	billable: mergeTransaction.billable,
	receipt: mergeTransaction.receipt,
	created: mergeTransaction.created,
	modifiedCreated: mergeTransaction.created,
	reportID: mergeTransaction.reportID,
	reportName: mergeTransaction.reportName,
	routes: mergeTransaction.routes,
	taxValue: mergeTransaction.taxValue,
	taxAmount: mergeTransaction.taxAmount,
	taxCode: mergeTransaction.taxCode,
	taxName: mergeTransaction.taxName,
	};

src/pages/TransactionMerge/ConfirmationPage.tsx passes only targetTransaction and mergeTransaction into buildMergedTransactionData(), so the confirmation preview cannot recover card identity from the source transaction.

App/src/pages/TransactionMerge/ConfirmationPage.tsx

Lines 64 to 65 in 5d9c146

	// Build the merged transaction data for display
	const mergedTransactionData = buildMergedTransactionData(targetTransaction, mergeTransaction);

src/libs/actions/MergeTransaction.ts has the same issue for the optimistic merge update and API payload. The optimistic update only preserves the selected receipt, and the MergeTransaction params do not include card identity fields, so the kept transaction can lose cardID, cardName, cardNumber, and bank when the card transaction is not the target.

App/src/libs/actions/MergeTransaction.ts

Lines 285 to 291 in 5d9c146

	onyxData.optimisticData?.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.TRANSACTION}${targetTransaction.transactionID}`,
	value: {
	receipt: mergeTransaction.receipt ?? null,
	},
	});

App/src/libs/actions/MergeTransaction.ts

Lines 359 to 386 in 5d9c146

	const params: MergeTransactionParams = {
	transactionID: mergeTransaction.targetTransactionID,
	transactionIDList: [mergeTransaction.sourceTransactionID],
	created: mergeTransaction.created,
	merchant: mergeTransaction.merchant,
	amount: finalAmount,
	currency: mergeTransaction.currency,
	category: mergeTransaction.category,
	comment: JSON.stringify({
	...targetTransaction.comment,
	comment: mergeTransaction.description,
	customUnit: mergeTransaction.customUnit,
	waypoints: mergeTransaction.waypoints ?? null,
	attendees: mergeTransaction.attendees,
	originalTransactionID: mergeTransaction.originalTransactionID,
	...(mergeTransaction.odometerStart !== undefined && {odometerStart: mergeTransaction.odometerStart}),
	...(mergeTransaction.odometerEnd !== undefined && {odometerEnd: mergeTransaction.odometerEnd}),
	...(mergeTransaction.odometerStartImage !== undefined && {odometerStartImage: mergeTransaction.odometerStartImage}),
	...(mergeTransaction.odometerEndImage !== undefined && {odometerEndImage: mergeTransaction.odometerEndImage}),
	}),
	billable: mergeTransaction.billable,
	reimbursable: mergeTransaction.reimbursable,
	tag: mergeTransaction.tag,
	taxCode: mergeTransaction.taxCode,
	taxPolicyID: mergeTransaction.taxPolicyID,
	receiptID: mergeTransaction.receipt?.receiptID,
	reportID: mergeTransaction.reportID,
	};

Because getTransactionType() falls back to cash when cardName is missing or cash-like, the merged expense displays the cash icon after the card metadata is lost.

App/src/libs/TransactionUtils/index.ts

Lines 331 to 357 in 5d9c146

	function getTransactionType(transaction: OnyxEntry<Transaction>, card?: Card): ValueOf<typeof CONST.SEARCH.TRANSACTION_TYPE> {
	if (isDistanceRequest(transaction)) {
	return CONST.SEARCH.TRANSACTION_TYPE.DISTANCE;
	}
	if (isPerDiemRequest(transaction)) {
	return CONST.SEARCH.TRANSACTION_TYPE.PER_DIEM;
	}
	if (isTimeRequest(transaction)) {
	return CONST.SEARCH.TRANSACTION_TYPE.TIME;
	}
	if (isManagedCardTransaction(transaction)) {
	return CONST.SEARCH.TRANSACTION_TYPE.CARD;
	}
	if (card?.cardName === CONST.COMPANY_CARDS.CARD_NAME.CASH) {
	return CONST.SEARCH.TRANSACTION_TYPE.CASH;
	}
	if (!transaction?.cardName || transaction?.cardName?.includes(CONST.EXPENSE.TYPE.CASH_CARD_NAME)) {
	return CONST.SEARCH.TRANSACTION_TYPE.CASH;
	}
	return CONST.SEARCH.TRANSACTION_TYPE.CARD;
	}

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

First, preserve card identity on optimistic CSV-imported transactions in src/libs/actions/ImportTransactions.ts.

Original code:

App/src/libs/actions/ImportTransactions.ts

Lines 289 to 307 in 5d9c146

	function buildOptimisticTransactions(transactionList: TransactionFromCSV[], cardID: number, currency: string, isReimbursable: boolean): Transaction[] {
	return transactionList.map(
	(csvTransaction) =>
	({
	transactionID: csvTransaction.transactionID,
	cardID,
	created: csvTransaction.created,
	merchant: csvTransaction.merchant,
	amount: csvTransaction.amount,
	currency,
	category: csvTransaction.category ?? '',
	reimbursable: isReimbursable,
	pendingAction: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
	comment: {
	comment: '',
	},
	reportID: '0',
	}) as Transaction,
	);

Replace it with:

-function buildOptimisticTransactions(transactionList: TransactionFromCSV[], cardID: number, currency: string, isReimbursable: boolean): Transaction[] {
+function buildOptimisticTransactions(transactionList: TransactionFromCSV[], cardID: number, cardDisplayName: string, currency: string, isReimbursable: boolean): Transaction[] {
     return transactionList.map(
         (csvTransaction) =>
             ({
                 transactionID: csvTransaction.transactionID,
                 cardID,
+                cardName: cardDisplayName,
+                bank: CONST.PERSONAL_CARDS.BANK_NAME.CSV,
                 created: csvTransaction.created,

-    const {cardDisplayName = 'Imported Card', currency = CONST.CURRENCY.USD, isReimbursable = true, flipAmountSign = false} = settings;
+    const {cardDisplayName: configuredCardDisplayName, currency = CONST.CURRENCY.USD, isReimbursable = true, flipAmountSign = false} = settings;
+    const cardDisplayName = configuredCardDisplayName ?? previouslySavedLayout?.name ?? 'Imported Card';

-    const optimisticTransactions = buildOptimisticTransactions(transactionList, cardID, currency, isReimbursable);
+    const optimisticTransactions = buildOptimisticTransactions(transactionList, cardID, cardDisplayName, currency, isReimbursable);

This makes newly imported CSV card transactions carry the same card identity that the rest of the UI expects, without changing isFromCreditCardImport() or treating all upload transactions as normal card imports.

Next, preserve card identity during merge in src/libs/MergeTransactionUtils.ts.

Original code:

App/src/libs/MergeTransactionUtils.ts

Lines 361 to 398 in 5d9c146

	function buildMergedTransactionData(targetTransaction: OnyxEntry<Transaction>, mergeTransaction: OnyxEntry<MergeTransaction>): Transaction | null {
	if (!targetTransaction || !mergeTransaction) {
	return null;
	}
	return {
	...targetTransaction,
	amount: mergeTransaction.amount,
	modifiedAmount: mergeTransaction.amount,
	modifiedCurrency: mergeTransaction.currency,
	merchant: mergeTransaction.merchant,
	modifiedMerchant: mergeTransaction.merchant,
	category: mergeTransaction.category,
	tag: mergeTransaction.tag,
	comment: {
	...targetTransaction.comment,
	comment: mergeTransaction.description,
	customUnit: mergeTransaction.customUnit,
	waypoints: mergeTransaction.waypoints,
	attendees: mergeTransaction.attendees,
	...(mergeTransaction.odometerStart !== undefined && {odometerStart: mergeTransaction.odometerStart}),
	...(mergeTransaction.odometerEnd !== undefined && {odometerEnd: mergeTransaction.odometerEnd}),
	...(mergeTransaction.odometerStartImage !== undefined && {odometerStartImage: mergeTransaction.odometerStartImage}),
	...(mergeTransaction.odometerEndImage !== undefined && {odometerEndImage: mergeTransaction.odometerEndImage}),
	},
	reimbursable: mergeTransaction.reimbursable,
	billable: mergeTransaction.billable,
	receipt: mergeTransaction.receipt,
	created: mergeTransaction.created,
	modifiedCreated: mergeTransaction.created,
	reportID: mergeTransaction.reportID,
	reportName: mergeTransaction.reportName,
	routes: mergeTransaction.routes,
	taxValue: mergeTransaction.taxValue,
	taxAmount: mergeTransaction.taxAmount,
	taxCode: mergeTransaction.taxCode,
	taxName: mergeTransaction.taxName,
	};

Replace it with:

+type CardIdentityField = 'cardID' | 'cardName' | 'cardNumber' | 'bank';
+type CardIdentityData = Partial<Pick<Transaction, CardIdentityField>>;
+
+const CARD_IDENTITY_FIELDS: CardIdentityField[] = ['cardID', 'cardName', 'cardNumber', 'bank'];

+function isTransactionCardIdentitySource(transaction: OnyxEntry<Transaction>): boolean {
+    if (!transaction || transaction.cardName === CONST.EXPENSE.TYPE.CASH_CARD_NAME) {
+        return false;
+    }
+
+    return !!transaction.cardID || !!transaction.cardName || !!transaction.cardNumber || isFromCreditCardImport(transaction);
+}
+
+function getDefinedCardIdentityFields(transaction: OnyxEntry<Transaction>): CardIdentityData {
+    if (!transaction) {
+        return {};
+    }
+
+    return CARD_IDENTITY_FIELDS.reduce<CardIdentityData>((cardIdentityFields, field) => {
+        const value = transaction[field];
+        if (value !== undefined) {
+            return {...cardIdentityFields, [field]: value};
+        }
+        return cardIdentityFields;
+    }, {});
+}
+
+function getCardIdentityFieldsForMerge(targetTransaction: OnyxEntry<Transaction>, sourceTransaction: OnyxEntry<Transaction>): CardIdentityData {
+    if (isTransactionCardIdentitySource(targetTransaction)) {
+        return getDefinedCardIdentityFields(targetTransaction);
+    }
+
+    if (isTransactionCardIdentitySource(sourceTransaction)) {
+        return getDefinedCardIdentityFields(sourceTransaction);
+    }
+
+    return {};
+}

-function buildMergedTransactionData(targetTransaction: OnyxEntry<Transaction>, mergeTransaction: OnyxEntry<MergeTransaction>): Transaction | null {
+function buildMergedTransactionData(targetTransaction: OnyxEntry<Transaction>, mergeTransaction: OnyxEntry<MergeTransaction>, sourceTransaction?: OnyxEntry<Transaction>): Transaction | null {
     if (!targetTransaction || !mergeTransaction) {
         return null;
     }
 
+    const cardIdentityFields = getCardIdentityFieldsForMerge(targetTransaction, sourceTransaction);
+
     return {
         ...targetTransaction,

         taxAmount: mergeTransaction.taxAmount,
         taxCode: mergeTransaction.taxCode,
         taxName: mergeTransaction.taxName,
+        ...cardIdentityFields,
     };
 }

This keeps card identity from whichever merge participant has real card metadata. It fixes the preview without changing merge target selection, which avoids changing report/thread cleanup behavior.

Then pass the source transaction into the preview builder from src/pages/TransactionMerge/ConfirmationPage.tsx.

Original code:

App/src/pages/TransactionMerge/ConfirmationPage.tsx

Lines 64 to 65 in 5d9c146

	// Build the merged transaction data for display
	const mergedTransactionData = buildMergedTransactionData(targetTransaction, mergeTransaction);

Replace it with:

-    const mergedTransactionData = buildMergedTransactionData(targetTransaction, mergeTransaction);
+    const mergedTransactionData = buildMergedTransactionData(targetTransaction, mergeTransaction, sourceTransaction);

This gives the confirmation preview access to the card transaction even when the receipt/cash transaction is the merge target.

Next, preserve the same card identity in the optimistic merge update and API payload in src/libs/actions/MergeTransaction.ts.

Original code:

App/src/libs/actions/MergeTransaction.ts

Lines 285 to 291 in 5d9c146

	onyxData.optimisticData?.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.TRANSACTION}${targetTransaction.transactionID}`,
	value: {
	receipt: mergeTransaction.receipt ?? null,
	},
	});

App/src/libs/actions/MergeTransaction.ts

Lines 359 to 386 in 5d9c146

	const params: MergeTransactionParams = {
	transactionID: mergeTransaction.targetTransactionID,
	transactionIDList: [mergeTransaction.sourceTransactionID],
	created: mergeTransaction.created,
	merchant: mergeTransaction.merchant,
	amount: finalAmount,
	currency: mergeTransaction.currency,
	category: mergeTransaction.category,
	comment: JSON.stringify({
	...targetTransaction.comment,
	comment: mergeTransaction.description,
	customUnit: mergeTransaction.customUnit,
	waypoints: mergeTransaction.waypoints ?? null,
	attendees: mergeTransaction.attendees,
	originalTransactionID: mergeTransaction.originalTransactionID,
	...(mergeTransaction.odometerStart !== undefined && {odometerStart: mergeTransaction.odometerStart}),
	...(mergeTransaction.odometerEnd !== undefined && {odometerEnd: mergeTransaction.odometerEnd}),
	...(mergeTransaction.odometerStartImage !== undefined && {odometerStartImage: mergeTransaction.odometerStartImage}),
	...(mergeTransaction.odometerEndImage !== undefined && {odometerEndImage: mergeTransaction.odometerEndImage}),
	}),
	billable: mergeTransaction.billable,
	reimbursable: mergeTransaction.reimbursable,
	tag: mergeTransaction.tag,
	taxCode: mergeTransaction.taxCode,
	taxPolicyID: mergeTransaction.taxPolicyID,
	receiptID: mergeTransaction.receipt?.receiptID,
	reportID: mergeTransaction.reportID,
	};

Replace it with:

 import {
     areTransactionsEligibleForMerge,
     DERIVED_MERGE_FIELDS,
+    getCardIdentityFieldsForMerge,
     getMergeableDataAndConflictFields,

     targetTransactionThreadReport,
     targetTransactionThreadParentReport,
     targetTransactionThreadParentReportNextStep,
+    sourceTransaction,
     policy,

     targetTransactionThreadReport: OnyxEntry<Report>;
     targetTransactionThreadParentReport: OnyxEntry<Report>;
     targetTransactionThreadParentReportNextStep: OnyxEntry<ReportNextStepDeprecated>;
+    sourceTransaction: Transaction;
     policy: OnyxEntry<Policy>;

     let data: UpdateMoneyRequestData<UpdateMoneyRequestDataKeys>;
     const isUnreportedExpense = !mergeTransaction.reportID || mergeTransaction.reportID === CONST.REPORT.UNREPORTED_REPORT_ID;
+    const cardIdentityFields = getCardIdentityFieldsForMerge(targetTransaction, sourceTransaction);

         key: `${ONYXKEYS.COLLECTION.TRANSACTION}${targetTransaction.transactionID}`,
         value: {
             receipt: mergeTransaction.receipt ?? null,
+            ...cardIdentityFields,
         },
     });

     // This preserves the user's chosen sign while following the storage convention
     const finalAmount = -mergeTransaction.amount;
+    const cardIdentityFields = getCardIdentityFieldsForMerge(targetTransaction, sourceTransaction);
 
     // Call the merge transaction action

         taxPolicyID: mergeTransaction.taxPolicyID,
         receiptID: mergeTransaction.receipt?.receiptID,
         reportID: mergeTransaction.reportID,
+        ...cardIdentityFields,
     };

         targetTransactionThreadReport,
         targetTransactionThreadParentReport,
         targetTransactionThreadParentReportNextStep,
+        sourceTransaction,
         policy,

This makes the optimistic kept transaction and the merge request preserve the card metadata. The backend should use these params to keep the card fields on the merged transaction.

Finally, add the optional card identity fields to src/libs/API/parameters/MergeTransactionParams.ts.

Original code:

App/src/libs/API/parameters/MergeTransactionParams.ts

Lines 1 to 49 in 5d9c146

	type MergeTransactionParams = {
	/** Transaction ID we're keeping */
	transactionID: string;
	/** ID of the transaction we're merging into that will be deleted */
	transactionIDList: string[];
	/** Created date */
	created: string;
	/** Merchant which user want to keep */
	merchant: string;
	/** Category which user want to keep */
	category: string;
	/** Tag which user want to keep */
	tag: string;
	/** Description which user want to keep */
	comment: string;
	/** Whether the transaction is reimbursable */
	reimbursable: boolean;
	/** Whether the transaction is billable */
	billable: boolean;
	/** The receiptID we want to keep */
	receiptID: number | undefined;
	/** The amount of the transaction */
	amount: number;
	/** The currency of the transaction */
	currency: string;
	/** The report ID of the transaction */
	reportID: string;
	/** The tax code of the transaction */
	taxCode: string;
	/** The tax policy ID of the transaction */
	taxPolicyID: string;
	/** The created IOU report action ID of the transaction */
	createdIOUReportActionID?: string;
	};

Replace it with:

     /** The created IOU report action ID of the transaction */
     createdIOUReportActionID?: string;
+
+    /** The card ID to preserve when merging a receipt/cash expense into a card expense */
+    cardID?: number;
+
+    /** The card display name to preserve when merging a receipt/cash expense into a card expense */
+    cardName?: string;
+
+    /** The masked card number to preserve when merging a receipt/cash expense into a card expense */
+    cardNumber?: string;
+
+    /** The card bank/feed to preserve when merging a receipt/cash expense into a card expense */
+    bank?: string;
 };

This keeps the frontend request type aligned with the payload we send.

What alternative solutions did you explore? (Optional)

I considered changing isFromCreditCardImport() so bank === 'upload' with a cardID returns true. I rejected that because the current upload exclusion is intentional and protects search snapshot behavior where CSV uploads must not become normal card imports.

I considered changing selectTargetAndSourceTransactionsForMerge() so CSV card transactions always become the target. I rejected that because target selection also affects report/thread cleanup and delete behavior. Preserving card identity is narrower and fixes the icon without changing merge ownership.

I considered creating the Draft Report optimistically in importTransactionsFromCSV(). I rejected that because report assignment and receipt auto-matching are authoritative backend behaviors for ImportCSVTransactions; duplicating that report creation logic in App would risk conflicting optimistic reports.