[Due for payment 2026-08-06] [$250] Search: show expense count and total when "Select all matching items" is active

[luacmartins]

Problem

Classic shows expense count + total when selecting all matching expenses. NewDot Select all matching items sets areAllMatchingItemsSelected but shows no numeric count/total for ad-hoc filters (only saved searches + suggested-search tabs get server totals today).

Expected

Select all matching → show full-result count and total (count only when total can't be converted — same as Classic mixed-currency behavior).

Solution

Auth already returns search.count / search.total / search.currency when shouldCalculateTotals: true. Wire it up:

1. useSearchShouldCalculateTotals — return true when areAllMatchingItemsSelected
2. Refetch Search at offset: 0 with shouldCalculateTotals: true if count missing after select-all (keep totals on offset === 0 only)
3. SearchSelectionFooter — show footer + server metadata when select-all active
4. SearchBulkActionsButton — "X selected" from metadata.count, not generic "All matching items selected"
5. SearchPageFooter — hide total row when undefined (e.g. withdrawal-ID grouping)

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022071699629449390326
• Upwork Job ID: 2071699629449390326
• Last Price Increase: 2026-06-29

[lorretheboy]

Proposal

What is the root cause of that problem?

useSearchShouldCalculateTotals only returns true for suggested-search keys and saved searches. For an ad-hoc filter query (searchKey undefined, not in savedSearches) it always returns false, and it never looks at the selection state:

App/src/hooks/useSearchShouldCalculateTotals.ts

Lines 10 to 38 in 2746256

	const shouldCalculateTotals = useMemo(() => {
	if (!enabled) {
	return false;
	}
	if (!Object.keys(savedSearches ?? {}).length && !searchKey) {
	return false;
	}
	const eligibleSearchKeys: Partial<SearchKey[]> = [
	CONST.SEARCH.SEARCH_KEYS.SUBMIT,
	CONST.SEARCH.SEARCH_KEYS.APPROVE,
	CONST.SEARCH.SEARCH_KEYS.PAY,
	CONST.SEARCH.SEARCH_KEYS.EXPORT,
	CONST.SEARCH.SEARCH_KEYS.STATEMENTS,
	CONST.SEARCH.SEARCH_KEYS.UNAPPROVED_CASH,
	CONST.SEARCH.SEARCH_KEYS.UNAPPROVED_CARD,
	CONST.SEARCH.SEARCH_KEYS.RECONCILIATION,
	CONST.SEARCH.SEARCH_KEYS.TOP_CATEGORIES,
	CONST.SEARCH.SEARCH_KEYS.TOP_MERCHANTS,
	CONST.SEARCH.SEARCH_KEYS.TOP_SPENDERS,
	CONST.SEARCH.SEARCH_KEYS.SPEND_OVER_TIME,
	];
	const isSuggestedSearchWithTotals = eligibleSearchKeys.includes(searchKey);
	const isSavedSearch = searchHash !== undefined && savedSearches && !!savedSearches[searchHash];
	return isSuggestedSearchWithTotals || isSavedSearch;
	}, [enabled, savedSearches, searchKey, searchHash]);

So the causal chain is: ad-hoc filter → hook returns false → Search calls handleSearch with shouldCalculateTotals: false → Auth doesn't compute totals → searchResults.search.count/total/currency stay undefined. When the user then hits "Select all matching items", nothing re-requests totals, so the footer's gate is never satisfied and it renders nothing:

App/src/components/Search/SearchSelectionFooter.tsx

Lines 21 to 25 in 2746256

	const shouldAllowFooterTotals = useSearchShouldCalculateTotals(currentSearchKey, currentSearchQueryJSON?.hash, true);
	const metadata = searchResults?.search;
	const selectedTransactionsKeys = Object.keys(selectedTransactions ?? {});
	const shouldShowFooter = (!areAllMatchingItemsSelected && selectedTransactionsKeys.length > 0) || (shouldAllowFooterTotals && !!metadata?.count);

and the bulk-actions button falls back to the generic label instead of a count:

App/src/components/Search/SearchBulkActionsButton.tsx

Line 119 in 2746256

const selectionButtonText = areAllMatchingItemsSelected ? translate('search.exportAll.allMatchingItemsSelected') : translate('workspace.common.selected', {count: selectedItemsCount});

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

Fix it at the single convergence point — make useSearchShouldCalculateTotals also return true when all matching items are selected. Pass areAllMatchingItemsSelected (from useSearchSelectionContext) into the hook and return early-true on it, alongside the existing suggested/saved checks.

That alone drives the rest: in Search, shouldCalculateTotals is computed with offset === 0, so flipping it true on select-all makes the existing retry effect re-query at offset 0 with totals while leaving paginated pages untouched:

App/src/components/Search/index.tsx

Line 170 in 2746256

const shouldCalculateTotals = useSearchShouldCalculateTotals(currentSearchKey, hash, offset === 0);

Once metadata.count is populated, SearchSelectionFooter's gate passes and SearchBulkActionsButton should read the count from metadata.count instead of showing allMatchingItemsSelected.

Finally, guard the total row in SearchPageFooter so it's hidden when total is undefined (e.g. withdrawal-ID grouping returns count without a convertible total), matching Classic's count-only behavior:

App/src/components/Search/SearchPageFooter.tsx

Lines 46 to 49 in 2746256

	<View style={[styles.flexRow, styles.gap1]}>
	<Text style={styles.textLabelSupporting}>{`${translate('common.totalSpend')}:`}</Text>
	<Text style={valueTextStyle}>{convertToDisplayString(total, currency)}</Text>
	</View>

What alternative solutions did you explore? (Optional)

Leave the hook alone and instead OR areAllMatchingItemsSelected into the enabled/shouldCalculateTotals flags at each call site (index.tsx, SearchSelectionFooter). This works but spreads the same condition across multiple files and risks the call sites drifting out of sync; centralizing it in the hook keeps one source of truth.

[melvin-bot]

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

[kitvasyl]

Proposal

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

Selecting all matching Search results does not show the full expense count and total for arbitrary queries, even though the Search response can provide those values.

What is the root cause of that problem?

src/hooks/useSearchShouldCalculateTotals.ts enables shouldCalculateTotals only for saved searches and a fixed set of suggested search keys. It does not consider areAllMatchingItemsSelected, so ad-hoc searches do not request server-side count, total, and currency metadata.

Additionally, src/components/Search/SearchBulkActionsButton.tsx always renders the generic “All matching items selected” text in this state, while src/components/Search/SearchPageFooter.tsx renders the total row even when no scalar total exists.

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

Extend useSearchShouldCalculateTotals with the select-all-matching state and return true when it is active. Pass that state from the existing Search callers and refetch offset 0 with shouldCalculateTotals: true when selection changes to all matching and metadata is unavailable.

For this state, display the returned Search metadata: use search.count for the selected count and use search.total with search.currency in the footer. Fall back to the loaded-row count while metadata is unavailable, and update SearchPageFooter to render the total-spend row only when total is defined.

What alternative solutions did you explore? (Optional)

Computing the summary from loaded rows would be incorrect for matches outside the current page, so the existing server-side totals option should be reused instead.

[melvin-bot]

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

[KJ21-ENG]

Proposal

What is the root cause of that problem?

Selecting all matching search results only updates the selection context, while the totals eligibility hook still returns true only for eligible suggested searches or saved searches. For an ad-hoc expense search, selecting all matching items therefore does not make the Search request ask Auth for search.count, search.total, and search.currency.

App/src/hooks/useSearchShouldCalculateTotals.ts

Lines 7 to 40 in 2746256

	function useSearchShouldCalculateTotals(searchKey: SearchKey | undefined, searchHash: number | undefined, enabled: boolean) {
	const [savedSearches] = useOnyx(ONYXKEYS.SAVED_SEARCHES);
	const shouldCalculateTotals = useMemo(() => {
	if (!enabled) {
	return false;
	}
	if (!Object.keys(savedSearches ?? {}).length && !searchKey) {
	return false;
	}
	const eligibleSearchKeys: Partial<SearchKey[]> = [
	CONST.SEARCH.SEARCH_KEYS.SUBMIT,
	CONST.SEARCH.SEARCH_KEYS.APPROVE,
	CONST.SEARCH.SEARCH_KEYS.PAY,
	CONST.SEARCH.SEARCH_KEYS.EXPORT,
	CONST.SEARCH.SEARCH_KEYS.STATEMENTS,
	CONST.SEARCH.SEARCH_KEYS.UNAPPROVED_CASH,
	CONST.SEARCH.SEARCH_KEYS.UNAPPROVED_CARD,
	CONST.SEARCH.SEARCH_KEYS.RECONCILIATION,
	CONST.SEARCH.SEARCH_KEYS.TOP_CATEGORIES,
	CONST.SEARCH.SEARCH_KEYS.TOP_MERCHANTS,
	CONST.SEARCH.SEARCH_KEYS.TOP_SPENDERS,
	CONST.SEARCH.SEARCH_KEYS.SPEND_OVER_TIME,
	];
	const isSuggestedSearchWithTotals = eligibleSearchKeys.includes(searchKey);
	const isSavedSearch = searchHash !== undefined && savedSearches && !!savedSearches[searchHash];
	return isSuggestedSearchWithTotals || isSavedSearch;
	}, [enabled, savedSearches, searchKey, searchHash]);
	return shouldCalculateTotals ?? false;

App/src/components/Search/SearchSelectionProvider.tsx

Lines 124 to 133 in 2746256

	const selectAllMatchingItems: SearchSelectionActionsValue['selectAllMatchingItems'] = (shouldSelectAll) => {
	setSelectionState((prevState) => {
	if (prevState.areAllMatchingItemsSelected === shouldSelectAll) {
	return prevState;
	}
	return {
	...prevState,
	areAllMatchingItemsSelected: shouldSelectAll,
	};
	});

The selection footer only appears for select-all when totals are already allowed and a server count exists, so ad-hoc select-all never gets a footer with the full-result count/total. The bulk actions button also hard-codes the generic "All matching items selected" label instead of using the server count when it is available.

App/src/components/Search/SearchSelectionFooter.tsx

Lines 21 to 47 in 2746256

	const shouldAllowFooterTotals = useSearchShouldCalculateTotals(currentSearchKey, currentSearchQueryJSON?.hash, true);
	const metadata = searchResults?.search;
	const selectedTransactionsKeys = Object.keys(selectedTransactions ?? {});
	const shouldShowFooter = (!areAllMatchingItemsSelected && selectedTransactionsKeys.length > 0) || (shouldAllowFooterTotals && !!metadata?.count);
	if (!shouldShowFooter) {
	return null;
	}
	const shouldUseClientTotal = !metadata?.count || (selectedTransactionsKeys.length > 0 && !areAllMatchingItemsSelected);
	const selectedTransactionItems = Object.values(selectedTransactions);
	const currency = metadata?.currency ?? selectedTransactionItems.at(0)?.groupCurrency ?? selectedTransactionItems.at(0)?.currency;
	const count = shouldUseClientTotal
	? selectedTransactionsKeys.reduce((acc, key) => {
	if (isGroupEntry(key)) {
	const group = currentSearchResults?.data?.[key];
	return acc + (group?.count ?? 0);
	}
	const item = selectedTransactions[key];
	if (item.action === CONST.SEARCH.ACTION_TYPES.VIEW && key === item.reportID) {
	return acc;
	}
	return acc + 1;
	}, 0)
	: metadata?.count;
	const total = shouldUseClientTotal ? selectedTransactionItems.reduce((acc, transaction) => acc - (transaction.groupAmount ?? -Math.abs(transaction.amount)), 0) : metadata?.total;

App/src/components/Search/SearchBulkActionsButton.tsx

Lines 96 to 120 in 2746256

	const selectedItemsCount = useMemo(() => {
	if (!selectedTransactions) {
	return 0;
	}
	if (isExpenseReportType) {
	const reportIDs = new Set(
	Object.values(selectedTransactions)
	.map((transaction) => transaction?.reportID)
	.filter((reportID): reportID is string => !!reportID),
	);
	return reportIDs.size;
	}
	return selectedTransactionsKeys.reduce((count, key) => {
	if (key.startsWith(CONST.SEARCH.GROUP_PREFIX)) {
	const group = searchData?.[key as keyof typeof searchData] as {count?: number} | undefined;
	return count + (group?.count ?? 0);
	}
	return count + 1;
	}, 0);
	}, [selectedTransactions, selectedTransactionsKeys, isExpenseReportType, searchData]);
	const selectionButtonText = areAllMatchingItemsSelected ? translate('search.exportAll.allMatchingItemsSelected') : translate('workspace.common.selected', {count: selectedItemsCount});

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

Make areAllMatchingItemsSelected part of the totals eligibility path. When select-all matching is active, useSearchShouldCalculateTotals() should return true for the current search even if it is an ad-hoc search, while preserving the existing saved/suggested-search rules for normal page loads.

When select-all matching is active and search.count is missing, refetch the current search at offset: 0 with shouldCalculateTotals: true. Keep totals attached to the first page only so pagination does not clear or replace the metadata. The Search action already sends shouldCalculateTotals to the backend and clears totals only for an offset-0 search when the flag is false, so the fix should reuse that request path.

App/src/components/Search/index.tsx

Lines 170 to 204 in 2746256

	const shouldCalculateTotals = useSearchShouldCalculateTotals(currentSearchKey, hash, offset === 0);
	const previousReportActions = usePrevious(reportActions);
	const {translate} = useLocalize();
	const searchListRef = useRef<SelectionListHandle<SearchListItem> | null>(null);
	const savedSearchSelector = useCallback((searches: OnyxEntry<SaveSearch>) => searches?.[hash], [hash]);
	const [savedSearch] = useOnyx(ONYXKEYS.SAVED_SEARCHES, {
	selector: savedSearchSelector,
	});
	const validGroupBy = getValidGroupBy(groupBy);
	const prevValidGroupBy = usePrevious(validGroupBy);
	const isSearchResultsEmpty = !searchResults?.data || isSearchResultsEmptyUtil(searchResults, validGroupBy);
	const isSearchResultsEmptyRef = useRef(isSearchResultsEmpty);
	isSearchResultsEmptyRef.current = isSearchResultsEmpty;
	// When grouping by card, we need cardFeeds to display feed names
	const isCardFeedsLoading = validGroupBy === CONST.SEARCH.GROUP_BY.CARD && cardFeedsResult?.status === 'loading';
	useEffect(() => {
	if (prevValidGroupBy === validGroupBy) {
	return;
	}
	clearSelectedTransactions();
	}, [validGroupBy, prevValidGroupBy, clearSelectedTransactions]);
	const {newSearchResultKeys, handleSelectionListScroll, newTransactions, hasQueuedHighlights} = useSearchHighlightAndScroll({
	searchResults,
	transactions,
	previousTransactions,
	queryJSON,
	searchKey: currentSearchKey,
	offset,
	shouldCalculateTotals,

App/src/components/Search/index.tsx

Lines 358 to 419 in 2746256

	const shouldRetrySearchWithTotalsOrGroupedRef = useRef(false);
	useEffect(() => {
	const focusedRoute = findFocusedRoute(navigationRef.getRootState());
	const isMigratedModalDisplayed = focusedRoute?.name === NAVIGATORS.MIGRATED_USER_MODAL_NAVIGATOR || focusedRoute?.name === SCREENS.MIGRATED_USER_WELCOME_MODAL.DYNAMIC_ROOT;
	const comingBackOnlineWithNoResults = prevIsOffline && !isOffline && isEmptyObject(searchResults?.data);
	if (!comingBackOnlineWithNoResults && ((!isFocused && !isMigratedModalDisplayed) || isOffline)) {
	return;
	}
	// When mounting after the pre-insert fast path, the deferred write hasn't
	// been flushed yet. Triggering a search now would race with the CREATE
	// API call and return stale results that overwrite the optimistic row.
	// Skip this call; the optimistic data from flushDeferredWrite will populate
	// the list, and the next user-driven search will refresh from the server.
	if (hasPendingWriteOnMountRef.current.hasPendingWriteOnMount && hasDeferredWrite(CONST.DEFERRED_LAYOUT_WRITE_KEYS.SEARCH)) {
	return;
	}
	if (searchResults?.search?.isLoading) {
	if (validGroupBy || (shouldCalculateTotals && searchResults?.search?.count === undefined)) {
	shouldRetrySearchWithTotalsOrGroupedRef.current = true;
	}
	return;
	}
	handleSearch({
	queryJSON,
	searchKey: currentSearchKey,
	offset,
	shouldCalculateTotals,
	prevReportsLength: filteredDataLength,
	isLoading: !!searchResults?.search?.isLoading,
	});
	// We don't need to run the effect on change of isFocused.
	// eslint-disable-next-line react-hooks/exhaustive-deps
	}, [handleSearch, isOffline, offset, queryJSON, currentSearchKey, shouldCalculateTotals, validGroupBy]);
	useEffect(() => {
	if (!shouldRetrySearchWithTotalsOrGroupedRef.current || searchResults?.search?.isLoading || (!shouldCalculateTotals && !validGroupBy)) {
	return;
	}
	// If count is already present, the latest response already contains totals and we can skip the re-query.
	// If we show grouped values we want to retry search either way, the data may be outdated e.g. after deleting an expense.
	if (!validGroupBy && searchResults?.search?.count !== undefined) {
	shouldRetrySearchWithTotalsOrGroupedRef.current = false;
	return;
	}
	shouldRetrySearchWithTotalsOrGroupedRef.current = false;
	handleSearch({
	queryJSON,
	searchKey: currentSearchKey,
	offset,
	shouldCalculateTotals: true,
	prevReportsLength: filteredDataLength,
	isLoading: false,
	});
	}, [filteredDataLength, handleSearch, offset, queryJSON, currentSearchKey, searchResults?.search?.count, searchResults?.search?.isLoading, shouldCalculateTotals, validGroupBy]);

App/src/libs/actions/Search.ts

Lines 621 to 639 in 2746256

	function getOnyxLoadingData(
	hash: number,
	queryJSON?: Readonly<SearchQueryJSON>,
	offset?: number,
	isOffline?: boolean,
	isSearchAPI = false,
	shouldCalculateTotals?: boolean,
	): OnyxData<typeof ONYXKEYS.COLLECTION.SNAPSHOT> {
	const shouldClearTotals = isSearchAPI && shouldCalculateTotals === false && offset === 0;
	const optimisticData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.SNAPSHOT>> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.SNAPSHOT}${hash}`,
	value: {
	search: {
	...(isSearchAPI && {isLoading: true}),
	...(offset !== undefined ? {offset} : {}),
	...(shouldClearTotals ? {count: null, total: null, currency: null} : {}),
	},

App/src/libs/actions/Search.ts

Lines 838 to 897 in 2746256

	function search({
	queryJSON,
	searchKey,
	offset,
	shouldCalculateTotals = false,
	prevReportsLength,
	isOffline = false,
	isLoading,
	shouldUpdateLastSearchParams = false,
	skipWaitForWrites = false,
	}: {
	queryJSON: Readonly<SearchQueryJSON>;
	searchKey: SearchKey | undefined;
	offset?: number;
	shouldCalculateTotals?: boolean;
	prevReportsLength?: number;
	isOffline?: boolean;
	isLoading: boolean;
	shouldUpdateLastSearchParams?: boolean;
	/**
	* When true, fires the search API immediately without waiting for pending
	* writes in the sequential queue. Use for the post-expense-creation flow
	* where the expense write is deferred and search snapshot data lives in
	* separate Onyx keys, so there is no risk of the response overwriting
	* optimistic write data.
	*/
	skipWaitForWrites?: boolean;
	}) {
	if (isLoading || shouldPreventSearchAPI) {
	return;
	}
	const dedupeKey = `${queryJSON.hash}_${offset ?? 0}`;
	if (inFlightSearchRequests.has(dedupeKey)) {
	return;
	}
	inFlightSearchRequests.add(dedupeKey);
	const {optimisticData, finallyData, failureData} = getOnyxLoadingData(queryJSON.hash, queryJSON, offset, isOffline, true, shouldCalculateTotals);
	const {flatFilters, limit, ...queryJSONWithoutFlatFilters} = queryJSON;
	const backendQueryJSON = shouldUseBackendDateSortFallback(queryJSON.sortBy)
	? {
	...queryJSONWithoutFlatFilters,
	sortBy: CONST.SEARCH.TABLE_COLUMNS.DATE,
	inputQuery: buildSearchQueryString({...queryJSON, sortBy: CONST.SEARCH.TABLE_COLUMNS.DATE}),
	rawFilterList: queryJSONWithoutFlatFilters.rawFilterList?.map((filter) =>
	filter.key === CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_BY ? {...filter, value: CONST.SEARCH.TABLE_COLUMNS.DATE} : filter,
	),
	}
	: queryJSONWithoutFlatFilters;
	const query = {
	...backendQueryJSON,
	searchKey,
	offset,
	filters: backendQueryJSON.filters ?? null,
	shouldCalculateTotals,
	// Backend expects 'maximumResults' instead of 'limit'
	...(limit !== undefined && {maximumResults: limit}),
	};
	const jsonQuery = serializeQueryJSONForBackend(query);

Update SearchSelectionFooter so select-all uses search.count, search.total, and search.currency when present, falling back to the current client-selected calculation only before metadata is available or when the user is selecting individual visible rows. Update SearchBulkActionsButton to read the same metadata and show the selected count from search.count while select-all matching is active.

Finally, hide the total-spend row in SearchPageFooter when total or currency is undefined, so grouped cases that can return a count without a convertible total show count only instead of formatting an undefined total.

App/src/components/Search/SearchPageFooter.tsx

Lines 30 to 49 in 2746256

	return (
	<View
	style={[
	shouldUseNarrowLayout ? styles.justifyContentStart : styles.justifyContentEnd,
	styles.borderTop,
	styles.ph5,
	styles.pv3,
	styles.flexRow,
	styles.gap3,
	StyleUtils.getBackgroundColorStyle(theme.appBG),
	]}
	>
	<View style={[styles.flexRow, styles.gap1]}>
	<Text style={styles.textLabelSupporting}>{`${translate('common.expenses')}:`}</Text>
	<Text style={valueTextStyle}>{count}</Text>
	</View>
	<View style={[styles.flexRow, styles.gap1]}>
	<Text style={styles.textLabelSupporting}>{`${translate('common.totalSpend')}:`}</Text>
	<Text style={valueTextStyle}>{convertToDisplayString(total, currency)}</Text>
	</View>

Test coverage:

• Add hook coverage for useSearchShouldCalculateTotals() returning true when select-all matching is active for an otherwise ineligible ad-hoc search.
• Add component coverage for SearchSelectionFooter showing server count/total during select-all and count-only when total/currency are missing.
• Add component coverage for SearchBulkActionsButton showing the server count label during select-all matching.
• Manually verify an ad-hoc expense search: select all matching, confirm count and total appear, paginate, confirm totals remain stable, and verify a grouped withdrawal-ID search shows count only.

What alternative solutions did you explore? (Optional)

We could calculate the count and total from loaded client rows, but that would still be wrong for all matching results beyond the current page. Reusing the existing Search shouldCalculateTotals backend path is safer because Auth already returns the full-result metadata.

[github-actions]

⚠️ @KJ21-ENG 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.

[samranahm]

🚨 Edited by proposal-police: This proposal was edited at 2026-06-29 21:02:10 UTC.

Proposal

What is the root cause of that problem?

When a user runs an ad-hoc Search (custom filters, not a saved search or suggested-search tab) and chooses Select all matching items, NewDot marks every matching row as selected via areAllMatchingItemsSelected, but the UI never shows how many expenses that represents or their combined total.

Classic does show count + total in this state. NewDot does not, because server-side totals are only requested for a narrow set of searches today.

The gap is in how totals eligibility is decided. useSearchShouldCalculateTotals returns true only for suggested-search keys (Submit, Approve, Pay, etc.) or saved searches matched by hash. It does not consider selection state. For ad-hoc queries, shouldCalculateTotals stays false, so Auth never returns search.count, search.total, or search.currency even though the backend already supports them when shouldCalculateTotals: true.

That causes two visible failures:

1. SearchSelectionFooter only shows the footer for select-all when totals are already allowed and a server count exists — so ad-hoc select-all shows nothing.
2. SearchBulkActionsButton shows the generic string "All matching items selected" instead of a numeric count like "42 selected".

Selecting all matching items only flips a boolean in SearchSelectionProvider; nothing in the search request path changes to fetch full-result metadata for ad-hoc filters.

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

1. Extend useSearchShouldCalculateTotals — Add an areAllMatchingItemsSelected parameter (from useSearchSelectionContext). Return true when select-all is active, in addition to the existing suggested-search and saved-search checks. This keeps one source of truth instead of duplicating the condition at every call site.

2. Reuse the existing Search refetch path (no new API) — Search/index.tsx already computes shouldCalculateTotals at offset === 0 and has a retry effect that re-queries with shouldCalculateTotals: true when count is missing. Once the hook returns true on select-all, this existing machinery should refetch page 0 with totals. Paginated loads (offset > 0) should keep shouldCalculateTotals: false so metadata on page 0 is not cleared.

3. Update SearchSelectionFooter — When areAllMatchingItemsSelected is true and server metadata is present, show the footer using search.count, search.total, and search.currency. Keep the current client-side calculation as a fallback while metadata is loading or when the user selects individual visible rows only.

4. Update SearchBulkActionsButton — When select-all is active and search.count is available, show "X selected" (via workspace.common.selected) using the server count — not the generic "All matching items selected" label.

5. Guard SearchPageFooter for count-only cases — Some groupings (e.g. withdrawal-ID) can return a count without a convertible total (mixed currencies). Hide the total-spend row when total is undefined, matching Classic's count-only behavior. Still show the expense count.

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.