@elisra-devops/docgen-data-provider 1.101.0 → 1.103.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elisra-devops/docgen-data-provider",
-  "version": "1.101.0",
+  "version": "1.103.0",
   "description": "A document generator data provider, aimed to retrive data from azure devops",
   "repository": {
     "type": "git",

package/src/models/mewp-reporting.ts

@@ -28,6 +28,7 @@ export interface MewpL2RequirementWorkItem {
   requirementId: string;
   baseKey: string;
   title: string;
+  owner: string;
   subSystem: string;
   responsibility: string;
   linkedTestCaseIds: number[];
@@ -40,6 +41,7 @@ export interface MewpL2RequirementFamily {
   requirementId: string;
   baseKey: string;
   title: string;
+  owner: string;
   subSystem: string;
   responsibility: string;
   linkedTestCaseIds: number[];
@@ -84,7 +86,10 @@ export type MewpCoverageL3L4Cell = MewpL3L4Pair;
 
 export interface MewpCoverageRow {
   'L2 REQ ID': string;
+  'SR #': string;
   'L2 REQ Title': string;
+  'L2 REQ Full Title'?: string;
+  'L2 Owner': string;
   'L2 SubSystem': string;
   'L2 Run Status': MewpRunStatus;
   'Bug ID': number | '';

package/src/modules/ResultDataProvider.ts

@@ -56,10 +56,14 @@ export default class ResultDataProvider {
   private static readonly MEWP_INTERNAL_VALIDATION_DIAGNOSTICS_TAG =
     '[MEWP][InternalValidation][Diagnostics]';
   private static readonly MEWP_INTERNAL_VALIDATION_SUMMARY_TAG = '[MEWP][InternalValidation][Summary]';
+  private static readonly MEWP_INTERNAL_VALIDATION_ASSUMPTIONS_REF = 'Assumptions';
+  private static readonly MEWP_INTERNAL_VALIDATION_ASSUMPTIONS_HEADER_PATTERN = /assumptions/i;
 
   private static readonly MEWP_L2_COVERAGE_COLUMNS = [
     'L2 REQ ID',
+    'SR #',
     'L2 REQ Title',
+    'L2 Owner',
     'L2 SubSystem',
     'L2 Run Status',
     'Bug ID',
@@ -806,6 +810,7 @@ export default class ResultDataProvider {
       const rows: MewpInternalValidationRow[] = [];
       const stepsXmlByTestCase = this.buildTestCaseStepsXmlMap(testData);
       const testCaseTitleMap = this.buildMewpTestCaseTitleMap(testData);
+      const testCaseDescriptionMap = this.buildMewpTestCaseDescriptionMap(testData);
       const allTestCaseIds = new Set<number>();
       for (const suite of testData || []) {
         const testCasesItems = Array.isArray(suite?.testCasesItems) ? suite.testCasesItems : [];
@@ -861,7 +866,16 @@ export default class ResultDataProvider {
             : [];
         const executableSteps = parsedSteps.filter((step) => !step?.isSharedStepTitle);
         diagnostics.totalParsedSteps += executableSteps.length;
-        const mentionEntries = this.extractRequirementMentionsFromExpectedSteps(parsedSteps, true);
+        // Direction A/B mentions can come from two sources:
+        // 1) Expected Result in executable steps.
+        // 2) "Assumptions" section in the test-case description.
+        const stepMentionEntries = this.extractRequirementMentionsFromExpectedSteps(parsedSteps, true);
+        const descriptionText = testCaseDescriptionMap.get(testCaseId) || '';
+        const assumptionsMentionEntries = this.extractRequirementMentionsFromAssumptionsDescription(
+          descriptionText,
+          true
+        );
+        const mentionEntries = [...stepMentionEntries, ...assumptionsMentionEntries];
         diagnostics.totalStepsWithMentions += mentionEntries.length;
         const mentionedL2Only = new Set<string>();
         const mentionedCodeFirstStep = new Map<string, string>();
@@ -903,24 +917,6 @@ export default class ResultDataProvider {
           if (!mentionedCodesByBase.has(baseKey)) mentionedCodesByBase.set(baseKey, new Set<string>());
           mentionedCodesByBase.get(baseKey)!.add(code);
         }
-        if (traceCurrentTestCase) {
-          logger.debug(
-            this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG, {
-              event: 'test-case-start',
-              tc: testCaseId,
-              parsedSteps: executableSteps.length,
-              stepsWithMentions: mentionEntries.length,
-              mentionedCodes:
-                [...mentionedL2Only].sort((a, b) => this.compareMewpRequirementCodes(a, b)).join('; ') ||
-                '<none>',
-              linkedCodesInTestCase:
-                [...linkedFullCodes]
-                  .sort((a, b) => this.compareMewpRequirementCodes(a, b))
-                  .join('; ') || '<none>',
-            })
-          );
-        }
-
         // Direction A logic:
         // 1) Base mention ("SR0054") is parent-level and considered covered only when
         //    the whole family is covered across scoped test cases:
@@ -946,38 +942,12 @@ export default class ResultDataProvider {
 
             // Base mention ("SR0054") requires full family coverage across selected test cases.
             if (hasBaseMention) {
-              const missingRequiredFamilyMembers = requiredFamilyMembers.filter(
-                (memberCode) => !familyLinkedCodes.has(memberCode)
-              );
               const isWholeFamilyCovered = requiredFamilyMembers.every((memberCode) =>
                 familyLinkedCodes.has(memberCode)
               );
               if (!isWholeFamilyCovered) {
                 missingBaseWhenFamilyUncovered.add(baseKey);
               }
-              if (traceCurrentTestCase) {
-                logger.debug(
-                  this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG, {
-                    event: 'base-family-coverage',
-                    tc: testCaseId,
-                    base: baseKey,
-                    baseMention: true,
-                    requiredFamily:
-                      requiredFamilyMembers
-                        .sort((a, b) => this.compareMewpRequirementCodes(a, b))
-                        .join('; ') || '<none>',
-                    linkedAcrossScope:
-                      [...familyLinkedCodes]
-                        .sort((a, b) => this.compareMewpRequirementCodes(a, b))
-                        .join('; ') || '<none>',
-                    missingRequired:
-                      missingRequiredFamilyMembers
-                        .sort((a, b) => this.compareMewpRequirementCodes(a, b))
-                        .join('; ') || '<none>',
-                    covered: isWholeFamilyCovered,
-                  })
-                );
-              }
             }
 
             // Specific mention ("SR0054-1") validates as exact-match only across scoped test cases.
@@ -987,60 +957,20 @@ export default class ResultDataProvider {
             for (const code of missingSpecificMembers) {
               missingSpecificMentionedNoFamily.add(code);
             }
-            if (traceCurrentTestCase && mentionedSpecificMembers.length > 0) {
-              logger.debug(
-                this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG, {
-                  event: 'specific-members-check',
-                  tc: testCaseId,
-                  base: baseKey,
-                  specificMentioned:
-                    mentionedSpecificMembers
-                      .sort((a, b) => this.compareMewpRequirementCodes(a, b))
-                      .join('; ') || '<none>',
-                  specificMissing:
-                    missingSpecificMembers
-                      .sort((a, b) => this.compareMewpRequirementCodes(a, b))
-                      .join('; ') || '<none>',
-                })
-              );
-            }
             continue;
           }
 
           // Fallback path when family data is unavailable for this base key.
-          const fallbackMissingSpecific: string[] = [];
-          let fallbackMissingBase = false;
           for (const code of mentionedCodes) {
             const hasSpecificSuffix = /-\d+$/.test(code);
             if (hasSpecificSuffix) {
               if (!linkedFullCodesAcrossTestCases.has(code)) {
                 missingSpecificMentionedNoFamily.add(code);
-                fallbackMissingSpecific.push(code);
               }
             } else if (!linkedBaseKeysAcrossTestCases.has(baseKey)) {
               missingBaseWhenFamilyUncovered.add(baseKey);
-              fallbackMissingBase = true;
             }
           }
-          if (traceCurrentTestCase) {
-            logger.debug(
-              this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG, {
-                event: 'fallback-path',
-                tc: testCaseId,
-                base: baseKey,
-                fallbackUsed: true,
-                mentioned:
-                  mentionedCodesList
-                    .sort((a, b) => this.compareMewpRequirementCodes(a, b))
-                    .join('; ') || '<none>',
-                missingSpecific:
-                  fallbackMissingSpecific
-                    .sort((a, b) => this.compareMewpRequirementCodes(a, b))
-                    .join('; ') || '<none>',
-                missingBase: fallbackMissingBase,
-              })
-            );
-          }
         }
 
         // Direction B is family-based: if any member of a family is mentioned in Expected Result,
@@ -1086,17 +1016,6 @@ export default class ResultDataProvider {
           const stepRef = mentionedBaseFirstStep.get(baseKey) || 'Step ?';
           appendMentionedButNotLinked(baseKey, stepRef);
         }
-        if (traceCurrentTestCase) {
-          logger.debug(
-            this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG, {
-              event: 'direction-a-summary',
-              tc: testCaseId,
-              missingSpecific: sortedMissingSpecificMentionedNoFamily.join('; ') || '<none>',
-              missingBase: sortedMissingBaseWhenFamilyUncovered.join('; ') || '<none>',
-            })
-          );
-        }
-
         const sortedExtraLinked = [...new Set(extraLinked)]
           .map((code) => this.normalizeMewpRequirementCodeWithSuffix(code))
           .filter((code) => !!code)
@@ -1134,21 +1053,23 @@ export default class ResultDataProvider {
         const validationStatus: 'Pass' | 'Fail' =
           mentionedButNotLinked || linkedButNotMentioned ? 'Fail' : 'Pass';
         if (validationStatus === 'Fail') diagnostics.failingRows += 1;
-        logger.debug(
-          this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_DIAGNOSTICS_TAG, {
-            testCaseId,
-            parsedSteps: executableSteps.length,
-            stepsWithMentions: mentionEntries.length,
-            customerIdsFound: mentionedL2Only.size,
-            linkedRequirements: linkedFullCodes.size,
-            mentionedButNotLinked:
-              sortedMissingSpecificMentionedNoFamily.length +
-              sortedMissingBaseWhenFamilyUncovered.length,
-            linkedButNotMentioned: sortedExtraLinked.length,
-            status: validationStatus,
-            customerIdSample: [...mentionedL2Only].slice(0, 5).join(', '),
-          })
-        );
+        if (traceCurrentTestCase) {
+          logger.debug(
+            this.buildTaggedLogMessage(ResultDataProvider.MEWP_INTERNAL_VALIDATION_DIAGNOSTICS_TAG, {
+              testCaseId,
+              parsedSteps: executableSteps.length,
+              stepsWithMentions: mentionEntries.length,
+              customerIdsFound: mentionedL2Only.size,
+              linkedRequirements: linkedFullCodes.size,
+              mentionedButNotLinked:
+                sortedMissingSpecificMentionedNoFamily.length +
+                sortedMissingBaseWhenFamilyUncovered.length,
+              linkedButNotMentioned: sortedExtraLinked.length,
+              status: validationStatus,
+              customerIdSample: [...mentionedL2Only].slice(0, 5).join(', '),
+            })
+          );
+        }
 
         rows.push({
           'Test Case ID': testCaseId,
@@ -1297,7 +1218,7 @@ export default class ResultDataProvider {
   private createMewpCoverageRow(
     requirement: Pick<
       MewpL2RequirementFamily,
-      'workItemId' | 'requirementId' | 'title' | 'subSystem' | 'responsibility'
+      'workItemId' | 'requirementId' | 'title' | 'owner' | 'subSystem' | 'responsibility'
     >,
     runStatus: MewpRunStatus,
     bug: MewpCoverageBugCell,
@@ -1305,12 +1226,18 @@ export default class ResultDataProvider {
   ): MewpCoverageRow {
     const l2ReqIdNumeric = Number(requirement?.workItemId || 0);
     const l2ReqId = l2ReqIdNumeric > 0 ? String(l2ReqIdNumeric) : '';
+    const srNumber = this.normalizeMewpRequirementCodeWithSuffix(requirement?.requirementId || '');
     const l2ReqTitle = this.toMewpComparableText(requirement.title);
+    const reqName = this.deriveMewpRequirementDisplayName(srNumber, l2ReqTitle);
+    const l2Owner = this.toMewpComparableText(requirement.owner);
     const l2SubSystem = this.toMewpComparableText(requirement.subSystem);
 
     return {
       'L2 REQ ID': l2ReqId,
-      'L2 REQ Title': l2ReqTitle,
+      'SR #': srNumber,
+      'L2 REQ Title': reqName,
+      'L2 REQ Full Title': l2ReqTitle,
+      'L2 Owner': l2Owner,
       'L2 SubSystem': l2SubSystem,
       'L2 Run Status': runStatus,
       'Bug ID': Number.isFinite(Number(bug?.id)) && Number(bug?.id) > 0 ? Number(bug?.id) : '',
@@ -1323,6 +1250,20 @@ export default class ResultDataProvider {
     };
   }
 
+  private deriveMewpRequirementDisplayName(requirementCode: string, title: string): string {
+    const normalizedTitle = this.toMewpComparableText(title);
+    if (!normalizedTitle) return '';
+
+    const normalizedCode = this.normalizeMewpRequirementCodeWithSuffix(requirementCode || '');
+    if (!normalizedCode) return normalizedTitle;
+
+    const escapedCode = normalizedCode.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const codePrefixPattern = new RegExp(`^${escapedCode}(?:\\s*[:\\-–—]\\s*|\\s+)`, 'i');
+    const withoutCodePrefix = normalizedTitle.replace(codePrefixPattern, '').trim();
+    if (!withoutCodePrefix) return normalizedTitle;
+    return withoutCodePrefix;
+  }
+
   private createEmptyMewpCoverageBugCell(): MewpCoverageBugCell {
     return { id: '' as '', title: '', responsibility: '' };
   }
@@ -1643,14 +1584,17 @@ export default class ResultDataProvider {
   }
 
   private buildRequirementSapWbsByBaseKey(
-    requirements: Array<Pick<MewpL2RequirementWorkItem, 'baseKey' | 'responsibility'>>
+    requirements: Array<Pick<MewpL2RequirementWorkItem, 'baseKey' | 'owner' | 'responsibility'>>
   ): Map<string, string> {
     const out = new Map<string, string>();
     for (const requirement of requirements || []) {
       const baseKey = String(requirement?.baseKey || '').trim();
       if (!baseKey) continue;
 
-      const normalized = this.resolveMewpResponsibility(this.toMewpComparableText(requirement?.responsibility));
+      const rawOwner = this.toMewpComparableText(requirement?.owner);
+      const normalized =
+        this.resolveMewpResponsibility(rawOwner) ||
+        this.resolveMewpResponsibility(this.toMewpComparableText(requirement?.responsibility));
       if (!normalized) continue;
 
       const existing = out.get(baseKey) || '';
@@ -1752,6 +1696,54 @@ export default class ResultDataProvider {
     return map;
   }
 
+  /**
+   * Builds a lookup of test case id -> test case description using suite payload data.
+   *
+   * Resolution order:
+   * 1) direct description fields on test-case payload (`testCase.description` / `workItem.description`)
+   * 2) `System.Description` / `Description` in work-item fields map
+   * 3) `System.Description` / `Description` from work-item field list (`workItemFields`)
+   */
+  private buildMewpTestCaseDescriptionMap(testData: any[]): Map<number, string> {
+    const map = new Map<number, string>();
+
+    const readDescriptionFromFields = (fields: Record<string, any>): string => {
+      const value =
+        this.getFieldValueByName(fields, 'System.Description') ??
+        this.getFieldValueByName(fields, 'Description');
+      return this.toMewpComparableText(value);
+    };
+
+    for (const suite of testData || []) {
+      const testCasesItems = Array.isArray(suite?.testCasesItems) ? suite.testCasesItems : [];
+      for (const testCase of testCasesItems) {
+        const id = Number(testCase?.workItem?.id || testCase?.testCaseId || testCase?.id);
+        if (!Number.isFinite(id) || id <= 0 || map.has(id)) continue;
+
+        const fromDirect = this.toMewpComparableText(testCase?.description || testCase?.workItem?.description);
+        if (fromDirect) {
+          map.set(id, fromDirect);
+          continue;
+        }
+
+        const fieldsFromMap = testCase?.workItem?.fields || {};
+        const fromFieldsMap = readDescriptionFromFields(fieldsFromMap);
+        if (fromFieldsMap) {
+          map.set(id, fromFieldsMap);
+          continue;
+        }
+
+        const fieldsFromList = this.extractWorkItemFieldsMap(testCase?.workItem?.workItemFields);
+        const fromFieldsList = readDescriptionFromFields(fieldsFromList);
+        if (fromFieldsList) {
+          map.set(id, fromFieldsList);
+        }
+      }
+    }
+
+    return map;
+  }
+
   private extractMewpTestCaseId(runResult: any): number {
     const testCaseId = Number(runResult?.testCaseId || runResult?.testCase?.id || 0);
     return Number.isFinite(testCaseId) ? testCaseId : 0;
@@ -1956,6 +1948,107 @@ export default class ResultDataProvider {
     return out;
   }
 
+  /**
+   * Extracts SR requirement mentions from the "assumptions" section inside a test-case description.
+   *
+   * Notes:
+   * - Heading detection is case-insensitive and keyed by "assumptions".
+   * - Parsing is scoped to that section only and stops when a likely next section heading is reached
+   *   after at least one requirement-bearing line was collected.
+   * - Returned stepRef is a synthetic marker ("Assumptions") so downstream discrepancy output can
+   *   clearly attribute source to description-level assumptions.
+   */
+  private extractRequirementMentionsFromAssumptionsDescription(
+    description: string,
+    includeSuffix: boolean
+  ): Array<{ stepRef: string; codes: Set<string> }> {
+    const lines = this.normalizeMewpDescriptionLines(description);
+    if (lines.length === 0) return [];
+
+    const assumptionsHeaderIndex = lines.findIndex((line) =>
+      ResultDataProvider.MEWP_INTERNAL_VALIDATION_ASSUMPTIONS_HEADER_PATTERN.test(line)
+    );
+    if (assumptionsHeaderIndex < 0) return [];
+
+    const assumptionCodes = new Set<string>();
+    let hasCollectedRequirementCodes = false;
+    for (let index = assumptionsHeaderIndex + 1; index < lines.length; index += 1) {
+      const rawLine = String(lines[index] || '').trim();
+      if (!rawLine) continue;
+
+      const line = rawLine.replace(/^[-*•]+\s*/, '').trim();
+      if (!line) continue;
+
+      const lineCodes = this.extractRequirementCodesFromExpectedText(line, includeSuffix);
+      if (lineCodes.size > 0) {
+        for (const code of lineCodes) assumptionCodes.add(code);
+        hasCollectedRequirementCodes = true;
+        continue;
+      }
+
+      if (hasCollectedRequirementCodes && this.isLikelyMewpDescriptionSectionHeading(line)) {
+        break;
+      }
+    }
+
+    if (assumptionCodes.size === 0) return [];
+    return [{ stepRef: ResultDataProvider.MEWP_INTERNAL_VALIDATION_ASSUMPTIONS_REF, codes: assumptionCodes }];
+  }
+
+  /**
+   * Normalizes raw HTML/plain description content into comparable text lines.
+   * This makes section/title heuristics resilient to formatting differences.
+   */
+  private normalizeMewpDescriptionLines(description: string): string[] {
+    const raw = String(description || '');
+    if (!raw) return [];
+
+    const normalized = raw
+      .replace(/\r\n?/g, '\n')
+      .replace(/<\s*br\s*\/?>/gi, '\n')
+      // Underlined sections are commonly used as inline HTML titles in MEWP test-case descriptions.
+      // Treat underline tags as boundaries so compact forms like <u><b>Title</b></u><p>... preserve section split.
+      .replace(/<\s*u\b[^>]*>/gi, '\n')
+      .replace(/<\/\s*u\s*>/gi, '\n')
+      .replace(/<\s*li\b[^>]*>/gi, '\n- ')
+      .replace(/<\/\s*(p|div|li|ul|ol|tr|td|h[1-6])\s*>/gi, '\n')
+      .replace(/&nbsp;|&#160;|&#xA0;/gi, ' ')
+      .replace(/&lt;/gi, '<')
+      .replace(/&gt;/gi, '>')
+      .replace(/&amp;/gi, '&')
+      .replace(/&quot;/gi, '"')
+      .replace(/&#39;|&apos;/gi, "'")
+      .replace(/<[^>]*>/g, ' ')
+      .replace(/[\u200B-\u200D\uFEFF]/g, '')
+      .replace(/[ \t]+/g, ' ');
+
+    return normalized
+      .split('\n')
+      .map((line) => String(line || '').trim())
+      .filter((line) => !!line);
+  }
+
+  /**
+   * Heuristic detector for description section headings used to stop assumptions parsing.
+   * A line is considered a heading when it is short/title-like and does not itself contain SR codes.
+   */
+  private isLikelyMewpDescriptionSectionHeading(line: string): boolean {
+    const normalized = String(line || '')
+      .replace(/^[-*•]+\s*/, '')
+      .trim();
+    if (!normalized) return false;
+    if (ResultDataProvider.MEWP_INTERNAL_VALIDATION_ASSUMPTIONS_HEADER_PATTERN.test(normalized))
+      return false;
+    if (this.extractRequirementCodesFromExpectedText(normalized, true).size > 0) return false;
+
+    const compact = normalized.replace(/[.:;,\-–—]+$/, '').trim();
+    if (!compact) return false;
+    const wordCount = compact.split(/\s+/).filter((item) => !!item).length;
+    if (wordCount === 0 || wordCount > 12) return false;
+    if (/[.;!?]/.test(compact)) return false;
+    return /^[a-z0-9\s()&/+_'-]+$/i.test(compact);
+  }
+
   private extractRequirementCodesFromExpectedText(text: string, includeSuffix: boolean): Set<string> {
     const out = new Set<string>();
     const source = this.normalizeRequirementStepText(text);
@@ -2138,6 +2231,7 @@ export default class ResultDataProvider {
         requirementId,
         baseKey: this.toRequirementKey(requirementId),
         title: this.toMewpComparableText(fields?.['System.Title'] || wi?.title),
+        owner: this.deriveMewpRequirementOwner(fields),
         subSystem: this.deriveMewpSubSystem(fields),
         responsibility: this.deriveMewpResponsibility(fields),
         linkedTestCaseIds: this.extractLinkedTestCaseIdsFromRequirement(wi?.relations || []),
@@ -2187,6 +2281,7 @@ export default class ResultDataProvider {
       if (areaPath.includes('\\customer requirements\\level 2')) score += 3;
       if (!areaPath.includes('\\mop')) score += 2;
       if (String(item?.title || '').trim()) score += 1;
+      if (String(item?.owner || '').trim()) score += 1;
       if (String(item?.subSystem || '').trim()) score += 1;
       if (String(item?.responsibility || '').trim()) score += 1;
       return score;
@@ -2223,6 +2318,7 @@ export default class ResultDataProvider {
         requirementId: String(family?.representative?.requirementId || baseKey),
         baseKey,
         title: String(family?.representative?.title || ''),
+        owner: String(family?.representative?.owner || ''),
         subSystem: String(family?.representative?.subSystem || ''),
         responsibility: String(family?.representative?.responsibility || ''),
         linkedTestCaseIds: [...family.linkedTestCaseIds].sort((a, b) => a - b),
@@ -2674,6 +2770,24 @@ export default class ResultDataProvider {
     return '';
   }
 
+  // L2 owner is sourced only from requirement SAPWBS fields.
+  private deriveMewpRequirementOwner(fields: Record<string, any>): string {
+    const directCandidates = [fields?.['Custom.SAPWBS'], fields?.['SAPWBS']];
+    for (const candidate of directCandidates) {
+      const normalized = this.toMewpComparableText(candidate);
+      if (normalized) return normalized;
+    }
+
+    for (const [key, value] of Object.entries(fields || {})) {
+      const normalizedKey = String(key || '').toLowerCase();
+      if (!normalizedKey.includes('sapwbs')) continue;
+      const normalizedValue = this.toMewpComparableText(value);
+      if (normalizedValue) return normalizedValue;
+    }
+
+    return '';
+  }
+
   // Test-case responsibility must come from test-case path context (not SAPWBS).
   private deriveMewpTestCaseResponsibility(fields: Record<string, any>): string {
     const areaPathCandidates = [