[$250] Brex integration enters reconnect loop, freezes during card assignment, and fails to import transactions

[m-natarajan]

If you haven’t already, check out our contributing guidelines for onboarding. To join our Slack channel, fill out this form.

---

Version Number:
Reproducible in staging?: Needs Reproduction (Reproduction blocked - No credentials for Brex)
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: @JamieMcElroy
Slack conversation (hyperlinked to channel name): #Expensify Bugs

Action Performed:

1. Navigate to Company Cards
2. Observe error message: “Card feed connection is broken. Please log in to your bank so we can establish the connection again.”
3. Click to reconnect / log into BREX
4. Successfully authenticate and link the BREX account
5. Get redirected back to the Company Cards page
6. Observe the connection status (integration entered a continuous reconnect loop and never successfully reconnected)
7. After refreshing the connection, the red error banner is no longer displayed
8. The user attempts to assign new Brex cards to trigger authentication
9. Instead of launching the Brex login flow, the page freezes
10. Refreshing the browser does not recover the application or resolve the issue

Expected Result:

The Brex integration should reconnect successfully after completing authentication.
Assigning new Brex cards should launch the authentication flow as expected.
The application should remain responsive throughout the process.
All eligible Brex transactions should sync and appear after a successful connection refresh.

Actual Result:

The reconnect flow initially looped back to the reconnect error screen.
The reconnect error banner later disappeared without resolving the underlying issue.
Attempting to assign new Brex cards causes the page to freeze.
Refreshing the page does not resolve the frozen state.
Despite successfully refreshing the Brex connection in Classic Expensify, some expected Brex transactions remain missing in both Classic and New Expensify.

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

The screenshot for the issue is in Slack thread

View all open jobs on GitHub

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022074857017017478175
• Upwork Job ID: 2074857017017478175
• Last Price Increase: 2026-07-15

[MelvinBot]

Proposal

⚠️ Medium confidence — the frontend gating logic below is unambiguous in the code and matches the reported symptoms, but I could not confirm the affected feed's runtime state (broken-vs-expired) or the backend OAuth result without production logs. The reconnect loop and missing transactions are backend-rooted and are called out separately.

What is the root cause of that problem?

There are really two separate problems in this report:

1. Assign/reconnect freezes and the banner clears without fixing anything (App frontend).
The BankConnection flow treats a feed that is expired differently from one that is broken-but-not-expired, and only the expired path actually launches the Brex login window:

• "Expired" is a pure timestamp check on cardFeed.expiration — CardUtils.ts isSelectedFeedExpired.
• "Broken" is a completely different signal derived from the backend's lastScrapeResult — CardUtils.ts isCardConnectionBroken.

In the driving effect at BankConnection/index.tsx:118-145, when the feed is broken but not expired, the code calls updateBrokenConnection() + Navigation.closeRHPFlow() and returns — it never reaches openBankConnection(url), so the Brex login flow is never launched. openBankConnection(url) is only reachable on the isFeedExpired branch. If the Brex OAuth URL is also unavailable (url is null and it isn't Plaid), the page falls through to a permanent ActivityIndicator — the observed freeze that a browser refresh doesn't recover (refresh re-enters the same broken-not-expired state).

updateBrokenConnection() optimistically sets lastScrapeResult to SUCCESS (200) and a pending lastScrape (useUpdateFeedBrokenConnection.ts:24-35 → CompanyCards.ts updateWorkspaceCompanyCard). Both make isCardConnectionBroken return false, so the red banner clears optimistically on the client even though nothing was reconnected — exactly the "banner disappeared without resolving the underlying issue" symptom.

2. Reconnect loop + missing transactions (backend — outside the App repo).
For OAuth feeds like Brex, RefreshCardFeedConnectionPage.tsx:44-68 only closes the reconnect RHP when the backend updates cardFeeds[feed].expiration. If the Brex OAuth/token refresh doesn't actually renew server-side (so expiration never changes and the scrape still returns a broken code), the page re-presents the reconnect screen — the loop — and transactions never import because the connection was never truly restored. The App only displays what the backend scraper produces; it cannot fix the underlying Brex token/consent.

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

App frontend (this repo):

• In BankConnection/index.tsx, a broken direct/OAuth feed should launch the reconnect/login flow (openBankConnection(url)) rather than short-circuiting to updateBrokenConnection() + closeRHPFlow(). Add a fallback/error surface when no OAuth url is available so the user isn't left on an indefinite spinner (fixes the freeze / no-login-launch).
• Stop clearing the broken banner purely optimistically. Only hide it once the backend confirms a healthy scrape result, so the banner reflects reality (fixes "banner disappears without resolving").

Backend (requires escalation — not the App repo): The reconnect loop and missing Brex transactions require an internal engineer to investigate the Brex OAuth/FDX token refresh and card scrape. Please have someone pull this feed's lastScrapeResult/jsonCode (look for account-refresh/invalid_grant-style codes) and confirm whether the feed expiration is updated after re-auth. Since these are outside Expensify/App, MelvinBot can't propose code for them.

What alternative solutions did you explore? (Optional)

Considered a more robust RHP exit heuristic that also keys on a lastScrapeResult transition or a timeout instead of solely on expiration changing — but that's a mitigation for the loop symptom, not a fix for the backend token-refresh root cause.

Investigation details & evidence

• Broken vs expired are independent signals: isCardConnectionBroken (from lastScrapeResult, CardUtils.ts:1255) vs isSelectedFeedExpired (from expiration timestamp, CardUtils.ts:950).
• Only the isFeedExpired branch reaches openBankConnection(url); the broken-not-expired branch returns early after updateBrokenConnection() + closeRHPFlow() (BankConnection/index.tsx:118-145).
• Optimistic banner clear: CompanyCards.ts:595-702 sets lastScrapeResult: SUCCESS + pending lastScrape; finallyData clears the pending flag but does not restore the real result, so the banner stays cleared unless the backend contradicts it.
• OAuth loop exit depends on feed.expiration changing: RefreshCardFeedConnectionPage.tsx:44-68.
• What would confirm this: production logs showing (a) the Brex feed was broken-but-not-expired at freeze time, (b) whether the Brex OAuth callback was ever hit, (c) whether expiration updated after re-auth, and (d) the real lastScrapeResult code. If the OAuth callback was never hit while the feed was broken, that confirms the frontend gating as the freeze root cause.

Alternative explanation considered: the freeze could be purely a permanent-spinner state driven by a null OAuth URL rather than the gating branch. Both funnel through the same component and both are addressed by the frontend fix above.

---

Next Steps for Contributor+ team:
To accept: @MelvinBot implement [this](https://github.com/Expensify/App/issues/95604) to create a draft PR for the App frontend portion only. The reconnect-loop/missing-transactions portion needs an internal engineer.
To refine: @MelvinBot <your feedback>
To reject: Explain why you are rejecting Melvin's proposal.

[ahmdshrif]

🚨 Edited by proposal-police: This proposal was edited at 2026-07-08 14:13:08 UTC.

Proposal

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

After re-authenticating a broken Brex feed, the app enters a continuous reconnect loop; the error banner later clears without the connection actually being fixed; attempting to assign a Brex card freezes the page instead of launching the Brex login, and the freeze survives a browser refresh.

What is the root cause of that problem?

The broken-feed reconnect flow rests on two wrong assumptions: (1) a valid feed expiration timestamp means authentication is healthy, and (2) a broken connection can be repaired by blindly re-issuing one persisted SyncCard API write per broken card — with no guard against re-firing. Evidence chain:

1. The banner ("Card feed connection is broken…") routes into BankConnection via the broken-connection RHP:

   App/src/components/Tables/WorkspaceCompanyCardsTable/WorkspaceCompanyCardsTableHeaderButtons.tsx

   Lines 82 to 105 in d60639b

   	const openBankConnection = () => {
   	if (!feedName) {
   	return;
   	}
   	const institutionId = getPlaidInstitutionId(feedName);
   	const initialStep = institutionId ? CONST.COMPANY_CARD.STEP.PLAID_CONNECTION : CONST.COMPANY_CARD.STEP.BANK_CONNECTION;
   	// For Plaid feeds, seed selectedCountry so PlaidConnectionStep can start the login flow
   	if (institutionId) {
   	const country = getPlaidCountry(policy?.outputCurrency, currencyList, countryByIp);
   	setAddNewCompanyCardStepAndData({
   	data: {
   	selectedCountry: country,
   	},
   	});
   	}
   	setAssignCardStepAndData({currentStep: initialStep});
   	Navigation.setNavigationActionToMicrotaskQueue(() => {
   	Navigation.navigate(ROUTES.WORKSPACE_COMPANY_CARDS_BROKEN_CARD_FEED_CONNECTION.getRoute(policyID ?? String(CONST.DEFAULT_NUMBER_ID), feedName));
   	});
   	};

2. While the feed is expired, BankConnection's effect opens the Brex OAuth popup. Once re-auth succeeds and expiration refreshes, the effect re-runs and takes the !isFeedExpired branch: it calls updateBrokenConnection() and closes the RHP — it never re-opens the login from here on:

   App/src/pages/workspace/companyCards/BankConnection/index.tsx

   Lines 124 to 137 in d60639b

   	if (feed) {
   	if (!isFeedExpired) {
   	customWindow?.close();
   	if (isFeedConnectionBroken) {
   	updateBrokenConnection();
   	Navigation.closeRHPFlow();
   	return;
   	}
   	setAssignCardStepAndData({
   	currentStep: assignCard?.cardToAssign?.dateOption ? CONST.COMPANY_CARD.STEP.CONFIRMATION : CONST.COMPANY_CARD.STEP.ASSIGNEE,
   	isEditing: false,
   	});
   	return;
   	}

3. updateBrokenConnection fires one SyncCard write per broken card on the feed (a Brex fleet can be hundreds of cards):

   App/src/hooks/useUpdateFeedBrokenConnection.ts

   Lines 24 to 35 in d60639b

   	const updateBrokenConnection = useCallback(() => {
   	if (!feed) {
   	return;
   	}
   	const bankName = getCompanyCardFeed(feed);
   	for (const [brokenCardId, card] of Object.entries(cardsWithBrokenFeedConnection)) {
   	if (!card.fundID || getCardFeedWithDomainID(card.bank, card.fundID) !== feed) {
   	continue;
   	}
   	updateWorkspaceCompanyCard(domainOrWorkspaceAccountID, brokenCardId, bankName, card.lastScrapeResult);
   	}
   	}, [cardsWithBrokenFeedConnection, domainOrWorkspaceAccountID, feed]);

4. Each write optimistically stamps lastScrapeResult: SUCCESS (this is why the banner disappears "without resolving the underlying issue"), and on failure restores the broken code:

   App/src/libs/actions/CompanyCards.ts

   Lines 596 to 629 in d60639b

   	const optimisticData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.WORKSPACE_CARDS_LIST | typeof ONYXKEYS.CARD_LIST>> = [
   	{
   	onyxMethod: Onyx.METHOD.MERGE,
   	key: `${ONYXKEYS.COLLECTION.WORKSPACE_CARDS_LIST}${domainOrWorkspaceAccountID}_${bankName}`,
   	value: {
   	[cardID]: {
   	isLoadingLastUpdated: true,
   	lastScrapeResult: CONST.JSON_CODE.SUCCESS,
   	pendingFields: {
   	lastScrape: CONST.RED_BRICK_ROAD_PENDING_ACTION.UPDATE,
   	},
   	errorFields: {
   	lastScrape: null,
   	},
   	},
   	},
   	},
   	{
   	onyxMethod: Onyx.METHOD.MERGE,
   	key: ONYXKEYS.CARD_LIST,
   	value: {
   	[cardID]: {
   	lastScrapeResult: CONST.JSON_CODE.SUCCESS,
   	isLoadingLastUpdated: true,
   	pendingFields: {
   	lastScrape: CONST.RED_BRICK_ROAD_PENDING_ACTION.UPDATE,
   	},
   	errorFields: {
   	lastScrape: null,
   	},
   	},
   	},
   	},
   	];

   and

   App/src/libs/actions/CompanyCards.ts

   Lines 658 to 691 in d60639b

   	const failureData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.WORKSPACE_CARDS_LIST | typeof ONYXKEYS.CARD_LIST>> = [
   	{
   	onyxMethod: Onyx.METHOD.MERGE,
   	key: `${ONYXKEYS.COLLECTION.WORKSPACE_CARDS_LIST}${domainOrWorkspaceAccountID}_${bankName}`,
   	value: {
   	[cardID]: {
   	lastScrapeResult,
   	isLoadingLastUpdated: false,
   	pendingFields: {
   	lastScrape: null,
   	},
   	errorFields: {
   	lastScrape: ErrorUtils.getMicroSecondOnyxErrorWithTranslationKey('common.genericErrorMessage'),
   	},
   	},
   	},
   	},
   	{
   	onyxMethod: Onyx.METHOD.MERGE,
   	key: ONYXKEYS.CARD_LIST,
   	value: {
   	[cardID]: {
   	lastScrapeResult,
   	isLoadingLastUpdated: false,
   	pendingFields: {
   	lastScrape: null,
   	},
   	errorFields: {
   	lastScrape: ErrorUtils.getMicroSecondOnyxErrorWithTranslationKey('common.genericErrorMessage'),
   	},
   	},
   	},
   	},
   	];

5. The derived cardFeedErrors recomputes isFeedConnectionBroken from lastScrapeResult on every card-list merge:

   App/src/libs/actions/OnyxDerived/configs/cardFeedErrors.ts

   Lines 122 to 143 in d60639b

   	const isFeedConnectionBroken = isCardConnectionBroken(card);
   	const newFeedState: Omit<CardFeedErrorState, 'shouldShowRBR'> = {
   	isFeedConnectionBroken: isFeedConnectionBroken || previousFeedErrors.isFeedConnectionBroken,
   	hasFeedErrors: hasFeedErrors || previousFeedErrors.hasFeedErrors,
   	hasWorkspaceErrors: hasWorkspaceErrors || previousFeedErrors.hasWorkspaceErrors,
   	};
   	const shouldShowRBR = getShouldShowRBR(newFeedState) || previousFeedErrors.shouldShowRBR;
   	cardFeedErrors[feedNameWithDomainID] = {
   	...newFeedState,
   	shouldShowRBR,
   	cardErrors,
   	feedErrors,
   	workspaceErrors,
   	};
   	// Track cards with broken feed connection
   	if (isFeedConnectionBroken) {
   	cardsWithBrokenFeedConnection[card.cardID] = card;
   	}

   via

   App/src/libs/CardUtils.ts

   Lines 1255 to 1260 in d60639b

   	function isCardConnectionBroken(card: Card): boolean {
   	if (card.pendingFields?.lastScrape) {
   	return false;
   	}
   	return !!card.lastScrapeResult && !CONST.COMPANY_CARDS.BROKEN_CONNECTION_IGNORED_STATUSES.includes(card.lastScrapeResult);
   	}

6. The effect's dependency array includes isFeedConnectionBroken and updateBrokenConnection — the very values those writes toggle:

   App/src/pages/workspace/companyCards/BankConnection/index.tsx

   Lines 173 to 191 in d60639b

   	}, [
   	isNewFeedConnected,
   	isAllFeedsResultLoading,
   	shouldBlockWindowOpen,
   	isBlockedToAddNewFeeds,
   	newFeed,
   	policyID,
   	url,
   	feed,
   	isFeedExpired,
   	isOffline,
   	assignCard?.cardToAssign?.dateOption,
   	isPlaid,
   	onImportPlaidAccounts,
   	isFeedConnectionBroken,
   	updateBrokenConnection,
   	isNewFeedHasError,
   	checkForDuplicateFeed,
   	]);

   . So: optimistic write flips the flag false → each failed sync flips it true → effect re-fires → re-syncs → fails again. A self-sustaining loop of API writes, Onyx merges, O(all-cards) derived recomputes and navigation dispatches — the freeze. Because API.write requests are persisted in the offline queue, a browser refresh replays the whole SyncCard backlog serially, so refreshing does not recover.
7. Card assignment funnels into the same screen (useAssignCard → WORKSPACE_COMPANY_CARDS_BROKEN_CARD_FEED_CONNECTION):

   App/src/hooks/useAssignCard.ts

   Lines 112 to 117 in d60639b

   	Navigation.setNavigationActionToMicrotaskQueue(() => {
   	switch (initialStep) {
   	case CONST.COMPANY_CARD.STEP.PLAID_CONNECTION:
   	case CONST.COMPANY_CARD.STEP.BANK_CONNECTION:
   	Navigation.navigate(ROUTES.WORKSPACE_COMPANY_CARDS_BROKEN_CARD_FEED_CONNECTION.getRoute(policyID, feedName));
   	break;

   . With the feed un-expired but cards still broken, step 2's short-circuit fires the sync flood and instantly closes the RHP — "instead of launching the Brex login flow, the page freezes".

This ties every symptom: reconnect loop (2+6), banner clearing without a fix (4), assign freeze with no login (7+6), refresh not recovering (6), and transactions staying missing (cards are never successfully re-scraped while the queue churns). The native app has the identical unguarded branch:

App/src/pages/workspace/companyCards/BankConnection/index.native.tsx

Lines 123 to 128 in d60639b

	if (feed && !isFeedExpired) {
	if (isFeedConnectionBroken) {
	updateBrokenConnection();
	Navigation.goBack(ROUTES.WORKSPACE_COMPANY_CARDS.getRoute(policyID));
	return;
	}

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

In both BankConnection variants (web index.tsx#L124-L137, native index.native.tsx#L123-L128): run the broken-connection sync at most once per mount, and when a sync attempt has already failed, fall through to re-opening the bank login instead of dead-ending:

if (isFeedConnectionBroken) {
    if (!hasAttemptedSync.current && !hasBrokenConnectionSyncFailed) {
        hasAttemptedSync.current = true;
        updateBrokenConnection();
        Navigation.closeRHPFlow();
    } else if (url) {
        customWindow = openBankConnection(url); // let the user actually re-auth
    }
    return;
}

(On native the same guard applies, and the fallback is simply not calling Navigation.goBack so the already-rendered bank WebView stays up for re-auth.)

hasBrokenConnectionSyncFailed is exposed from useUpdateFeedBrokenConnection (any card in cardsWithBrokenFeedConnection for this feed carrying errorFields.lastScrape from a failed sync); in the same hook, skip cards with isLoadingLastUpdated so re-mounts (each banner click) can't enqueue duplicate SyncCard writes for in-flight cards. Regression safety in one sentence: the add-new-card flow, the Plaid path (driven by isRefreshing in RefreshCardFeedConnectionPage), and the personal-cards fix flow never enter this branch and are untouched, and the intent of Fix AMEX card feed reconnect PR #85126 (sync every broken card of the correct feed) is preserved — each card is still synced, exactly once.

Why the obvious spot fix fails: just guarding the effect (or pruning updateBrokenConnection/isFeedConnectionBroken from the deps) stops the infinite flood but leaves the user wedged — every subsequent assign/reconnect attempt is a fresh mount that still hits the !isFeedExpired short-circuit, silently closes the RHP, and never launches the Brex login, because that gate wrongly treats a live expiration timestamp as proof of valid auth even while every scrape is failing. Both halves — the once-per-mount guard and the failed-sync → re-auth fallback — are required to fix the loop and the frozen/dead-end assignment.

What alternative solutions did you explore? (Optional)

1. Deps-only patch (remove the unstable deps from the effect): kills the render-loop but misses the assign dead-end and still floods once per mount per click — incomplete.
2. Add a conflict/dedup resolver for SYNC_CARD in the persisted-request layer: protects the queue, but the effect keeps re-firing and the login still never re-opens; useful hardening, not the fix.
3. Backend: batch card re-sync into one command and clear scrape flags in the OAuth callback — the true upstream cure for the missing-transaction import, but the App-side fix above is what stops the loop, the freeze, and restores a working re-auth path, and is mergeable by an external contributor now.

[samranahm]

Proposal

What is the root cause of that problem?

There are two client-side symptoms with two distinct causes.

Freeze when assigning a Brex card. In useAssignCard, isAssigningCardDisabled becomes true whenever the selected feed connection is broken, because isSelectedFeedConnectionBroken is derived from feedErrors?.isFeedConnectionBroken || feedErrors?.hasFeedErrors:

App/src/hooks/useAssignCard.ts

Lines 49 to 128 in d60639b

	function useAssignCard({feedName, policyID, setShouldShowOfflineModal}: UseAssignCardProps) {
	const [cardFeeds] = useCardFeeds(policyID);
	const companyFeeds = getCompanyFeeds(cardFeeds);
	const currentFeedData = feedName ? companyFeeds?.[feedName] : ({} as CombinedCardFeed);
	const {translate} = useLocalize();
	const policy = usePolicy(policyID);
	const workspaceAccountID = policy?.policyAccountID ?? CONST.DEFAULT_NUMBER_ID;
	const companyCards = getCompanyFeeds(cardFeeds);
	const selectedFeedData = feedName && companyCards[feedName];
	const domainOrWorkspaceAccountID = getDomainOrWorkspaceAccountID(workspaceAccountID, selectedFeedData);
	const fetchCompanyCards = () => {
	const emailList = Object.keys(getMemberAccountIDsForWorkspace(policy?.employeeList));
	openPolicyCompanyCardsPage(policyID, domainOrWorkspaceAccountID, emailList, translate);
	};
	const {isOffline} = useNetwork({onReconnect: fetchCompanyCards});
	const {cardFeedErrors} = useCardFeedErrors();
	const feedErrors = feedName ? cardFeedErrors[feedName] : undefined;
	const isSelectedFeedConnectionBroken = !!feedErrors?.isFeedConnectionBroken || !!feedErrors?.hasFeedErrors;
	const isAllowedToIssueCompanyCard = useIsAllowedToIssueCompanyCard({policyID});
	const isAssigningCardDisabled = !currentFeedData || !!currentFeedData?.pending || isSelectedFeedConnectionBroken || !isAllowedToIssueCompanyCard;
	const getInitialAssignCardStep = useInitialAssignCardStep({policyID, selectedFeed: feedName});
	/**
	* Initiates the card assignment flow.
	* @param cardName - The masked card number displayed to users (e.g., "XXXX1234")
	* @param cardID - The identifier sent to backend (equals cardName for direct feeds)
	*/
	const assignCard = (cardName?: string, cardID?: string) => {
	if (isAssigningCardDisabled) {
	return;
	}
	if (!feedName || !cardID) {
	return;
	}
	const isCommercialFeed = isCustomFeed(feedName);
	// If the feed is a direct feed (not a commercial feed) and the user is offline,
	// show the offline alert modal to inform them of the connectivity issue.
	if (!isCommercialFeed && isOffline) {
	setShouldShowOfflineModal(true);
	return;
	}
	clearAddNewCardFlow();
	clearAssignCardStepAndData();
	const initialAssignCardStep = getInitialAssignCardStep(cardName, cardID);
	if (!initialAssignCardStep) {
	return;
	}
	const {initialStep, cardToAssign} = initialAssignCardStep;
	setAssignCardStepAndData({currentStep: initialStep, cardToAssign});
	Navigation.setNavigationActionToMicrotaskQueue(() => {
	switch (initialStep) {
	case CONST.COMPANY_CARD.STEP.PLAID_CONNECTION:
	case CONST.COMPANY_CARD.STEP.BANK_CONNECTION:
	Navigation.navigate(ROUTES.WORKSPACE_COMPANY_CARDS_BROKEN_CARD_FEED_CONNECTION.getRoute(policyID, feedName));
	break;
	case CONST.COMPANY_CARD.STEP.ASSIGNEE:
	default:
	Navigation.navigate(
	createDynamicRoute(DYNAMIC_ROUTES.WORKSPACE_COMPANY_CARDS_ASSIGN_CARD_ASSIGNEE.getRoute(feedName, cardID), ROUTES.WORKSPACE_COMPANY_CARDS.getRoute(policyID)),
	);
	break;
	}
	});
	};
	return {

When the user clicks to assign a Brex card while the feed still carries a broken-connection error, assignCard hits if (isAssigningCardDisabled) { return; } and exits silently. No Brex login flow launches and no feedback is shown, so the page appears frozen. That is exactly issue steps 8 and 9.

Reconnect loop / stale broken state. In WorkspaceCompanyCardsPage, both the onReconnect handler and the loadPolicyCompanyCardsFeed effect refetch the feed. loadPolicyCompanyCardsFeed is recreated whenever bankName, isFeedPending, or isLoading change:

App/src/pages/workspace/companyCards/WorkspaceCompanyCardsPage.tsx

Lines 32 to 111 in d60639b

	function WorkspaceCompanyCardsPage({route}: WorkspaceCompanyCardsPageProps) {
	const policyID = route.params.policyID;
	const {translate} = useLocalize();
	const {login: currentUserLogin = ''} = useCurrentUserPersonalDetails();
	const memoizedIllustrations = useMemoizedLazyIllustrations(['CompanyCard']);
	const {shouldUseNarrowLayout} = useResponsiveLayout();
	const policy = usePolicy(policyID);
	useWorkspaceDocumentTitle(policy?.name, 'workspace.common.companyCards');
	const workspaceAccountID = policy?.policyAccountID ?? CONST.DEFAULT_NUMBER_ID;
	const companyCards = useCompanyCards({policyID});
	const {
	allCardFeeds,
	feedName,
	selectedFeed,
	bankName,
	isFeedPending,
	isFeedAdded,
	onyxMetadata: {cardListMetadata},
	} = companyCards;
	const domainOrWorkspaceAccountID = getDomainOrWorkspaceAccountID(workspaceAccountID, selectedFeed);
	// Use a ref so that changes to the employee list (e.g. after inviting a member) don't
	// recreate the callback and trigger an unnecessary re-fetch that flashes a skeleton loader.
	const employeeListRef = useRef(policy?.employeeList);
	useEffect(() => {
	employeeListRef.current = policy?.employeeList;
	}, [policy?.employeeList]);
	const loadPolicyCompanyCardsPage = useCallback(() => {
	const emailList = Object.keys(getMemberAccountIDsForWorkspace(employeeListRef.current));
	openPolicyCompanyCardsPage(policyID, domainOrWorkspaceAccountID, emailList, translate);
	}, [domainOrWorkspaceAccountID, policyID, translate]);
	const {isOffline} = useNetwork({
	onReconnect: loadPolicyCompanyCardsPage,
	});
	const isLoading = !isOffline && (!allCardFeeds || (isFeedAdded && isLoadingOnyxValue(cardListMetadata)));
	const hasFeedsLoaded = !!allCardFeeds && Object.keys(allCardFeeds).length > 0;
	useEffect(() => {
	if (isOffline || hasFeedsLoaded) {
	return;
	}
	loadPolicyCompanyCardsPage();
	}, [loadPolicyCompanyCardsPage, isOffline, hasFeedsLoaded]);
	const loadPolicyCompanyCardsFeed = useCallback(() => {
	if (isLoading || !bankName || isFeedPending || isOffline) {
	return;
	}
	openPolicyCompanyCardsFeed(domainOrWorkspaceAccountID, policyID, bankName, translate);
	}, [bankName, domainOrWorkspaceAccountID, isFeedPending, isLoading, policyID, translate, isOffline]);
	useEffect(() => {
	loadPolicyCompanyCardsFeed();
	}, [loadPolicyCompanyCardsFeed]);
	const [shouldShowOfflineModal, setShouldShowOfflineModal] = useState(false);
	const {assignCard, isAssigningCardDisabled} = useAssignCard({feedName, policyID, setShouldShowOfflineModal});
	const canWriteCompanyCards = canMemberWrite(policy, currentUserLogin, CONST.POLICY.POLICY_FEATURE.COMPANY_CARDS);
	return (
	<AccessOrNotFoundWrapper
	policyID={route.params.policyID}
	featureName={CONST.POLICY.MORE_FEATURES.ARE_COMPANY_CARDS_ENABLED}
	policyFeature={CONST.POLICY.POLICY_FEATURE.COMPANY_CARDS}
	>
	<WorkspacePageWithSections
	icon={memoizedIllustrations.CompanyCard}
	headerText={translate('workspace.common.companyCards')}
	route={route}
	policyFeature={CONST.POLICY.POLICY_FEATURE.COMPANY_CARDS}
	shouldShowOfflineIndicatorInWideScreen

For a Brex feed whose connection is still marked broken, the fetch keeps re-reading the same broken state, which flips isFeedPending/isLoading, recreates the callback, and re-fires the effect. That is the continuous reconnect loop, and it is why the broken banner reappears then vanishes without the underlying error clearing.

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

1. In useAssignCard, separate the broken-connection case from the generic disabled no-op so the user is routed to reconnect instead of a silent freeze.

App/src/hooks/useAssignCard.ts

Lines 49 to 128 in d60639b

	function useAssignCard({feedName, policyID, setShouldShowOfflineModal}: UseAssignCardProps) {
	const [cardFeeds] = useCardFeeds(policyID);
	const companyFeeds = getCompanyFeeds(cardFeeds);
	const currentFeedData = feedName ? companyFeeds?.[feedName] : ({} as CombinedCardFeed);
	const {translate} = useLocalize();
	const policy = usePolicy(policyID);
	const workspaceAccountID = policy?.policyAccountID ?? CONST.DEFAULT_NUMBER_ID;
	const companyCards = getCompanyFeeds(cardFeeds);
	const selectedFeedData = feedName && companyCards[feedName];
	const domainOrWorkspaceAccountID = getDomainOrWorkspaceAccountID(workspaceAccountID, selectedFeedData);
	const fetchCompanyCards = () => {
	const emailList = Object.keys(getMemberAccountIDsForWorkspace(policy?.employeeList));
	openPolicyCompanyCardsPage(policyID, domainOrWorkspaceAccountID, emailList, translate);
	};
	const {isOffline} = useNetwork({onReconnect: fetchCompanyCards});
	const {cardFeedErrors} = useCardFeedErrors();
	const feedErrors = feedName ? cardFeedErrors[feedName] : undefined;
	const isSelectedFeedConnectionBroken = !!feedErrors?.isFeedConnectionBroken || !!feedErrors?.hasFeedErrors;
	const isAllowedToIssueCompanyCard = useIsAllowedToIssueCompanyCard({policyID});
	const isAssigningCardDisabled = !currentFeedData || !!currentFeedData?.pending || isSelectedFeedConnectionBroken || !isAllowedToIssueCompanyCard;
	const getInitialAssignCardStep = useInitialAssignCardStep({policyID, selectedFeed: feedName});
	/**
	* Initiates the card assignment flow.
	* @param cardName - The masked card number displayed to users (e.g., "XXXX1234")
	* @param cardID - The identifier sent to backend (equals cardName for direct feeds)
	*/
	const assignCard = (cardName?: string, cardID?: string) => {
	if (isAssigningCardDisabled) {
	return;
	}
	if (!feedName || !cardID) {
	return;
	}
	const isCommercialFeed = isCustomFeed(feedName);
	// If the feed is a direct feed (not a commercial feed) and the user is offline,
	// show the offline alert modal to inform them of the connectivity issue.
	if (!isCommercialFeed && isOffline) {
	setShouldShowOfflineModal(true);
	return;
	}
	clearAddNewCardFlow();
	clearAssignCardStepAndData();
	const initialAssignCardStep = getInitialAssignCardStep(cardName, cardID);
	if (!initialAssignCardStep) {
	return;
	}
	const {initialStep, cardToAssign} = initialAssignCardStep;
	setAssignCardStepAndData({currentStep: initialStep, cardToAssign});
	Navigation.setNavigationActionToMicrotaskQueue(() => {
	switch (initialStep) {
	case CONST.COMPANY_CARD.STEP.PLAID_CONNECTION:
	case CONST.COMPANY_CARD.STEP.BANK_CONNECTION:
	Navigation.navigate(ROUTES.WORKSPACE_COMPANY_CARDS_BROKEN_CARD_FEED_CONNECTION.getRoute(policyID, feedName));
	break;
	case CONST.COMPANY_CARD.STEP.ASSIGNEE:
	default:
	Navigation.navigate(
	createDynamicRoute(DYNAMIC_ROUTES.WORKSPACE_COMPANY_CARDS_ASSIGN_CARD_ASSIGNEE.getRoute(feedName, cardID), ROUTES.WORKSPACE_COMPANY_CARDS.getRoute(policyID)),
	);
	break;
	}
	});
	};
	return {

const assignCard = (cardName?: string, cardID?: string) => {
    if (isSelectedFeedConnectionBroken) {
        setShouldShowOfflineModal(true);
        return;
    }
    if (isAssigningCardDisabled) {
        return;
    }
    ...
};

This guarantees the click gives feedback and steers the user to the reconnect flow rather than appearing frozen.

2. In WorkspaceCompanyCardsPage, stop the loop by only refetching the feed when it is not already loaded and the connection is not broken, so the effect does not re-fire off its own state changes.

App/src/pages/workspace/companyCards/WorkspaceCompanyCardsPage.tsx

Lines 32 to 111 in d60639b

	function WorkspaceCompanyCardsPage({route}: WorkspaceCompanyCardsPageProps) {
	const policyID = route.params.policyID;
	const {translate} = useLocalize();
	const {login: currentUserLogin = ''} = useCurrentUserPersonalDetails();
	const memoizedIllustrations = useMemoizedLazyIllustrations(['CompanyCard']);
	const {shouldUseNarrowLayout} = useResponsiveLayout();
	const policy = usePolicy(policyID);
	useWorkspaceDocumentTitle(policy?.name, 'workspace.common.companyCards');
	const workspaceAccountID = policy?.policyAccountID ?? CONST.DEFAULT_NUMBER_ID;
	const companyCards = useCompanyCards({policyID});
	const {
	allCardFeeds,
	feedName,
	selectedFeed,
	bankName,
	isFeedPending,
	isFeedAdded,
	onyxMetadata: {cardListMetadata},
	} = companyCards;
	const domainOrWorkspaceAccountID = getDomainOrWorkspaceAccountID(workspaceAccountID, selectedFeed);
	// Use a ref so that changes to the employee list (e.g. after inviting a member) don't
	// recreate the callback and trigger an unnecessary re-fetch that flashes a skeleton loader.
	const employeeListRef = useRef(policy?.employeeList);
	useEffect(() => {
	employeeListRef.current = policy?.employeeList;
	}, [policy?.employeeList]);
	const loadPolicyCompanyCardsPage = useCallback(() => {
	const emailList = Object.keys(getMemberAccountIDsForWorkspace(employeeListRef.current));
	openPolicyCompanyCardsPage(policyID, domainOrWorkspaceAccountID, emailList, translate);
	}, [domainOrWorkspaceAccountID, policyID, translate]);
	const {isOffline} = useNetwork({
	onReconnect: loadPolicyCompanyCardsPage,
	});
	const isLoading = !isOffline && (!allCardFeeds || (isFeedAdded && isLoadingOnyxValue(cardListMetadata)));
	const hasFeedsLoaded = !!allCardFeeds && Object.keys(allCardFeeds).length > 0;
	useEffect(() => {
	if (isOffline || hasFeedsLoaded) {
	return;
	}
	loadPolicyCompanyCardsPage();
	}, [loadPolicyCompanyCardsPage, isOffline, hasFeedsLoaded]);
	const loadPolicyCompanyCardsFeed = useCallback(() => {
	if (isLoading || !bankName || isFeedPending || isOffline) {
	return;
	}
	openPolicyCompanyCardsFeed(domainOrWorkspaceAccountID, policyID, bankName, translate);
	}, [bankName, domainOrWorkspaceAccountID, isFeedPending, isLoading, policyID, translate, isOffline]);
	useEffect(() => {
	loadPolicyCompanyCardsFeed();
	}, [loadPolicyCompanyCardsFeed]);
	const [shouldShowOfflineModal, setShouldShowOfflineModal] = useState(false);
	const {assignCard, isAssigningCardDisabled} = useAssignCard({feedName, policyID, setShouldShowOfflineModal});
	const canWriteCompanyCards = canMemberWrite(policy, currentUserLogin, CONST.POLICY.POLICY_FEATURE.COMPANY_CARDS);
	return (
	<AccessOrNotFoundWrapper
	policyID={route.params.policyID}
	featureName={CONST.POLICY.MORE_FEATURES.ARE_COMPANY_CARDS_ENABLED}
	policyFeature={CONST.POLICY.POLICY_FEATURE.COMPANY_CARDS}
	>
	<WorkspacePageWithSections
	icon={memoizedIllustrations.CompanyCard}
	headerText={translate('workspace.common.companyCards')}
	route={route}
	policyFeature={CONST.POLICY.POLICY_FEATURE.COMPANY_CARDS}
	shouldShowOfflineIndicatorInWideScreen

const loadPolicyCompanyCardsFeed = useCallback(() => {
    if (isLoading || !bankName || isFeedPending || isOffline || hasFeedsLoaded) {
        return;
    }
    openPolicyCompanyCardsFeed(domainOrWorkspaceAccountID, policyID, bankName, translate);
}, [bankName, domainOrWorkspaceAccountID, isFeedPending, isLoading, policyID, translate, isOffline, hasFeedsLoaded]);

Gating on hasFeedsLoaded breaks the refetch cycle that keeps flipping isLoading/isFeedPending, so the reconnect state settles instead of looping.

What alternative solutions did you explore? (Optional)

Reminder: Please use plain English, be brief and avoid jargon. Feel free to use images, charts or pseudo-code if necessary. Do not post large multi-line diffs or write walls of text. Do not create PRs unless you have been hired for this job.

[dilshodmackbook-sketch]

🚨 Edited by proposal-police: This proposal was edited at 2026-07-08 14:18:07 UTC.

Proposal

What is the root cause of that problem?

Brex is a direct OAuth feed (oauth.brex.com), and the App has no path to re-authenticate a feed that is broken but not expired. "Expired" and "broken" are two independent signals — expiry is a timestamp on cardFeed.expiration, while "broken" is derived from the backend's lastScrapeResult in isCardConnectionBroken — and only the expired path ever opens the bank login window. Every client entry point for a broken feed dead-ends, which produces the two client-side symptoms in the report:

1. Assigning a new Brex card does nothing (steps 8–9). In useAssignCard, a broken connection folds straight into isAssigningCardDisabled, and assignCard bails out before it can navigate:

App/src/hooks/useAssignCard.ts

Lines 69 to 88 in 89bfa7e

	const {cardFeedErrors} = useCardFeedErrors();
	const feedErrors = feedName ? cardFeedErrors[feedName] : undefined;
	const isSelectedFeedConnectionBroken = !!feedErrors?.isFeedConnectionBroken || !!feedErrors?.hasFeedErrors;
	const isAllowedToIssueCompanyCard = useIsAllowedToIssueCompanyCard({policyID});
	const isAssigningCardDisabled = !currentFeedData || !!currentFeedData?.pending || isSelectedFeedConnectionBroken || !isAllowedToIssueCompanyCard;
	const getInitialAssignCardStep = useInitialAssignCardStep({policyID, selectedFeed: feedName});
	/**
	* Initiates the card assignment flow.
	* @param cardName - The masked card number displayed to users (e.g., "XXXX1234")
	* @param cardID - The identifier sent to backend (equals cardName for direct feeds)
	*/
	const assignCard = (cardName?: string, cardID?: string) => {
	if (isAssigningCardDisabled) {
	return;
	}
	if (!feedName || !cardID) {
	return;
	}

So while the feed carries a broken/hasFeedErrors state, tapping Assign card hits if (isAssigningCardDisabled) return; and exits silently — no login flow launches and no feedback is shown, which reads as the page being frozen.

2. The reconnect "loops" and the banner clears without fixing anything (steps 3, 6, 7). Clicking the banner's log into your bank link runs openBankConnection and lands on BankConnection. But for a feed that is broken and not expired, the driving effect short-circuits before it can open the OAuth window:

App/src/pages/workspace/companyCards/BankConnection/index.tsx

Lines 124 to 136 in 89bfa7e

	if (feed) {
	if (!isFeedExpired) {
	customWindow?.close();
	if (isFeedConnectionBroken) {
	updateBrokenConnection();
	Navigation.closeRHPFlow();
	return;
	}
	setAssignCardStepAndData({
	currentStep: assignCard?.cardToAssign?.dateOption ? CONST.COMPANY_CARD.STEP.CONFIRMATION : CONST.COMPANY_CARD.STEP.ASSIGNEE,
	isEditing: false,
	});
	return;

It calls updateBrokenConnection() + Navigation.closeRHPFlow() and returns — openBankConnection(url) is only reachable on the isFeedExpired branch. And updateBrokenConnection optimistically rewrites each broken card's lastScrapeResult to SUCCESS, so isCardConnectionBroken flips to false and the red banner clears client-side even though nothing reconnected. The next real scrape returns the same broken code, the banner comes back, the user clicks again — the reconnect loop.

The remaining symptoms — the loop persisting server-side and Brex transactions never importing (the report notes they're missing in Classic too) — are backend-rooted: the App only renders what the Brex scraper/expiration produce and can't renew the token itself.

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

Give a broken (non-expired) direct/OAuth feed the same reconnect treatment as an expired feed — actually open the bank login window, and never clear the banner until the backend confirms a healthy scrape.

In the BankConnection effect, a broken feed should launch the real reconnect window instead of optimistically clearing:

if (feed) {
    if (!isFeedExpired && !isFeedConnectionBroken) {
        customWindow?.close();
        setAssignCardStepAndData({
            currentStep: assignCard?.cardToAssign?.dateOption ? CONST.COMPANY_CARD.STEP.CONFIRMATION : CONST.COMPANY_CARD.STEP.ASSIGNEE,
            isEditing: false,
        });
        return;
    }
    if (isPlaid) {
        return;
    }
    if (url) {
        customWindow = openBankConnection(url);
        return;
    }
    // no OAuth url available -> surface an error state instead of an endless spinner
}

Supporting changes:

• Don't treat isFeedConnectionBroken as a hard block in assignCard. Instead route the Assign action into the reconnect flow — getInitialAssignCardStep already returns BANK_CONNECTION/PLAID_CONNECTION for expired feeds, so extend that same branch to broken feeds so clicking Assign card launches the login flow rather than no-op'ing.
• Stop clearing the banner purely optimistically in updateBrokenConnection; keep the real lastScrapeResult and only clear once a healthy scrape is confirmed, so the banner reflects reality.

Backend (needs internal escalation, outside Expensify/App): the persistent loop and missing Brex transactions require investigating the Brex OAuth/token refresh and scrape — whether cardFeeds[feed].expiration is renewed after re-auth and what lastScrapeResult/jsonCode the feed returns (look for invalid_grant/account-refresh codes).

What alternative solutions did you explore? (Optional)

We considered only fixing the Assign entry point (ungating isAssigningCardDisabled), but that still leaves the banner-link path short-circuiting to an optimistic clear, so the loop persists — both entry points share the one root cause and need the single reconnect path. We also considered keying the RHP exit off a lastScrapeResult transition or a timeout rather than solely expiration, but that only masks the loop symptom; the durable fix for the loop/missing transactions is the backend token refresh.

[melvin-bot]

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

[melvin-bot]

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

[KJ21-ENG]

🚨 Edited by proposal-police: This proposal was edited at 2026-07-08 14:20:59 UTC.

Proposal

What is the root cause of that problem?

There are two related signals in the company-card flow, and the App currently treats them as if they mean the same thing.

The broken-connection banner and the Assign disabled state are driven by card scrape state. A direct feed shows the banner when a card's backend-provided lastScrapeResult means the card connection is broken, and useAssignCard() also blocks assignment while the selected feed has that broken/error state.

App/src/components/Tables/WorkspaceCompanyCardsTable/getShouldShowBrokenConnectionError.ts

Lines 13 to 15 in d60639b

	function getShouldShowBrokenConnectionError(feedName: CompanyCardFeedWithDomainID, feedErrors: CardFeedErrorState | undefined): boolean {
	return (!!feedErrors?.isFeedConnectionBroken && isDirectFeed(feedName)) || !!feedErrors?.hasFeedErrors;
	}

App/src/libs/actions/OnyxDerived/configs/cardFeedErrors.ts

Lines 122 to 143 in d60639b

	const isFeedConnectionBroken = isCardConnectionBroken(card);
	const newFeedState: Omit<CardFeedErrorState, 'shouldShowRBR'> = {
	isFeedConnectionBroken: isFeedConnectionBroken || previousFeedErrors.isFeedConnectionBroken,
	hasFeedErrors: hasFeedErrors || previousFeedErrors.hasFeedErrors,
	hasWorkspaceErrors: hasWorkspaceErrors || previousFeedErrors.hasWorkspaceErrors,
	};
	const shouldShowRBR = getShouldShowRBR(newFeedState) || previousFeedErrors.shouldShowRBR;
	cardFeedErrors[feedNameWithDomainID] = {
	...newFeedState,
	shouldShowRBR,
	cardErrors,
	feedErrors,
	workspaceErrors,
	};
	// Track cards with broken feed connection
	if (isFeedConnectionBroken) {
	cardsWithBrokenFeedConnection[card.cardID] = card;
	}

App/src/libs/CardUtils.ts

Lines 1255 to 1260 in d60639b

	function isCardConnectionBroken(card: Card): boolean {
	if (card.pendingFields?.lastScrape) {
	return false;
	}
	return !!card.lastScrapeResult && !CONST.COMPANY_CARDS.BROKEN_CONNECTION_IGNORED_STATUSES.includes(card.lastScrapeResult);
	}

App/src/hooks/useAssignCard.ts

Lines 69 to 75 in d60639b

	const {cardFeedErrors} = useCardFeedErrors();
	const feedErrors = feedName ? cardFeedErrors[feedName] : undefined;
	const isSelectedFeedConnectionBroken = !!feedErrors?.isFeedConnectionBroken || !!feedErrors?.hasFeedErrors;
	const isAllowedToIssueCompanyCard = useIsAllowedToIssueCompanyCard({policyID});
	const isAssigningCardDisabled = !currentFeedData || !!currentFeedData?.pending || isSelectedFeedConnectionBroken || !isAllowedToIssueCompanyCard;
	const getInitialAssignCardStep = useInitialAssignCardStep({policyID, selectedFeed: feedName});

But the existing bank-login decision for an existing company-card feed is driven by cardFeed.expiration, not by the broken scrape state. In the feed branch of BankConnection, a broken-but-not-expired direct feed takes the !isFeedExpired branch, calls updateBrokenConnection(), closes the right-hand panel, and returns before the OAuth login branch can open. Brex is a direct OAuth feed, and isSelectedFeedExpired() also returns false when expiration is missing, so the same short-circuit can happen even when the user needs to log in again.

App/src/CONST/index.ts

Lines 4384 to 4389 in d60639b

	CITIBANK: 'oauth.citibank.com',
	CAPITAL_ONE: 'oauth.capitalone.com',
	BANK_OF_AMERICA: 'oauth.bankofamerica.com',
	CHASE: 'oauth.chase.com',
	BREX: 'oauth.brex.com',
	PEX: 'admin.pexcard.com',

App/src/pages/workspace/companyCards/BankConnection/index.tsx

Lines 118 to 145 in d60639b

	useEffect(() => {
	if ((!url && !isPlaid) || isOffline || isNewFeedHasError || isAllFeedsResultLoading || (isBlockedToAddNewFeeds && !feed)) {
	return;
	}
	// Handle assign card flow
	if (feed) {
	if (!isFeedExpired) {
	customWindow?.close();
	if (isFeedConnectionBroken) {
	updateBrokenConnection();
	Navigation.closeRHPFlow();
	return;
	}
	setAssignCardStepAndData({
	currentStep: assignCard?.cardToAssign?.dateOption ? CONST.COMPANY_CARD.STEP.CONFIRMATION : CONST.COMPANY_CARD.STEP.ASSIGNEE,
	isEditing: false,
	});
	return;
	}
	if (isPlaid) {
	return;
	}
	if (url) {
	customWindow = openBankConnection(url);
	return;
	}
	}

App/src/pages/workspace/companyCards/BankConnection/index.native.tsx

Lines 117 to 133 in d60639b

	useEffect(() => {
	if ((!url && !isPlaid) || isNewFeedHasError) {
	return;
	}
	// Handle assign card flow
	if (feed && !isFeedExpired) {
	if (isFeedConnectionBroken) {
	updateBrokenConnection();
	Navigation.goBack(ROUTES.WORKSPACE_COMPANY_CARDS.getRoute(policyID));
	return;
	}
	setAssignCardStepAndData({
	currentStep: assignCard?.cardToAssign?.dateOption ? CONST.COMPANY_CARD.STEP.CONFIRMATION : CONST.COMPANY_CARD.STEP.ASSIGNEE,
	isEditing: false,
	});
	return;

App/src/libs/CardUtils.ts

Lines 950 to 952 in d60639b

	function isSelectedFeedExpired(cardFeed: CombinedCardFeed | undefined): boolean {
	return cardFeed?.expiration ? isBefore(fromUnixTime(cardFeed.expiration), new Date()) : false;
	}

updateBrokenConnection() does not re-authenticate Brex. It loops over broken cards and calls SyncCard; updateWorkspaceCompanyCard() optimistically writes lastScrapeResult: SUCCESS and a pending lastScrape, both of which make the derived broken-connection state clear before the backend proves the connection is healthy. If the scrape then fails and the broken state returns, the effect can re-enter the same sync/close path instead of opening the bank login, which explains the loop, the banner disappearing without a real fix, and assignment appearing stuck.

App/src/hooks/useUpdateFeedBrokenConnection.ts

Lines 24 to 35 in d60639b

	const updateBrokenConnection = useCallback(() => {
	if (!feed) {
	return;
	}
	const bankName = getCompanyCardFeed(feed);
	for (const [brokenCardId, card] of Object.entries(cardsWithBrokenFeedConnection)) {
	if (!card.fundID || getCardFeedWithDomainID(card.bank, card.fundID) !== feed) {
	continue;
	}
	updateWorkspaceCompanyCard(domainOrWorkspaceAccountID, brokenCardId, bankName, card.lastScrapeResult);
	}
	}, [cardsWithBrokenFeedConnection, domainOrWorkspaceAccountID, feed]);

App/src/libs/actions/CompanyCards.ts

Lines 595 to 702 in d60639b

	function updateWorkspaceCompanyCard(domainOrWorkspaceAccountID: number, cardID: string, bankName: CompanyCardFeedWithNumber, lastScrapeResult?: number, breakConnection?: boolean) {
	const optimisticData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.WORKSPACE_CARDS_LIST | typeof ONYXKEYS.CARD_LIST>> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.WORKSPACE_CARDS_LIST}${domainOrWorkspaceAccountID}_${bankName}`,
	value: {
	[cardID]: {
	isLoadingLastUpdated: true,
	lastScrapeResult: CONST.JSON_CODE.SUCCESS,
	pendingFields: {
	lastScrape: CONST.RED_BRICK_ROAD_PENDING_ACTION.UPDATE,
	},
	errorFields: {
	lastScrape: null,
	},
	},
	},
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: ONYXKEYS.CARD_LIST,
	value: {
	[cardID]: {
	lastScrapeResult: CONST.JSON_CODE.SUCCESS,
	isLoadingLastUpdated: true,
	pendingFields: {
	lastScrape: CONST.RED_BRICK_ROAD_PENDING_ACTION.UPDATE,
	},
	errorFields: {
	lastScrape: null,
	},
	},
	},
	},
	];
	const finallyData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.WORKSPACE_CARDS_LIST | typeof ONYXKEYS.CARD_LIST>> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.WORKSPACE_CARDS_LIST}${domainOrWorkspaceAccountID}_${bankName}`,
	value: {
	[cardID]: {
	isLoadingLastUpdated: false,
	pendingFields: {
	lastScrape: null,
	},
	},
	},
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: ONYXKEYS.CARD_LIST,
	value: {
	[cardID]: {
	isLoadingLastUpdated: false,
	pendingFields: {
	lastScrape: null,
	},
	},
	},
	},
	];
	const failureData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.WORKSPACE_CARDS_LIST | typeof ONYXKEYS.CARD_LIST>> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.WORKSPACE_CARDS_LIST}${domainOrWorkspaceAccountID}_${bankName}`,
	value: {
	[cardID]: {
	lastScrapeResult,
	isLoadingLastUpdated: false,
	pendingFields: {
	lastScrape: null,
	},
	errorFields: {
	lastScrape: ErrorUtils.getMicroSecondOnyxErrorWithTranslationKey('common.genericErrorMessage'),
	},
	},
	},
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: ONYXKEYS.CARD_LIST,
	value: {
	[cardID]: {
	lastScrapeResult,
	isLoadingLastUpdated: false,
	pendingFields: {
	lastScrape: null,
	},
	errorFields: {
	lastScrape: ErrorUtils.getMicroSecondOnyxErrorWithTranslationKey('common.genericErrorMessage'),
	},
	},
	},
	},
	];
	const parameters: {cardID: number; breakConnection?: number} = {
	cardID: Number(cardID),
	};
	if (breakConnection) {
	// Simulate "Account refresh required" error code for testing
	parameters.breakConnection = 438;
	}
	API.write(WRITE_COMMANDS.SYNC_CARD, parameters, {optimisticData, finallyData, failureData});

App/src/pages/workspace/companyCards/BankConnection/index.tsx

Lines 173 to 191 in d60639b

	}, [
	isNewFeedConnected,
	isAllFeedsResultLoading,
	shouldBlockWindowOpen,
	isBlockedToAddNewFeeds,
	newFeed,
	policyID,
	url,
	feed,
	isFeedExpired,
	isOffline,
	assignCard?.cardToAssign?.dateOption,
	isPlaid,
	onImportPlaidAccounts,
	isFeedConnectionBroken,
	updateBrokenConnection,
	isNewFeedHasError,
	checkForDuplicateFeed,
	]);

The missing Brex transactions after a supposedly successful reconnect are separate from the App UI loop. The App reads company-card feeds/cards from backend commands and renders that state; transaction backfill and the real Brex OAuth/scrape result are owned by the company-card backend/provider flow, especially because the report says the same transactions are missing in Classic Expensify.

App/src/libs/actions/CompanyCards.ts

Lines 941 to 1052 in d60639b

	function openPolicyCompanyCardsPage(policyID: string, domainOrWorkspaceAccountID: number, emailList: string[], translate: LocaleContextProps['translate']) {
	// Skip loading state writes when domainOrWorkspaceAccountID is 0 since Onyx discards writes to collection keys with member ID '0'.
	const onyxLoadingStateUpdates = domainOrWorkspaceAccountID !== CONST.DEFAULT_NUMBER_ID;
	const optimisticData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.SHARED_NVP_PRIVATE_DOMAIN_MEMBER>> = onyxLoadingStateUpdates
	? [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.SHARED_NVP_PRIVATE_DOMAIN_MEMBER}${domainOrWorkspaceAccountID}`,
	value: {
	isLoading: true,
	errors: null,
	},
	},
	]
	: [];
	const successData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.SHARED_NVP_PRIVATE_DOMAIN_MEMBER>> = onyxLoadingStateUpdates
	? [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.SHARED_NVP_PRIVATE_DOMAIN_MEMBER}${domainOrWorkspaceAccountID}`,
	value: {
	isLoading: false,
	},
	},
	]
	: [];
	const failureData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.SHARED_NVP_PRIVATE_DOMAIN_MEMBER>> = onyxLoadingStateUpdates
	? [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.SHARED_NVP_PRIVATE_DOMAIN_MEMBER}${domainOrWorkspaceAccountID}`,
	value: {
	isLoading: false,
	errors: {
	[CONST.COMPANY_CARDS.WORKSPACE_FEEDS_LOAD_ERROR]: translate('workspace.companyCards.error.workspaceFeedsCouldNotBeLoadedMessage'),
	},
	},
	},
	]
	: [];
	const params: OpenPolicyExpensifyCardsPageParams = {
	policyID,
	emailList: JSON.stringify(emailList),
	};
	API.read(READ_COMMANDS.OPEN_POLICY_COMPANY_CARDS_PAGE, params, {optimisticData, successData, failureData});
	}
	function openPolicyCompanyCardsFeed(domainAccountID: number, policyID: string, feed: CompanyCardFeedWithNumber, translate: LocaleContextProps['translate']) {
	const parameters: OpenPolicyCompanyCardsFeedParams = {
	domainAccountID,
	policyID,
	feed,
	};
	const optimisticData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.SHARED_NVP_PRIVATE_DOMAIN_MEMBER>> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.SHARED_NVP_PRIVATE_DOMAIN_MEMBER}${domainAccountID}`,
	value: {
	settings: {
	cardFeedsStatus: {
	[feed]: {
	isLoading: true,
	errors: null,
	},
	},
	},
	},
	},
	];
	const successData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.SHARED_NVP_PRIVATE_DOMAIN_MEMBER>> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.SHARED_NVP_PRIVATE_DOMAIN_MEMBER}${domainAccountID}`,
	value: {
	settings: {
	cardFeedsStatus: {
	[feed]: {
	isLoading: false,
	},
	},
	},
	},
	},
	];
	const failureData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.SHARED_NVP_PRIVATE_DOMAIN_MEMBER>> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.SHARED_NVP_PRIVATE_DOMAIN_MEMBER}${domainAccountID}`,
	value: {
	settings: {
	cardFeedsStatus: {
	[feed]: {
	isLoading: false,
	errors: {
	[CONST.COMPANY_CARDS.FEED_LOAD_ERROR]: translate('workspace.companyCards.error.feedCouldNotBeLoadedMessage'),
	},
	},
	},
	},
	},
	},
	];
	API.read(READ_COMMANDS.OPEN_POLICY_COMPANY_CARDS_FEED, parameters, {optimisticData, successData, failureData});

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

In both BankConnection variants, handle a broken direct/OAuth feed as a re-authentication path instead of a plain sync-and-close path. For an existing feed, if isFeedExpired || isFeedConnectionBroken, open the bank connection URL (or render the native WebView) when a URL exists. If no URL exists, show a recoverable error/loading failure instead of leaving the page on an indefinite spinner.

After the OAuth return, run the broken-card sync in a guarded way and close/advance only after the backend state confirms recovery. Specifically:

• Do not call updateBrokenConnection() before the user has actually gone through the bank login path when the feed is broken.
• Track an in-flight/attempted refresh for the selected feed so repeated isFeedConnectionBroken changes cannot enqueue duplicate SyncCard writes for the same broken cards.
• Skip cards that already have pendingFields.lastScrape or isLoadingLastUpdated during the refresh.
• Avoid masking the banner with an optimistic lastScrapeResult: SUCCESS; keep a pending/loading state until the server returns a healthy scrape result, then let the derived cardFeedErrors[feed] state clear naturally.
• In RefreshCardFeedConnectionPage, do not use expiration changing as the only OAuth success signal. Keep the refresh right-hand panel open until the selected feed no longer has a broken feed/card error and the refresh sync is no longer pending.

Keep the Plaid add/import path separate, and keep healthy direct-feed assignment behavior the same: once the feed is not broken and the user picked a card, useAssignCard() should continue into the assignee/confirmation steps.

This App change should fix the NewDot loop, premature banner disappearance, and frozen/dead-end assignment flow. If Brex transactions are still missing after the App waits for a confirmed healthy scrape, that remaining import gap needs backend/provider investigation rather than another App UI change.

Test coverage:

• Add a web test and a native/unit coverage case for a direct OAuth feed where isFeedConnectionBroken is true but expiration is missing or still in the future; assert the Brex login path opens instead of updateBrokenConnection() immediately closing the flow.
• Add a regression test where a failed post-login SyncCard returns the broken state again; assert duplicate sync writes are not enqueued and the banner is not hidden as fixed.
• Add a refresh-flow test that keeps the panel open while pendingFields.lastScrape/isLoadingLastUpdated is set, then closes only after cardFeedErrors[feed] clears.
• Add a healthy direct-feed assignment test to confirm the assignee/confirmation flow still works when the feed is not broken.

What alternative solutions did you explore? (Optional)

I considered changing isSelectedFeedExpired() so broken direct feeds always look expired. That would make the login path easier to reach, but it would broaden a timestamp helper into a scrape-health helper and affect unrelated assignment callers. Keeping the fix in BankConnection and the refresh flow is more targeted.

I also considered a backend-only fix. Backend work may still be required for the missing Brex transaction import, but it would not fix the App-side short-circuit that can hide the banner and dead-end assignment before a real bank login happens.

[trasnake87]

🚫 Duplicated proposal withdrawn by 🤖 ProposalPolice.