Fix: Multi-level tags show "Required" on all levels when only some are required

src/libs/TagsOptionsListUtils.ts

@@ -243,7 +243,12 @@ function getTagVisibility({
     const policyTagLists = getTagLists(policyTags);
 
     return policyTagLists.map(({tags, required}, index) => {
-        const isTagRequired = required || !!policy?.requiresTag;
+        // For independent multi-level tags each level has its own `required` flag, so mirror the per-level tag
+        // validation (see getTagViolationForIndependentTags) instead of OR-ing in the workspace-wide `requiresTag`,
+        // which would incorrectly label every level as "Required". Dependent multi-level tags are excluded: their
+        // validation (getTagViolationsForDependentTags) blocks submission on every level once `requiresTag` is on,
+        // regardless of each level's own `required` flag, so they must keep OR-ing the workspace-wide `requiresTag`.
+        const isTagRequired = isMultilevelTags && !hasDependentTags ? (required ?? true) : required || !!policy?.requiresTag;
         let shouldShow = false;
 
         if (shouldShowTags) {

tests/unit/TagsOptionsListUtilsTest.ts

@@ -916,6 +916,82 @@ describe('TagsOptionsListUtils', () => {
 
             expect(result).toEqual([{isTagRequired: true, shouldShow: true}]);
         });
+
+        it('should only mark the per-level required tags for independent multi-level tags even when policy.requiresTag is true', () => {
+            const policyWithRequiresTag = {...mockPolicy, requiresTag: true};
+            const multiLevelTags: PolicyTagLists = {
+                tagList1: {
+                    name: 'Level A',
+                    required: true,
+                    tags: {tagA: {name: 'A', enabled: true}},
+                    orderWeight: 0,
+                },
+                tagList2: {
+                    name: 'Level B',
+                    required: false,
+                    tags: {tagB: {name: 'B', enabled: true}},
+                    orderWeight: 1,
+                },
+                tagList3: {
+                    name: 'Level C',
+                    required: false,
+                    tags: {tagC: {name: 'C', enabled: true}},
+                    orderWeight: 2,
+                },
+            };
+
+            const result = getTagVisibility({
+                shouldShowTags: true,
+                policy: policyWithRequiresTag,
+                policyTags: multiLevelTags,
+                transaction: mockTransaction,
+            });
+
+            expect(result).toEqual([
+                {isTagRequired: true, shouldShow: true},
+                {isTagRequired: false, shouldShow: true},
+                {isTagRequired: false, shouldShow: true},
+            ]);
+        });
+
+        it('should keep marking every level required for dependent multi-level tags when policy.requiresTag is true even if a level required is false', () => {
+            const policyWithRequiresTag = {...mockPolicy, requiresTag: true, hasMultipleTagLists: true};
+            const dependentMultiLevelTags: PolicyTagLists = {
+                tagList1: {
+                    name: 'Level A',
+                    required: false,
+                    tags: {tagA: {name: 'A', enabled: true, rules: {parentTagsFilter: ''}}},
+                    orderWeight: 0,
+                },
+                tagList2: {
+                    name: 'Level B',
+                    required: false,
+                    tags: {tagB: {name: 'B', enabled: true, rules: {parentTagsFilter: 'A'}}},
+                    orderWeight: 1,
+                },
+                tagList3: {
+                    name: 'Level C',
+                    required: false,
+                    tags: {tagC: {name: 'C', enabled: true, rules: {parentTagsFilter: 'A:B'}}},
+                    orderWeight: 2,
+                },
+            };
+
+            const result = getTagVisibility({
+                shouldShowTags: true,
+                policy: policyWithRequiresTag,
+                policyTags: dependentMultiLevelTags,
+                transaction: {...mockTransaction, tag: 'A:B:C'},
+            });
+
+            // Dependent tags block submission on every level once requiresTag is on, so the badge must
+            // stay "Required" on every level regardless of each level's own `required` flag.
+            expect(result).toEqual([
+                {isTagRequired: true, shouldShow: true},
+                {isTagRequired: true, shouldShow: true},
+                {isTagRequired: true, shouldShow: true},
+            ]);
+        });
     });
 
     describe('getEnabledTags', () => {