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

package/bin/models/mewp-reporting.d.ts

@@ -24,6 +24,7 @@ export interface MewpL2RequirementWorkItem {
     requirementId: string;
     baseKey: string;
     title: string;
+    owner: string;
     subSystem: string;
     responsibility: string;
     linkedTestCaseIds: number[];
@@ -35,6 +36,7 @@ export interface MewpL2RequirementFamily {
     requirementId: string;
     baseKey: string;
     title: string;
+    owner: string;
     subSystem: string;
     responsibility: string;
     linkedTestCaseIds: number[];
@@ -71,7 +73,10 @@ export interface MewpCoverageBugCell {
 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/bin/modules/ResultDataProvider.d.ts

@@ -26,6 +26,8 @@ export default class ResultDataProvider {
     private static readonly MEWP_INTERNAL_VALIDATION_TRACE_TAG;
     private static readonly MEWP_INTERNAL_VALIDATION_DIAGNOSTICS_TAG;
     private static readonly MEWP_INTERNAL_VALIDATION_SUMMARY_TAG;
+    private static readonly MEWP_INTERNAL_VALIDATION_ASSUMPTIONS_REF;
+    private static readonly MEWP_INTERNAL_VALIDATION_ASSUMPTIONS_HEADER_PATTERN;
     private static readonly MEWP_L2_COVERAGE_COLUMNS;
     private static readonly INTERNAL_VALIDATION_COLUMNS;
     orgUrl: string;
@@ -90,6 +92,7 @@ export default class ResultDataProvider {
     private formatLogValue;
     private buildTaggedLogMessage;
     private createMewpCoverageRow;
+    private deriveMewpRequirementDisplayName;
     private createEmptyMewpCoverageBugCell;
     private createEmptyMewpCoverageL3L4Cell;
     private buildMewpCoverageL3L4Rows;
@@ -104,6 +107,15 @@ export default class ResultDataProvider {
     private isExternalStateInScope;
     private invertBaseRequirementLinks;
     private buildMewpTestCaseTitleMap;
+    /**
+     * 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;
     private extractMewpTestCaseId;
     private buildTestCaseStepsXmlMap;
     private extractStepsXmlFromTestCaseItem;
@@ -115,6 +127,27 @@ export default class ResultDataProvider {
     private resolveRequirementStatusForWindow;
     private extractRequirementCodesFromText;
     private extractRequirementMentionsFromExpectedSteps;
+    /**
+     * 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;
+    /**
+     * Normalizes raw HTML/plain description content into comparable text lines.
+     * This makes section/title heuristics resilient to formatting differences.
+     */
+    private normalizeMewpDescriptionLines;
+    /**
+     * 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;
     private extractRequirementCodesFromExpectedText;
     private extractRequirementCandidatesFromToken;
     private expandRequirementTokenByComma;
@@ -138,6 +171,7 @@ export default class ResultDataProvider {
     private extractLinkedWorkItemIdsFromRelations;
     private extractMewpRequirementIdentifier;
     private deriveMewpResponsibility;
+    private deriveMewpRequirementOwner;
     private deriveMewpTestCaseResponsibility;
     private deriveMewpSubSystem;
     private resolveBugResponsibility;

package/bin/modules/ResultDataProvider.js

@@ -517,6 +517,7 @@ class ResultDataProvider {
             const rows = [];
             const stepsXmlByTestCase = this.buildTestCaseStepsXmlMap(testData);
             const testCaseTitleMap = this.buildMewpTestCaseTitleMap(testData);
+            const testCaseDescriptionMap = this.buildMewpTestCaseDescriptionMap(testData);
             const allTestCaseIds = new Set();
             for (const suite of testData || []) {
                 const testCasesItems = Array.isArray(suite === null || suite === void 0 ? void 0 : suite.testCasesItems) ? suite.testCasesItems : [];
@@ -562,7 +563,13 @@ class ResultDataProvider {
                     : [];
                 const executableSteps = parsedSteps.filter((step) => !(step === null || step === void 0 ? void 0 : 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();
                 const mentionedCodeFirstStep = new Map();
@@ -601,19 +608,6 @@ class ResultDataProvider {
                         mentionedCodesByBase.set(baseKey, new Set());
                     mentionedCodesByBase.get(baseKey).add(code);
                 }
-                if (traceCurrentTestCase) {
-                    logger_1.default.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:
@@ -636,81 +630,30 @@ class ResultDataProvider {
                         const requiredFamilyMembers = specificFamilyMembers.length > 0 ? specificFamilyMembers : normalizedFamilyMembers;
                         // 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_1.default.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.
                         const missingSpecificMembers = mentionedSpecificMembers.filter((code) => !familyLinkedCodes.has(code));
                         for (const code of missingSpecificMembers) {
                             missingSpecificMentionedNoFamily.add(code);
                         }
-                        if (traceCurrentTestCase && mentionedSpecificMembers.length > 0) {
-                            logger_1.default.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 = [];
-                    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_1.default.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,
                 // linked members of that same family are not considered "linked but not mentioned".
@@ -750,14 +693,6 @@ class ResultDataProvider {
                     const stepRef = mentionedBaseFirstStep.get(baseKey) || 'Step ?';
                     appendMentionedButNotLinked(baseKey, stepRef);
                 }
-                if (traceCurrentTestCase) {
-                    logger_1.default.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)
@@ -792,18 +727,20 @@ class ResultDataProvider {
                 const validationStatus = mentionedButNotLinked || linkedButNotMentioned ? 'Fail' : 'Pass';
                 if (validationStatus === 'Fail')
                     diagnostics.failingRows += 1;
-                logger_1.default.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_1.default.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,
                     'Test Case Title': String(testCaseTitleMap.get(testCaseId) || '').trim(),
@@ -921,11 +858,17 @@ class ResultDataProvider {
     createMewpCoverageRow(requirement, runStatus, bug, linkedL3L4) {
         const l2ReqIdNumeric = Number((requirement === null || requirement === void 0 ? void 0 : requirement.workItemId) || 0);
         const l2ReqId = l2ReqIdNumeric > 0 ? String(l2ReqIdNumeric) : '';
+        const srNumber = this.normalizeMewpRequirementCodeWithSuffix((requirement === null || requirement === void 0 ? void 0 : 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 === null || bug === void 0 ? void 0 : bug.id)) && Number(bug === null || bug === void 0 ? void 0 : bug.id) > 0 ? Number(bug === null || bug === void 0 ? void 0 : bug.id) : '',
@@ -937,6 +880,20 @@ class ResultDataProvider {
             'L4 REQ Title': String((linkedL3L4 === null || linkedL3L4 === void 0 ? void 0 : linkedL3L4.l4Title) || '').trim(),
         };
     }
+    deriveMewpRequirementDisplayName(requirementCode, title) {
+        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;
+    }
     createEmptyMewpCoverageBugCell() {
         return { id: '', title: '', responsibility: '' };
     }
@@ -1192,7 +1149,9 @@ class ResultDataProvider {
             const baseKey = String((requirement === null || requirement === void 0 ? void 0 : requirement.baseKey) || '').trim();
             if (!baseKey)
                 continue;
-            const normalized = this.resolveMewpResponsibility(this.toMewpComparableText(requirement === null || requirement === void 0 ? void 0 : requirement.responsibility));
+            const rawOwner = this.toMewpComparableText(requirement === null || requirement === void 0 ? void 0 : requirement.owner);
+            const normalized = this.resolveMewpResponsibility(rawOwner) ||
+                this.resolveMewpResponsibility(this.toMewpComparableText(requirement === null || requirement === void 0 ? void 0 : requirement.responsibility));
             if (!normalized)
                 continue;
             const existing = out.get(baseKey) || '';
@@ -1289,6 +1248,48 @@ 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`)
+     */
+    buildMewpTestCaseDescriptionMap(testData) {
+        var _a, _b, _c, _d;
+        const map = new Map();
+        const readDescriptionFromFields = (fields) => {
+            var _a;
+            const value = (_a = this.getFieldValueByName(fields, 'System.Description')) !== null && _a !== void 0 ? _a : this.getFieldValueByName(fields, 'Description');
+            return this.toMewpComparableText(value);
+        };
+        for (const suite of testData || []) {
+            const testCasesItems = Array.isArray(suite === null || suite === void 0 ? void 0 : suite.testCasesItems) ? suite.testCasesItems : [];
+            for (const testCase of testCasesItems) {
+                const id = Number(((_a = testCase === null || testCase === void 0 ? void 0 : testCase.workItem) === null || _a === void 0 ? void 0 : _a.id) || (testCase === null || testCase === void 0 ? void 0 : testCase.testCaseId) || (testCase === null || testCase === void 0 ? void 0 : testCase.id));
+                if (!Number.isFinite(id) || id <= 0 || map.has(id))
+                    continue;
+                const fromDirect = this.toMewpComparableText((testCase === null || testCase === void 0 ? void 0 : testCase.description) || ((_b = testCase === null || testCase === void 0 ? void 0 : testCase.workItem) === null || _b === void 0 ? void 0 : _b.description));
+                if (fromDirect) {
+                    map.set(id, fromDirect);
+                    continue;
+                }
+                const fieldsFromMap = ((_c = testCase === null || testCase === void 0 ? void 0 : testCase.workItem) === null || _c === void 0 ? void 0 : _c.fields) || {};
+                const fromFieldsMap = readDescriptionFromFields(fieldsFromMap);
+                if (fromFieldsMap) {
+                    map.set(id, fromFieldsMap);
+                    continue;
+                }
+                const fieldsFromList = this.extractWorkItemFieldsMap((_d = testCase === null || testCase === void 0 ? void 0 : testCase.workItem) === null || _d === void 0 ? void 0 : _d.workItemFields);
+                const fromFieldsList = readDescriptionFromFields(fieldsFromList);
+                if (fromFieldsList) {
+                    map.set(id, fromFieldsList);
+                }
+            }
+        }
+        return map;
+    }
     extractMewpTestCaseId(runResult) {
         var _a;
         const testCaseId = Number((runResult === null || runResult === void 0 ? void 0 : runResult.testCaseId) || ((_a = runResult === null || runResult === void 0 ? void 0 : runResult.testCase) === null || _a === void 0 ? void 0 : _a.id) || 0);
@@ -1479,6 +1480,102 @@ 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.
+     */
+    extractRequirementMentionsFromAssumptionsDescription(description, includeSuffix) {
+        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();
+        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.
+     */
+    normalizeMewpDescriptionLines(description) {
+        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.
+     */
+    isLikelyMewpDescriptionSectionHeading(line) {
+        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);
+    }
     extractRequirementCodesFromExpectedText(text, includeSuffix) {
         const out = new Set();
         const source = this.normalizeRequirementStepText(text);
@@ -1648,6 +1745,7 @@ class ResultDataProvider {
                 requirementId,
                 baseKey: this.toRequirementKey(requirementId),
                 title: this.toMewpComparableText((fields === null || fields === void 0 ? void 0 : fields['System.Title']) || (wi === null || wi === void 0 ? void 0 : wi.title)),
+                owner: this.deriveMewpRequirementOwner(fields),
                 subSystem: this.deriveMewpSubSystem(fields),
                 responsibility: this.deriveMewpResponsibility(fields),
                 linkedTestCaseIds: this.extractLinkedTestCaseIdsFromRequirement((wi === null || wi === void 0 ? void 0 : wi.relations) || []),
@@ -1690,6 +1788,8 @@ class ResultDataProvider {
                 score += 2;
             if (String((item === null || item === void 0 ? void 0 : item.title) || '').trim())
                 score += 1;
+            if (String((item === null || item === void 0 ? void 0 : item.owner) || '').trim())
+                score += 1;
             if (String((item === null || item === void 0 ? void 0 : item.subSystem) || '').trim())
                 score += 1;
             if (String((item === null || item === void 0 ? void 0 : item.responsibility) || '').trim())
@@ -1723,14 +1823,15 @@ class ResultDataProvider {
         }
         return [...families.entries()]
             .map(([baseKey, family]) => {
-            var _a, _b, _c, _d, _e;
+            var _a, _b, _c, _d, _e, _f;
             return ({
                 workItemId: Number(((_a = family === null || family === void 0 ? void 0 : family.representative) === null || _a === void 0 ? void 0 : _a.workItemId) || 0),
                 requirementId: String(((_b = family === null || family === void 0 ? void 0 : family.representative) === null || _b === void 0 ? void 0 : _b.requirementId) || baseKey),
                 baseKey,
                 title: String(((_c = family === null || family === void 0 ? void 0 : family.representative) === null || _c === void 0 ? void 0 : _c.title) || ''),
-                subSystem: String(((_d = family === null || family === void 0 ? void 0 : family.representative) === null || _d === void 0 ? void 0 : _d.subSystem) || ''),
-                responsibility: String(((_e = family === null || family === void 0 ? void 0 : family.representative) === null || _e === void 0 ? void 0 : _e.responsibility) || ''),
+                owner: String(((_d = family === null || family === void 0 ? void 0 : family.representative) === null || _d === void 0 ? void 0 : _d.owner) || ''),
+                subSystem: String(((_e = family === null || family === void 0 ? void 0 : family.representative) === null || _e === void 0 ? void 0 : _e.subSystem) || ''),
+                responsibility: String(((_f = family === null || family === void 0 ? void 0 : family.representative) === null || _f === void 0 ? void 0 : _f.responsibility) || ''),
                 linkedTestCaseIds: [...family.linkedTestCaseIds].sort((a, b) => a - b),
             });
         })
@@ -2159,6 +2260,24 @@ class ResultDataProvider {
         }
         return '';
     }
+    // L2 owner is sourced only from requirement SAPWBS fields.
+    deriveMewpRequirementOwner(fields) {
+        const directCandidates = [fields === null || fields === void 0 ? void 0 : fields['Custom.SAPWBS'], fields === null || fields === void 0 ? void 0 : 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).
     deriveMewpTestCaseResponsibility(fields) {
         const areaPathCandidates = [
@@ -4511,9 +4630,13 @@ class ResultDataProvider {
 ResultDataProvider.MEWP_INTERNAL_VALIDATION_TRACE_TAG = '[MEWP][InternalValidation][Trace]';
 ResultDataProvider.MEWP_INTERNAL_VALIDATION_DIAGNOSTICS_TAG = '[MEWP][InternalValidation][Diagnostics]';
 ResultDataProvider.MEWP_INTERNAL_VALIDATION_SUMMARY_TAG = '[MEWP][InternalValidation][Summary]';
+ResultDataProvider.MEWP_INTERNAL_VALIDATION_ASSUMPTIONS_REF = 'Assumptions';
+ResultDataProvider.MEWP_INTERNAL_VALIDATION_ASSUMPTIONS_HEADER_PATTERN = /assumptions/i;
 ResultDataProvider.MEWP_L2_COVERAGE_COLUMNS = [
     'L2 REQ ID',
+    'SR #',
     'L2 REQ Title',
+    'L2 Owner',
     'L2 SubSystem',
     'L2 Run Status',
     'Bug ID',