[$250] Tag - Required tag feature is missing for dependent tags

[IuliiaHerets]

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

---

Version Number: v9.4.8-0
Reproducible in staging?: Yes
Reproducible in production?: Yes
If this was caught during regression testing, add the test name, ID and link from BrowserStack: https://test-management.browserstack.com/projects/2219752/folder/13176676/test-cases/41237316

Action Performed:

1. As the admin navigate to the workspace settings
2. Enable tags if needed
3. Upload dependent tags to the policy

Expected Result:

We expect Required toggle button after tags csv upload

Actual Result:

Required toggle button is missing for dependent tags and its only visible for independent tags

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

608614205-aafbde29-59f3-4b77-bda1-090c6a84acb1.mov

View all open jobs on GitHub

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022066929150668733615
• Upwork Job ID: 2066929150668733615
• Last Price Increase: 2026-06-16

[MelvinBot]

Proposal

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

After uploading dependent (multi-level) tags via CSV, the per-tag-list Required toggle is missing. It only appears for independent tags.

What is the root cause of that problem?

This is intentional gating, not an accidental break. The Required toggle on the tag-list view is wrapped in a !hasDependentTags condition, so it never renders once the policy has dependent tags:

• WorkspaceViewTagsPage.tsx:403 — {!hasDependentTags && ( <ToggleSettingOptionRow title={translate('common.required')} … /> )}
• The tag-list overview does the same: for hasDependentTags it renders a read-only count instead of the Switch — WorkspaceTagsPage.tsx:255.
• hasDependentTags returns true when the policy has multiple tag lists and any tag carries a parentTagsFilter (which CSV-uploaded dependent tags do) — PolicyUtils.ts:1666.

Is there any way to set "required" for dependent tags today?

Not per-list. The only required-style control that still renders for dependent tags is the policy-wide requiresTag switch on WorkspaceTagsSettingsPage.tsx:108 (bound to policy.requiresTag, not the per-list required field). The backend action setPolicyTagsRequired already supports per-list required, so the capability exists — it's just not exposed in the dependent-tags UI.

⚠️ One product question must be answered before a fix. Because the guard is deliberate, the real question is: should each dependent tag list be independently markable as Required, or is the single policy-wide requiresTag the intended model for dependent tags? If the policy-wide toggle is intended, this is Not A Bug and the regression test expectation should be updated. If per-list required is desired, proceed with the fix below.

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

If per-list Required is the desired behavior for dependent tags, remove the !hasDependentTags guard so the toggle renders:

• WorkspaceViewTagsPage.tsx:403 — render the ToggleSettingOptionRow for dependent tags too. The existing onToggle already falls through to setPolicyTagsRequired(policyData, on, orderWeight) for the multi-level case, so it will work correctly.
• Optionally mirror in WorkspaceTagsPage.tsx:255 so the overview shows the Switch instead of a read-only count, matching independent multi-level lists.

Confidence: High on the mechanism (verified file:line); Medium on the fix, because removing a deliberate guard depends on the product answer above.

---

Next Steps for Contributor+ team:
To accept: @MelvinBot implement [this](https://github.com/Expensify/App/blob/cbfad7a708e9093d4bb2681fb6f3fe3c6eb35d4a/src/pages/workspace/tags/WorkspaceViewTagsPage.tsx#L403) to create a draft PR.
To refine: @MelvinBot <your feedback>
To reject: Explain why you are rejecting Melvin's proposal.

[MobileMage]

🚨 Edited by proposal-police: This proposal was edited at 2026-06-17 01:50:32 UTC.

Proposal

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

The top-level Required toggle in Tag Settings shows for independent multi-level tags, where it should not appear. Independent tags set Required per level in the RHP. Single-level and dependent multi-level tags keep the top-level toggle, since you can't require a single level in a dependent setup. Those two cases already work; independent multi-level is the broken one.

What is the root cause of that problem?

The top-level control on WorkspaceTagsSettingsPage.tsx is the policy-wide "Members must tag all expenses" switch (policy.requiresTag). Nothing gates it by tag type, so it renders for every config, including independent multi-level.

The per-level toggle on WorkspaceViewTagsPage.tsx already sits behind {!hasDependentTags && (...)}, so it shows for independent only and hides for dependent. That side works.

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

Gate the top-level requiresTag toggle so it renders for single-level and dependent, not for independent multi-level. hasDependentTags comes from PolicyUtils.hasDependentTags(policy, policyTags). Wrap the toggle with:

{(!isMultiLevelTags || hasDependentTags) && (...)}

Leave the per-level toggle on WorkspaceViewTagsPage gated by !hasDependentTags.

What alternative solutions did you explore? (Optional)

I considered a per-level Required toggle for dependent tags, but a dependent tag world can't require a single level, so that would break the agreed behavior.

[lorretheboy]

Proposal

What is the root cause of that problem?

On the tag-list view page, the "Required" toggle is wrapped in a !hasDependentTags guard, so the whole block is skipped whenever the policy uses dependent tags:

App/src/pages/workspace/tags/WorkspaceViewTagsPage.tsx

Lines 403 to 443 in cbfad7a

	{!hasDependentTags && (
	<View style={[styles.pv4, styles.ph5]}>
	<ToggleSettingOptionRow
	title={translate('common.required')}
	switchAccessibilityLabel={translate('common.required')}
	isActive={!!currentPolicyTag?.required}
	onToggle={(on) => {
	if (!canWriteTags) {
	showReadOnlyModal();
	return;
	}
	if (!isMultiLevelTags) {
	showConfirmModal({
	title: translate('workspace.tags.cannotMakeTagListRequired.title'),
	prompt: translate('workspace.tags.cannotMakeTagListRequired.description'),
	confirmText: translate('common.buttonConfirm'),
	shouldShowCancelButton: false,
	});
	return;
	}
	if (isMakingLastRequiredTagListOptional(policy, policyTags, [currentPolicyTag])) {
	showConfirmModal({
	title: translate('workspace.tags.cannotMakeAllTagsOptional.title'),
	prompt: translate('workspace.tags.cannotMakeAllTagsOptional.description'),
	confirmText: translate('common.buttonConfirm'),
	shouldShowCancelButton: false,
	});
	return;
	}
	setPolicyTagsRequired(policyData, on, orderWeight);
	}}
	pendingAction={currentPolicyTag.pendingFields?.required}
	errors={currentPolicyTag?.errorFields?.required ?? undefined}
	onCloseError={() => clearPolicyTagListErrorField({policyID, tagListIndex: orderWeight, errorField: 'required', policyTags})}
	disabled={!canWriteTags || (!currentPolicyTag?.required && !Object.values(currentPolicyTag?.tags ?? {}).some((tag) => tag.enabled))}
	disabledAction={withReadOnlyFallback()}
	showLockIcon={!canWriteTags || !isMultiLevelTags || isMakingLastRequiredTagListOptional(policy, policyTags, [currentPolicyTag])}
	/>
	</View>
	)}

hasDependentTags returns true as soon as any tag in a multi-level list carries a parentTagsFilter rule:

App/src/libs/PolicyUtils.ts

Lines 1666 to 1671 in cbfad7a

	function hasDependentTags(policy: OnyxEntry<Policy>, policyTagList: OnyxEntry<PolicyTagLists>) {
	if (!policy?.hasMultipleTagLists) {
	return false;
	}
	return Object.values(policyTagList ?? {}).some((tagList) => Object.values(tagList.tags).some((tag) => !!tag.rules?.parentTagsFilter || !!tag.parentTagsFilter));
	}

So for a dependent-tag policy the guard is always true → the ToggleSettingOptionRow never renders → the Required toggle disappears. But "required" is a property of the tag list itself (currentPolicyTag.required), and it is valid for any multi-level list, dependent or independent. Hiding it for dependent tags is therefore incorrect — the toggle's own handler already only acts when isMultiLevelTags is true, and dependent tags are multi-level.

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

Stop gating the Required toggle on !hasDependentTags. The block at the lines above should render for dependent tag lists too. Since the toggle is only meaningful for multi-level lists, gate it on isMultiLevelTags instead of !hasDependentTags:

App/src/pages/workspace/tags/WorkspaceViewTagsPage.tsx

Line 403 in cbfad7a

{!hasDependentTags && (

i.e. change {!hasDependentTags && ( to {isMultiLevelTags && (. The existing onToggle, disabled, and showLockIcon logic already handle the multi-level cases correctly, so no other change is needed for the toggle to work for dependent tags.

What alternative solutions did you explore? (Optional)

Simply remove the !hasDependentTags && wrapper entirely. The handler already shows the cannotMakeTagListRequired modal and a lock icon when !isMultiLevelTags, so single-level lists stay correctly disabled while dependent and independent multi-level lists both expose a working toggle.

[mukhrr]

Proposal

What is the root cause of that problem?

This is a stale UI gate, not a missing data/API capability.

Historically, the Required toggle was added to the tag-list detail page in 336c0366470, then intentionally hidden for dependent tags in 5f812e23309 / PR #43769:

5f812e2

Later, multi-level tag lists gained a proper per-list required action (SetPolicyTagsRequired) and the main Tags page renders a Required switch for independent multi-level tags, but the old dependent-tags exclusion was preserved. In WorkspaceTagsPage, dependent tags still take a separate branch that renders only the tag count instead of the same Switch used by independent multi-level tags:

App/src/pages/workspace/tags/WorkspaceTagsPage.tsx

Lines 247 to 284 in 2138f48

	const tagList = useMemo<TagListItem[]>(() => {
	if (isMultiLevelTags) {
	return policyTagLists.map((policyTagList) => {
	const areTagsEnabled = !!Object.values(policyTagList?.tags ?? {}).some((tag) => tag.enabled);
	const isSwitchDisabled = !policyTagList.required && !areTagsEnabled;
	const isSwitchEnabled = policyTagList.required && areTagsEnabled;
	let rightElement;
	if (hasDependentTags) {
	rightElement = canWriteTags ? (
	<ListItemRightCaretWithLabel labelText={translate('workspace.tags.tagCount', {count: Object.keys(policyTagList?.tags ?? {}).length})} />
	) : (
	<Text>{translate('workspace.tags.tagCount', {count: Object.keys(policyTagList?.tags ?? {}).length})}</Text>
	);
	} else {
	rightElement = (
	<Switch
	isOn={isSwitchEnabled}
	accessibilityLabel={translate('workspace.tags.requiresTag')}
	onToggle={(newValue: boolean) => {
	if (isMakingLastRequiredTagListOptional(policy, policyTags, [policyTagList])) {
	showConfirmModal({
	title: translate('workspace.tags.cannotMakeAllTagsOptional.title'),
	prompt: translate('workspace.tags.cannotMakeAllTagsOptional.description'),
	confirmText: translate('common.buttonConfirm'),
	shouldShowCancelButton: false,
	});
	return;
	}
	updateWorkspaceRequiresTag(newValue, policyTagList.orderWeight);
	}}
	disabled={isSwitchDisabled || !canWriteTags}
	disabledAction={withReadOnlyFallback()}
	showLockIcon={!canWriteTags || isMakingLastRequiredTagListOptional(policy, policyTags, [policyTagList])}
	/>
	);
	}

The same stale gate also exists on the tag-list detail page:

App/src/pages/workspace/tags/WorkspaceViewTagsPage.tsx

Lines 403 to 443 in 2138f48

	{!hasDependentTags && (
	<View style={[styles.pv4, styles.ph5]}>
	<ToggleSettingOptionRow
	title={translate('common.required')}
	switchAccessibilityLabel={translate('common.required')}
	isActive={!!currentPolicyTag?.required}
	onToggle={(on) => {
	if (!canWriteTags) {
	showReadOnlyModal();
	return;
	}
	if (!isMultiLevelTags) {
	showConfirmModal({
	title: translate('workspace.tags.cannotMakeTagListRequired.title'),
	prompt: translate('workspace.tags.cannotMakeTagListRequired.description'),
	confirmText: translate('common.buttonConfirm'),
	shouldShowCancelButton: false,
	});
	return;
	}
	if (isMakingLastRequiredTagListOptional(policy, policyTags, [currentPolicyTag])) {
	showConfirmModal({
	title: translate('workspace.tags.cannotMakeAllTagsOptional.title'),
	prompt: translate('workspace.tags.cannotMakeAllTagsOptional.description'),
	confirmText: translate('common.buttonConfirm'),
	shouldShowCancelButton: false,
	});
	return;
	}
	setPolicyTagsRequired(policyData, on, orderWeight);
	}}
	pendingAction={currentPolicyTag.pendingFields?.required}
	errors={currentPolicyTag?.errorFields?.required ?? undefined}
	onCloseError={() => clearPolicyTagListErrorField({policyID, tagListIndex: orderWeight, errorField: 'required', policyTags})}
	disabled={!canWriteTags || (!currentPolicyTag?.required && !Object.values(currentPolicyTag?.tags ?? {}).some((tag) => tag.enabled))}
	disabledAction={withReadOnlyFallback()}
	showLockIcon={!canWriteTags || !isMultiLevelTags || isMakingLastRequiredTagListOptional(policy, policyTags, [currentPolicyTag])}
	/>
	</View>
	)}

The backend/action path already supports updating a specific tag list by index:

App/src/libs/actions/Policy/Tag.ts

Lines 1069 to 1127 in 2138f48

	function setPolicyTagsRequired(policyData: PolicyData, requiresTag: boolean, tagListIndex: number) {
	const policyTag = PolicyUtils.getTagLists(policyData.tags)?.at(tagListIndex);
	if (!policyTag?.name) {
	return;
	}
	const policyID = policyData.policy?.id;
	const policyTagsOptimisticData = {
	[policyTag.name]: {
	required: requiresTag,
	pendingFields: {required: CONST.RED_BRICK_ROAD_PENDING_ACTION.UPDATE},
	errorFields: {required: null},
	},
	};
	const onyxData: OnyxData<typeof ONYXKEYS.COLLECTION.POLICY_TAGS> = {
	optimisticData: [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.POLICY_TAGS}${policyID}`,
	value: policyTagsOptimisticData,
	},
	],
	successData: [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.POLICY_TAGS}${policyID}`,
	value: {
	[policyTag.name]: {
	pendingFields: {required: null},
	},
	},
	},
	],
	failureData: [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.POLICY_TAGS}${policyID}`,
	value: {
	[policyTag.name]: {
	required: policyTag.required,
	pendingFields: {required: null},
	errorFields: {
	required: ErrorUtils.getMicroSecondOnyxErrorWithTranslationKey('workspace.tags.genericFailureMessage'),
	},
	},
	},
	},
	],
	};
	pushTransactionViolationsOnyxData(onyxData, policyData, {}, {}, policyTagsOptimisticData);
	const parameters: SetPolicyTagsRequired = {
	policyID,
	tagListIndex,
	requireTagList: requiresTag,
	};
	API.write(WRITE_COMMANDS.SET_POLICY_TAGS_REQUIRED, parameters, onyxData);

Other dependent-tag code already consumes per-list required, so this UI restriction is inconsistent. For example, tag picker visibility treats each dependent tag list as required if tagList.required is true:

App/src/libs/TagsOptionsListUtils.ts

Lines 215 to 217 in 2138f48

	return policyTagLists.map(({tags, required}, index) => {
	const isTagRequired = required || !!policy?.requiresTag;
	let shouldShow = false;

And dependent-tag violations check each tag list’s required value:

App/src/libs/Violations/ViolationsUtils.ts

Lines 145 to 152 in 2138f48

	// Only flag ALL_TAG_LEVELS_REQUIRED if a required tag level is empty or missing.
	// Previously this used `tags.includes('')` and a length check which flagged any
	// empty/missing level regardless of whether it was required, causing false violations
	// when only some levels were filled (e.g. "Engineering" with non-required second level).
	const hasEmptyRequiredLevel = policyTagKeys.some((key, index) => {
	const tagValue = tags.at(index) ?? '';
	return tagValue === '' && (policyTagList[key]?.required ?? true);
	});

So the root cause is that the UI still assumes dependent tag lists cannot expose the Required toggle, while the rest of the app now supports per-list required state for dependent tags.

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

Show the same per-tag-list Required control for dependent and independent multi-level tags, while preserving the current safeguards.

Small illustrative diff:

diff --git a/src/pages/workspace/tags/WorkspaceTagsPage.tsx b/src/pages/workspace/tags/WorkspaceTagsPage.tsx
@@
-                if (hasDependentTags) {
-                    rightElement = canWriteTags ? (
-                        <ListItemRightCaretWithLabel labelText={translate('workspace.tags.tagCount', {count: Object.keys(policyTagList?.tags ?? {}).length})} />
-                    ) : (
-                        <Text>{translate('workspace.tags.tagCount', {count: Object.keys(policyTagList?.tags ?? {}).length})}</Text>
-                    );
-                } else {
-                    rightElement = (
-                        <Switch
-                            isOn={isSwitchEnabled}
-                            accessibilityLabel={translate('workspace.tags.requiresTag')}
-                            onToggle={(newValue) => {
-                                ...
-                                updateWorkspaceRequiresTag(newValue, policyTagList.orderWeight);
-                            }}
-                            disabled={isSwitchDisabled || !canWriteTags}
-                            disabledAction={withReadOnlyFallback()}
-                            showLockIcon={!canWriteTags || isMakingLastRequiredTagListOptional(policy, policyTags, [policyTagList])}
-                        />
-                    );
-                }
+                rightElement = (
+                    <Switch
+                        isOn={isSwitchEnabled}
+                        accessibilityLabel={translate('workspace.tags.requiresTag')}
+                        onToggle={(newValue) => {
+                            ...
+                            updateWorkspaceRequiresTag(newValue, policyTagList.orderWeight);
+                        }}
+                        disabled={isSwitchDisabled || !canWriteTags}
+                        disabledAction={withReadOnlyFallback()}
+                        showLockIcon={!canWriteTags || isMakingLastRequiredTagListOptional(policy, policyTags, [policyTagList])}
+                    />
+                );
@@
-                    alternateText: !hasDependentTags ? translate('workspace.tags.tagCount', {count: Object.keys(policyTagList?.tags ?? {}).length}) : '',
+                    alternateText: translate('workspace.tags.tagCount', {count: Object.keys(policyTagList?.tags ?? {}).length}),

Also update the list header for dependent multi-level tags to show Required instead of Count, since the count moves to the row subtitle.

-        if (hasDependentTags) {
-            return (
-                <CustomListHeader
-                    canSelectMultiple={false}
-                    leftHeaderText={translate('common.name')}
-                    rightHeaderText={translate('common.count')}
-                    shouldShowRightCaret
-                />
-            );
-        }

On WorkspaceViewTagsPage, remove only the dependent-tags wrapper so the existing ToggleSettingOptionRow renders for dependent multi-level tag lists too:

-                {!hasDependentTags && (
-                    <View style={[styles.pv4, styles.ph5]}>
+                <View style={[styles.pv4, styles.ph5]}>
                         <ToggleSettingOptionRow
                             ...
                             disabled={!canWriteTags || (!currentPolicyTag?.required && !Object.values(currentPolicyTag?.tags ?? {}).some((tag) => tag.enabled))}
                             disabledAction={withReadOnlyFallback()}
                             showLockIcon={!canWriteTags || !isMultiLevelTags || isMakingLastRequiredTagListOptional(policy, policyTags, [currentPolicyTag])}
                         />
-                    </View>
-                )}
+                </View>

To avoid regressions:

• Keep isMakingLastRequiredTagListOptional() so admins cannot make all tag lists optional when workspace settings require tags.
• Keep the disabled state when a tag list has no enabled tags.
• Keep read-only behavior through canWriteTags, disabledAction={withReadOnlyFallback()}, and lock icons.
• Preserve dependent tag navigation by leaving row selection unchanged.
• Preserve tag counts by moving them to alternateText instead of dropping them.
• QA both dependent and independent multi-level tags, plus read-only workspace access.

What alternative solutions did you explore? (Optional)

We could add the Required toggle only on the tag-list detail page, but that still leaves the main multi-level Tags page inconsistent with independent tags. We could also keep showing Count in the right column and add Required elsewhere, but that creates a different layout only for dependent tags. Reusing the existing multi-level Required switch path is smaller and matches the current action/validation model.

[dilshodmackbook-sketch]

Proposal

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

After uploading dependent tags via CSV, the Required toggle is missing from each tag list row on the workspace Tags page. It only appears for independent (single/flat) tags.

What is the root cause of that problem?

In WorkspaceTagsPage, when building the multi-level tag rows we explicitly branch on hasDependentTags and replace the Required Switch with a read-only tag-count element (ListItemRightCaretWithLabel / Text). So for dependent tags the row never renders the toggle:

App/src/pages/workspace/tags/WorkspaceTagsPage.tsx

Lines 255 to 284 in cbfad7a

	if (hasDependentTags) {
	rightElement = canWriteTags ? (
	<ListItemRightCaretWithLabel labelText={translate('workspace.tags.tagCount', {count: Object.keys(policyTagList?.tags ?? {}).length})} />
	) : (
	<Text>{translate('workspace.tags.tagCount', {count: Object.keys(policyTagList?.tags ?? {}).length})}</Text>
	);
	} else {
	rightElement = (
	<Switch
	isOn={isSwitchEnabled}
	accessibilityLabel={translate('workspace.tags.requiresTag')}
	onToggle={(newValue: boolean) => {
	if (isMakingLastRequiredTagListOptional(policy, policyTags, [policyTagList])) {
	showConfirmModal({
	title: translate('workspace.tags.cannotMakeAllTagsOptional.title'),
	prompt: translate('workspace.tags.cannotMakeAllTagsOptional.description'),
	confirmText: translate('common.buttonConfirm'),
	shouldShowCancelButton: false,
	});
	return;
	}
	updateWorkspaceRequiresTag(newValue, policyTagList.orderWeight);
	}}
	disabled={isSwitchDisabled || !canWriteTags}
	disabledAction={withReadOnlyFallback()}
	showLockIcon={!canWriteTags || isMakingLastRequiredTagListOptional(policy, policyTags, [policyTagList])}
	/>
	);
	}

The tag count is also moved into rightElement for dependent tags (instead of alternateText), reinforcing that the right side of the row shows the count rather than the toggle:

App/src/pages/workspace/tags/WorkspaceTagsPage.tsx

Line 293 in cbfad7a

alternateText: !hasDependentTags ? translate('workspace.tags.tagCount', {count: Object.keys(policyTagList?.tags ?? {}).length}) : '',

Each policyTagList still carries its own required flag and orderWeight, and setPolicyTagsRequired works per tag list regardless of dependency, so there is no functional reason to hide the toggle for dependent tags — it is simply gated out by the if (hasDependentTags) branch.

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

Render the Required Switch for dependent tag lists the same way we already do for independent multi-level tags by dropping the hasDependentTags branch and always assigning the Switch to rightElement:

rightElement = (
    <Switch
        isOn={isSwitchEnabled}
        accessibilityLabel={translate('workspace.tags.requiresTag')}
        onToggle={(newValue: boolean) => {
            if (isMakingLastRequiredTagListOptional(policy, policyTags, [policyTagList])) {
                showConfirmModal({
                    title: translate('workspace.tags.cannotMakeAllTagsOptional.title'),
                    prompt: translate('workspace.tags.cannotMakeAllTagsOptional.description'),
                    confirmText: translate('common.buttonConfirm'),
                    shouldShowCancelButton: false,
                });
                return;
            }
            updateWorkspaceRequiresTag(newValue, policyTagList.orderWeight);
        }}
        disabled={isSwitchDisabled || !canWriteTags}
        disabledAction={withReadOnlyFallback()}
        showLockIcon={!canWriteTags || isMakingLastRequiredTagListOptional(policy, policyTags, [policyTagList])}
    />
);

Since the count is no longer needed in rightElement, show it in alternateText for dependent tags too (remove the !hasDependentTags guard at L293):

alternateText: translate('workspace.tags.tagCount', {count: Object.keys(policyTagList?.tags ?? {}).length}),

Note: the existing isMakingLastRequiredTagListOptional guard keeps at least one required level when needed, so the same safeguard that protects independent multi-level tags now applies to dependent tags as well.

What specific scenarios should we cover in automated tests to prevent reintroducing this issue in the future?

Render WorkspaceTagsPage for a policy with dependent (CSV-uploaded) multi-level tags and assert that each tag list row renders the Required Switch (with the correct isOn/disabled state) and that toggling it calls setPolicyTagsRequired with the right orderWeight.

What alternative solutions did you explore? (Optional)

Keep the count in rightElement and additionally render the Switch beside it. This avoids touching alternateText, but it crowds the row and diverges from the independent multi-level tag layout, so reusing the existing else branch (count in alternateText, toggle in rightElement) is cleaner and consistent.

[melvin-bot]

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

[melvin-bot]

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

[github-actions]

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

[github-actions]

⚠️ @lorretheboy 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).