@resolveio/server-lib 22.3.210 → 22.3.211

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resolveio/server-lib",
-  "version": "22.3.210",
+  "version": "22.3.211",
   "description": "",
   "scripts": {
     "package": "./build_package.sh",

package/util/support-runner-v5.js

@@ -129,6 +129,11 @@ function cleanListEntryText(value, max) {
     if (max === void 0) { max = 500; }
     if (value && typeof value === 'object' && !Array.isArray(value)) {
         var source = value;
+        var hypothesis = cleanListEntryText(source.hypothesis, Math.floor(max / 2));
+        var whyRejected = cleanListEntryText(source.why_rejected || source.whyRejected || source.reason_rejected || source.reasonRejected, Math.floor(max / 2));
+        if (hypothesis && whyRejected) {
+            return "".concat(hypothesis, " rejected because ").concat(whyRejected).slice(0, max);
+        }
         try {
             for (var _b = __values([
                 'path',
@@ -924,7 +929,12 @@ function normalizeIssueClass(value) {
         route_auth_hydration: 'route_auth_hydration',
         slow_query: 'slow_query_performance',
         performance: 'slow_query_performance',
-        slow_query_performance: 'slow_query_performance'
+        slow_query_performance: 'slow_query_performance',
+        feature: 'missing_wrong_data',
+        feature_request: 'missing_wrong_data',
+        request_new_feature: 'missing_wrong_data',
+        requested_behavior_change: 'missing_wrong_data',
+        new_feature: 'missing_wrong_data'
     };
     return aliases[normalized] || '';
 }
@@ -962,12 +972,40 @@ function normalizeSupportDiagnosisEvidence(values) {
         .filter(function (entry) { return entry && typeof entry === 'object' && !Array.isArray(entry); })
         .map(function (entry) {
         var type = cleanText(entry.type, 80).toLowerCase();
-        var normalizedType = (allowed.has(type) ? type : 'other');
-        var summary = cleanText(entry.summary || entry.message || entry.evidence || entry.reason, 1200);
         var artifactPath = cleanText(entry.artifactPath || entry.artifact_path || entry.path || entry.file, 500);
+        var inferredType = (function () {
+            if (allowed.has(type)) {
+                return type;
+            }
+            if (/\b(ticket|manual-ticket|support-context|email\.metadata)\b/i.test(artifactPath)) {
+                return 'ticket';
+            }
+            if (/\b(commit|git)\b/i.test(artifactPath)) {
+                return 'commit';
+            }
+            if (/\b(mongo|query|database|collection)\b/i.test(artifactPath)) {
+                return 'mongo';
+            }
+            if (/\b(log|trace)\b/i.test(artifactPath)) {
+                return 'log';
+            }
+            if (/\b(angular|server|client|src|methods|publications|routing|permission|component)\b/i.test(artifactPath)) {
+                return 'code';
+            }
+            return 'other';
+        })();
+        var normalizedType = inferredType;
+        var summary = cleanText(entry.summary || entry.message || entry.evidence || entry.reason || entry.fact || entry.description, 1200)
+            || (artifactPath ? "Evidence from ".concat(artifactPath) : '');
         var ownerFiles = cleanList(entry.ownerFiles || entry.owner_files || entry.files, 12, 500)
             .map(normalizeOwnerFilePath)
             .filter(Boolean);
+        if (normalizedType === 'code' && artifactPath) {
+            var sourcePath = normalizeOwnerFilePath(artifactPath);
+            if (sourcePath && !ownerFiles.includes(sourcePath)) {
+                ownerFiles.push(sourcePath);
+            }
+        }
         var evidenceRefs = cleanList(entry.evidenceRefs || entry.evidence_refs || entry.refs, 12, 500);
         return {
             id: cleanText(entry.id || entry.evidenceId || entry.evidence_id, 160)
@@ -1438,19 +1476,162 @@ function normalizeSupportDiagnosisBusinessProofContract(value, issueClassHint) {
         data_or_dom_assertion: pickText(source, ['data_or_dom_assertion', 'dataOrDomAssertion', 'data_assertion', 'dataAssertion', 'dom_assertion', 'domAssertion', 'assertion'], 1000)
     };
 }
+function supportDiagnosisNarrativeText(value, max) {
+    if (max === void 0) { max = 1200; }
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return cleanText(value, max);
+    }
+    if (Array.isArray(value)) {
+        return cleanList(value, 12, Math.max(80, Math.floor(max / 2))).join(' ').slice(0, max);
+    }
+    var source = cleanObject(value);
+    if (!Object.keys(source).length) {
+        return '';
+    }
+    var direct = pickText(source, [
+        'summary',
+        'description',
+        'statement',
+        'issue_case',
+        'issueCase',
+        'customer_complaint',
+        'customerComplaint',
+        'expected_result',
+        'expectedResult',
+        'observed_result',
+        'observedResult',
+        'path',
+        'reason',
+        'fact'
+    ], max);
+    if (direct) {
+        return direct;
+    }
+    var hypothesis = cleanText(source.hypothesis, Math.floor(max / 2));
+    var whyRejected = cleanText(source.why_rejected || source.whyRejected || source.reason_rejected || source.reasonRejected, Math.floor(max / 2));
+    if (hypothesis && whyRejected) {
+        return "".concat(hypothesis, " rejected because ").concat(whyRejected).slice(0, max);
+    }
+    var routeModulePermission = cleanText(source.route_module_permission_gate || source.routeModulePermissionGate, Math.floor(max / 2));
+    var templateGate = cleanText(source.template_conditional_rendering_gate || source.templateConditionalRenderingGate, Math.floor(max / 2));
+    var backingGate = cleanText(source.backing_role_group_config_publications_gate || source.backingRoleGroupConfigPublicationsGate, Math.floor(max / 2));
+    return [routeModulePermission, templateGate, backingGate].filter(Boolean).join(' | ').slice(0, max);
+}
+function supportDiagnosisLooksLikeClassifiedFeatureRequest(source, issueCaseText, failingPathText, hypothesisText) {
+    var classificationText = supportDiagnosisNarrativeText(source.classification || source.classification_reason || source.classificationReason, 700);
+    var issueClassText = cleanText(source.issue_class || source.issueClass, 160);
+    var combined = [
+        issueClassText,
+        classificationText,
+        issueCaseText,
+        failingPathText,
+        hypothesisText
+    ].join(' ').toLowerCase();
+    return /\b(feature request|feature_request|new feature|requested behavior change|net-new|net new|not implemented|no existing|none_existing|does not exist|no .*route)\b/i.test(combined);
+}
+function normalizeSupportDiagnosisRejectedAlternatives(values) {
+    var e_5, _a;
+    if (!Array.isArray(values)) {
+        return cleanList(values, 10, 700);
+    }
+    var result = [];
+    try {
+        for (var values_2 = __values(values), values_2_1 = values_2.next(); !values_2_1.done; values_2_1 = values_2.next()) {
+            var value = values_2_1.value;
+            var text = supportDiagnosisNarrativeText(value, 700);
+            if (text && !result.includes(text)) {
+                result.push(text);
+            }
+            if (result.length >= 10) {
+                break;
+            }
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (values_2_1 && !values_2_1.done && (_a = values_2.return)) _a.call(values_2);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return result;
+}
+function normalizeSupportDiagnosisProofPlanRows(values) {
+    var e_6, _a;
+    if (!Array.isArray(values)) {
+        return {};
+    }
+    var actions = [];
+    var proofRequired = [];
+    try {
+        for (var values_3 = __values(values), values_3_1 = values_3.next(); !values_3_1.done; values_3_1 = values_3.next()) {
+            var row = values_3_1.value;
+            var source = cleanObject(row);
+            var action = pickText(source, ['action', 'step', 'browser_action', 'browserAction', 'task'], 500) || supportDiagnosisNarrativeText(row, 500);
+            var proof = pickText(source, ['proof_required', 'proofRequired', 'expected', 'expected_result', 'expectedResult', 'assertion', 'business_assertion', 'businessAssertion'], 700);
+            if (action) {
+                actions.push(action);
+            }
+            if (proof) {
+                proofRequired.push(proof);
+            }
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (values_3_1 && !values_3_1.done && (_a = values_3.return)) _a.call(values_3);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    return {
+        action: actions.join(' | ').slice(0, 1000),
+        after: proofRequired.join(' | ').slice(0, 1000),
+        business_assertion: proofRequired.join(' | ').slice(0, 1000),
+        data_assertion: proofRequired.join(' | ').slice(0, 1000)
+    };
+}
 function normalizeOwnerFilePath(value) {
-    return cleanListEntryText(value, 500)
+    var e_7, _a;
+    var normalized = cleanListEntryText(value, 500)
         .replace(/\\/g, '/')
         .replace(/^\.\/+/, '')
         .replace(/^\/+/, '')
         .replace(/\s+$/g, '');
+    try {
+        for (var _b = __values([
+            /(?:^|\/)resolveio-ai-workspace\/[^/]+\/resolveio-all\//i,
+            /(?:^|\/)ai-workspace\/[^/]+\/resolveio-all\//i,
+            /(?:^|\/)resolveio-all\//i,
+            /(?:^|\/)resolveio-server-lib\//i,
+            /(?:^|\/)resolveio-client-lib\//i
+        ]), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var pattern = _c.value;
+            var match = normalized.match(pattern);
+            if ((match === null || match === void 0 ? void 0 : match.index) !== undefined) {
+                var start = match.index + match[0].length;
+                var stripped = normalized.slice(start).replace(/^\/+/, '');
+                if (stripped) {
+                    return stripped;
+                }
+            }
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    return normalized;
 }
 function isResolveIOSupportGeneratedAngularWrapperPath(value) {
     var normalized = normalizeOwnerFilePath(value).replace(/^geochem\//i, '');
     return /(?:^|\/)angular\/app\/(?:methods|publications)\.ts$/i.test(normalized);
 }
 function ownerFileComparablePathKeys(value) {
-    var e_5, _a;
+    var e_8, _a;
     var normalized = normalizeOwnerFilePath(value);
     if (!normalized) {
         return [];
@@ -1472,12 +1653,12 @@ function ownerFileComparablePathKeys(value) {
             }
         }
     }
-    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
     finally {
         try {
             if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
         }
-        finally { if (e_5) throw e_5.error; }
+        finally { if (e_8) throw e_8.error; }
     }
     return Array.from(keys);
 }
@@ -1511,7 +1692,7 @@ function ownerFileLooksNonProductEvidence(value) {
     var normalized = normalizeOwnerFilePath(value);
     return /(^|\/)(qa-artifacts?|screenshots?|screen-shots?|traces?|logs?|tmp|temp|coverage|dist|build|docs?)(\/|$)/i.test(normalized)
         || /(^|\/)(?:support-diagnosis-pack-[^/]+|diagnosis-evidence-pack|aiqa-business-assertion)\.json$/i.test(normalized)
-        || /(^|\/)\.resolveio-(?:support|context|runner|qa)(\/|$)/i.test(normalized)
+        || /(^|\/)\.resolveio-(?:support-context|support|context|runner|qa)(\/|$)/i.test(normalized)
         || /(^|\/)(__tests__|tests?|spec)(\/|$)|\.(?:spec|test)\.[jt]sx?$/i.test(normalized)
         || /\.(?:png|jpe?g|gif|webp|svg|pdf|log|txt|md|markdown)$/i.test(normalized);
 }
@@ -1815,59 +1996,131 @@ function evaluateResolveIOSupportDiagnosisEvidenceQuality(value) {
     };
 }
 function normalizeResolveIOSupportDiagnosisGate(value, now) {
-    var source = cleanObject(value);
+    var rootSource = cleanObject(value);
+    var source = cleanObject(rootSource.support_diagnosis_gate
+        || rootSource.supportDiagnosisGate
+        || rootSource.diagnosis_gate
+        || rootSource.diagnosisGate
+        || rootSource);
     if (!Object.keys(source).length) {
         return undefined;
     }
-    var issueCaseSource = cleanObject(source.issue_case || source.issueCase);
+    var rawIssueCase = source.issue_case || source.issueCase;
+    var rawHypothesis = source.accepted_hypothesis || source.acceptedHypothesis;
+    var rawFailingPath = source.failing_path || source.failingPath;
+    var rawProofPlan = source.proof_plan || source.proofPlan;
+    var issueCaseSource = cleanObject(rawIssueCase);
     var hypothesisSource = cleanObject(source.accepted_hypothesis || source.acceptedHypothesis);
     var failingPathSource = cleanObject(source.failing_path || source.failingPath);
     var proofPlanSource = cleanObject(source.proof_plan || source.proofPlan);
+    var issueCaseText = supportDiagnosisNarrativeText(rawIssueCase, 1200);
+    var hypothesisText = supportDiagnosisNarrativeText(rawHypothesis, 1200);
+    var failingPathText = supportDiagnosisNarrativeText(rawFailingPath, 1200);
+    var proofPlanRows = normalizeSupportDiagnosisProofPlanRows(rawProofPlan);
     var issueClass = normalizeIssueClass(source.issue_class || source.issueClass);
-    var businessProofContract = normalizeSupportDiagnosisBusinessProofContract(proofPlanSource.business_proof_contract || proofPlanSource.businessProofContract || source.business_proof_contract || source.businessProofContract, issueClass || source.issue_class || source.issueClass);
-    var ownerFiles = cleanList(source.owner_files || source.ownerFiles, 20, 500)
+    var featureRequestClassified = supportDiagnosisLooksLikeClassifiedFeatureRequest(source, issueCaseText, failingPathText, hypothesisText);
+    var shouldDeriveLooseProofPlan = Array.isArray(rawProofPlan) || featureRequestClassified;
+    var proofPlanBefore = pickText(proofPlanSource, ['before', 'before_state', 'beforeState', 'precondition'], 1000);
+    var proofPlanBeforeUnavailable = pickText(proofPlanSource, ['before_state_unavailable_reason', 'beforeStateUnavailableReason', 'before_unavailable_reason'], 1000)
+        || (featureRequestClassified ? 'Before-state business proof is not available because this is classified as net-new feature scope; current evidence proves the requested route/workflow is not implemented yet.' : '');
+    var proofPlanAction = pickText(proofPlanSource, ['action', 'browser_action', 'browserAction', 'steps'], 1000) || proofPlanRows.action;
+    var proofPlanAfter = pickText(proofPlanSource, ['after', 'after_state', 'afterState', 'expected_after'], 1000) || proofPlanRows.after;
+    var proofPlanBusinessAssertion = pickText(proofPlanSource, ['business_assertion', 'businessAssertion', 'assertion'], 1000) || proofPlanRows.business_assertion;
+    var proofPlanDataAssertion = pickText(proofPlanSource, ['data_assertion', 'dataAssertion', 'mongo_delta', 'mongoDelta'], 1000) || proofPlanRows.data_assertion;
+    var proofPlanArtifactExpectation = pickText(proofPlanSource, ['artifact_expectation', 'artifactExpectation', 'artifact', 'screenshot'], 1000)
+        || (shouldDeriveLooseProofPlan && proofPlanBusinessAssertion ? 'browser trace/screenshot plus persisted DOM/data or Mongo delta tied to the business assertion' : '');
+    var derivedBusinessProofContract = shouldDeriveLooseProofPlan && proofPlanBusinessAssertion ? {
+        issue_class: issueClass || source.issue_class || source.issueClass,
+        setup_state: proofPlanBefore || proofPlanBeforeUnavailable,
+        action_under_test: proofPlanAction,
+        expected_business_state_change: proofPlanAfter || proofPlanBusinessAssertion,
+        prohibited_false_pass: 'Route load, screenshot, scorecard, or model claim alone is not acceptance.',
+        proof_artifacts: [
+            proofPlanArtifactExpectation,
+            'DOM/data assertion artifact',
+            'persisted record or Mongo delta proof'
+        ].filter(Boolean),
+        data_or_dom_assertion: proofPlanDataAssertion || proofPlanBusinessAssertion
+    } : undefined;
+    var businessProofContract = normalizeSupportDiagnosisBusinessProofContract(proofPlanSource.business_proof_contract || proofPlanSource.businessProofContract || source.business_proof_contract || source.businessProofContract, issueClass || source.issue_class || source.issueClass) || normalizeSupportDiagnosisBusinessProofContract(derivedBusinessProofContract, issueClass || source.issue_class || source.issueClass);
+    var rawOwnerFiles = cleanList(source.owner_files || source.ownerFiles, 20, 500)
         .map(normalizeOwnerFilePath)
         .filter(Boolean);
+    var productOwnerFiles = rawOwnerFiles.filter(function (ownerFile) { return !ownerFileLooksNonProductEvidence(ownerFile); });
+    var ownerFiles = productOwnerFiles.length ? productOwnerFiles : rawOwnerFiles;
+    var explicitEvidence = normalizeSupportDiagnosisEvidence(source.evidence);
+    var derivedFeatureRequestEvidence = !explicitEvidence.length && featureRequestClassified ? __spreadArray(__spreadArray([], __read((issueCaseText ? [{
+            id: "evidence-".concat(hashResolveIOSupportV5Evidence({ type: 'ticket', summary: issueCaseText }).slice(0, 12)),
+            type: 'ticket',
+            summary: issueCaseText
+        }] : [])), false), __read(ownerFiles.map(function (ownerFile) { return ({
+        id: "evidence-".concat(hashResolveIOSupportV5Evidence({ type: 'code', ownerFile: ownerFile, failingPathText: failingPathText, hypothesisText: hypothesisText }).slice(0, 12)),
+        type: 'code',
+        summary: cleanText([
+            "Owner file inspected for classified feature-request scope: ".concat(ownerFile, "."),
+            failingPathText || hypothesisText || 'No implemented route/module path was identified.'
+        ].filter(Boolean).join(' '), 1200),
+        artifactPath: ownerFile,
+        ownerFiles: [ownerFile]
+    }); })), false) : [];
+    var diagnosisEvidence = explicitEvidence.length ? explicitEvidence : derivedFeatureRequestEvidence;
+    var routeModule = pickText(issueCaseSource, ['route_module', 'routeModule', 'route', 'module', 'screen'], 500)
+        || pickText(source, ['route_module', 'routeModule', 'module', 'screen'], 500)
+        || pickText(failingPathSource, ['route', 'module', 'path', 'description'], 500)
+        || (featureRequestClassified ? 'net-new support feature workflow' : '');
+    var expectedResult = pickText(issueCaseSource, ['expected_result', 'expectedResult', 'expected'], 1000)
+        || pickText(source, ['expected_result', 'expectedResult', 'expected', 'primary_goal', 'primaryGoal', 'requested_behavior', 'requestedBehavior'], 1000)
+        || (featureRequestClassified && issueCaseText ? "Implement the requested workflow: ".concat(issueCaseText) : '');
+    var observedResult = pickText(issueCaseSource, ['observed_result', 'observedResult', 'observed', 'actual'], 1000)
+        || pickText(source, ['observed_result', 'observedResult', 'observed', 'actual', 'current_state', 'currentState'], 1000)
+        || (featureRequestClassified ? "Current repo evidence indicates no implemented route/module for ".concat(routeModule || 'the requested workflow', ".") : '');
+    var accountCustomerContext = pickText(issueCaseSource, ['account_customer_context', 'accountCustomerContext', 'account', 'customer', 'user', 'context'], 800)
+        || pickText(source, ['account_customer_context', 'accountCustomerContext', 'affected_account_user', 'affectedAccountUser', 'account', 'customer', 'client', 'user', 'context'], 800)
+        || (featureRequestClassified ? 'Customer/account context from support ticket intake.' : '');
+    var rawReproductionStatus = issueCaseSource.reproduction_status || issueCaseSource.reproductionStatus || source.reproduction_status;
     var gate = {
         issue_case: {
-            customer_complaint: pickText(issueCaseSource, ['customer_complaint', 'customerComplaint', 'complaint', 'request', 'summary'], 1200),
-            expected_result: pickText(issueCaseSource, ['expected_result', 'expectedResult', 'expected'], 1000),
-            observed_result: pickText(issueCaseSource, ['observed_result', 'observedResult', 'observed', 'actual'], 1000),
-            route_module: pickText(issueCaseSource, ['route_module', 'routeModule', 'route', 'module', 'screen'], 500),
-            account_customer_context: pickText(issueCaseSource, ['account_customer_context', 'accountCustomerContext', 'account', 'customer', 'user', 'context'], 800),
-            reproduction_status: normalizeReproductionStatus(issueCaseSource.reproduction_status || issueCaseSource.reproductionStatus || source.reproduction_status),
+            customer_complaint: pickText(issueCaseSource, ['customer_complaint', 'customerComplaint', 'complaint', 'request', 'summary'], 1200) || issueCaseText,
+            expected_result: expectedResult,
+            observed_result: observedResult,
+            route_module: routeModule,
+            account_customer_context: accountCustomerContext,
+            reproduction_status: rawReproductionStatus ? normalizeReproductionStatus(rawReproductionStatus) : (featureRequestClassified ? 'classified' : normalizeReproductionStatus(rawReproductionStatus)),
             reproduction_blocker: pickText(issueCaseSource, ['reproduction_blocker', 'reproductionBlocker', 'blocked_reason', 'blockedReason'], 1000)
         },
         issue_class: issueClass || 'missing_wrong_data',
         accepted_hypothesis: {
             statement: pickText(hypothesisSource, ['statement', 'hypothesis', 'root_cause', 'rootCause', 'summary'], 1200)
-                || (typeof source.accepted_hypothesis === 'string' ? cleanText(source.accepted_hypothesis, 1200) : ''),
-            falsifiable_test: pickText(hypothesisSource, ['falsifiable_test', 'falsifiableTest', 'test', 'proof', 'falsifier'], 1000),
-            evidence: cleanList(hypothesisSource.evidence || source.hypothesis_evidence || source.hypothesisEvidence, 10, 800)
+                || hypothesisText,
+            falsifiable_test: pickText(hypothesisSource, ['falsifiable_test', 'falsifiableTest', 'test', 'proof', 'falsifier'], 1000)
+                || (failingPathText ? "Verify the accepted hypothesis against the failing path evidence: ".concat(failingPathText) : ''),
+            evidence: cleanList(hypothesisSource.evidence || source.hypothesis_evidence || source.hypothesisEvidence, 10, 800).length
+                ? cleanList(hypothesisSource.evidence || source.hypothesis_evidence || source.hypothesisEvidence, 10, 800)
+                : diagnosisEvidence.map(function (entry) { return [entry.artifactPath, entry.summary].filter(Boolean).join(': '); }).filter(Boolean).slice(0, 10)
         },
-        rejected_alternatives: cleanList(source.rejected_alternatives || source.rejectedAlternatives, 10, 700),
+        rejected_alternatives: normalizeSupportDiagnosisRejectedAlternatives(source.rejected_alternatives || source.rejectedAlternatives),
         failing_path: {
             frontend: pickText(failingPathSource, ['frontend', 'frontend_path', 'frontendPath', 'eventPath'], 700),
             backend: pickText(failingPathSource, ['backend', 'backend_path', 'backendPath', 'methodPublicationPath'], 700),
             shared_library: pickText(failingPathSource, ['shared_library', 'sharedLibrary', 'library', 'lib'], 700),
             data_query: pickText(failingPathSource, ['data_query', 'dataQuery', 'query'], 700),
-            description: pickText(failingPathSource, ['description', 'path', 'summary'], 1200) || cleanText(source.failing_path, 1200)
+            description: pickText(failingPathSource, ['description', 'path', 'summary'], 1200) || failingPathText
         },
         owner_files: ownerFiles,
         proof_plan: {
-            before: pickText(proofPlanSource, ['before', 'before_state', 'beforeState', 'precondition'], 1000),
-            before_state_unavailable_reason: pickText(proofPlanSource, ['before_state_unavailable_reason', 'beforeStateUnavailableReason', 'before_unavailable_reason'], 1000),
-            action: pickText(proofPlanSource, ['action', 'browser_action', 'browserAction', 'steps'], 1000),
-            after: pickText(proofPlanSource, ['after', 'after_state', 'afterState', 'expected_after'], 1000),
-            business_assertion: pickText(proofPlanSource, ['business_assertion', 'businessAssertion', 'assertion'], 1000),
+            before: proofPlanBefore,
+            before_state_unavailable_reason: proofPlanBeforeUnavailable,
+            action: proofPlanAction,
+            after: proofPlanAfter,
+            business_assertion: proofPlanBusinessAssertion,
             route: pickText(proofPlanSource, ['route', 'url'], 500),
-            data_assertion: pickText(proofPlanSource, ['data_assertion', 'dataAssertion', 'mongo_delta', 'mongoDelta'], 1000),
-            artifact_expectation: pickText(proofPlanSource, ['artifact_expectation', 'artifactExpectation', 'artifact', 'screenshot'], 1000),
+            data_assertion: proofPlanDataAssertion,
+            artifact_expectation: proofPlanArtifactExpectation,
             business_proof_contract: businessProofContract
         },
         similar_tickets: normalizeSupportDiagnosisHints(source.similar_tickets || source.similarTickets),
         similar_commits: normalizeSupportDiagnosisHints(source.similar_commits || source.similarCommits),
-        evidence: normalizeSupportDiagnosisEvidence(source.evidence),
+        evidence: diagnosisEvidence,
         status: cleanText(source.status, 80).toLowerCase() || 'incomplete',
         updatedAt: isoNow(now || source.updatedAt || source.updated_at)
     };
@@ -1877,7 +2130,7 @@ function normalizeResolveIOSupportDiagnosisGate(value, now) {
     return gate;
 }
 function extractResolveIOSupportDiagnosisGateFromText(value, now) {
-    var e_6, _a;
+    var e_9, _a;
     var text = String(value || '').trim();
     if (!text) {
         return undefined;
@@ -1905,12 +2158,12 @@ function extractResolveIOSupportDiagnosisGateFromText(value, now) {
             }
         }
     }
-    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
     finally {
         try {
             if (candidates_1_1 && !candidates_1_1.done && (_a = candidates_1.return)) _a.call(candidates_1);
         }
-        finally { if (e_6) throw e_6.error; }
+        finally { if (e_9) throw e_9.error; }
     }
     return undefined;
 }
@@ -2073,7 +2326,7 @@ function supportStatusLooksPassed(value) {
     return /\b(pass|passed|success|succeeded|complete|completed|ready|not_required|not required)\b/i.test(cleanText(value, 200));
 }
 function nestedObject(source) {
-    var e_7, _a;
+    var e_10, _a;
     var keys = [];
     for (var _i = 1; _i < arguments.length; _i++) {
         keys[_i - 1] = arguments[_i];
@@ -2087,17 +2340,17 @@ function nestedObject(source) {
             }
         }
     }
-    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    catch (e_10_1) { e_10 = { error: e_10_1 }; }
     finally {
         try {
             if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
         }
-        finally { if (e_7) throw e_7.error; }
+        finally { if (e_10) throw e_10.error; }
     }
     return {};
 }
 function resolveSupportReplyReleaseGate(input) {
-    var e_8, _a;
+    var e_11, _a;
     var _b;
     var releaseEvidence = cleanObject(input.releaseEvidence);
     var releaseStatus = cleanText(input.releaseStatus
@@ -2168,12 +2421,12 @@ function resolveSupportReplyReleaseGate(input) {
             blockers.push("missing_".concat(field));
         }
     }
-    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
     finally {
         try {
             if (missingCommitProofFields_1_1 && !missingCommitProofFields_1_1.done && (_a = missingCommitProofFields_1.return)) _a.call(missingCommitProofFields_1);
         }
-        finally { if (e_8) throw e_8.error; }
+        finally { if (e_11) throw e_11.error; }
     }
     var shouldEvaluateHotfix = statusBlocked || commitProofRequired || Object.keys(hotfixEvidence).length > 0;
     var hotfixContinuation = shouldEvaluateHotfix
@@ -2219,7 +2472,7 @@ function supportBusinessAssertionRouteOnly(value) {
     return /^(route_probe_pass|route_only_pass|route_pass|route_probe|route_loaded)$/i.test(cleanText(value, 80));
 }
 function normalizeSupportBusinessProofAssertions(input) {
-    var e_9, _a;
+    var e_12, _a;
     var gate = normalizeResolveIOSupportDiagnosisGate(input.diagnosisGate);
     var proofPlan = gate === null || gate === void 0 ? void 0 : gate.proof_plan;
     var proofContract = proofPlan === null || proofPlan === void 0 ? void 0 : proofPlan.business_proof_contract;
@@ -2253,12 +2506,12 @@ function normalizeSupportBusinessProofAssertions(input) {
             });
         }
     }
-    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    catch (e_12_1) { e_12 = { error: e_12_1 }; }
     finally {
         try {
             if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
         }
-        finally { if (e_9) throw e_9.error; }
+        finally { if (e_12) throw e_12.error; }
     }
     var status = cleanText(input.businessAssertionStatus || input.outcomeLabel, 80);
     if (!assertions.length && (supportBusinessAssertionPassed(status) || supportBusinessAssertionRouteOnly(status) || supportBusinessAssertionFailed(status))) {
@@ -2348,7 +2601,7 @@ function supportBusinessProofAssertionHasStructuredContractMapping(assertion, ga
     return routeMatches && actionMatches && expectedStateMatches && hasBusinessDataProof;
 }
 function supportBusinessProofAssertionMatchesContract(assertion, gate) {
-    var e_10, _a;
+    var e_13, _a;
     if (!gate) {
         return false;
     }
@@ -2388,12 +2641,12 @@ function supportBusinessProofAssertionMatchesContract(assertion, gate) {
             }
         }
     }
-    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+    catch (e_13_1) { e_13 = { error: e_13_1 }; }
     finally {
         try {
             if (proofWords_1_1 && !proofWords_1_1.done && (_a = proofWords_1.return)) _a.call(proofWords_1);
         }
-        finally { if (e_10) throw e_10.error; }
+        finally { if (e_13) throw e_13.error; }
     }
     return overlap >= Math.min(5, Math.max(3, Math.ceil(proofWords.size * 0.45)));
 }
@@ -3918,7 +4171,7 @@ function supportManagerRequiredResetEvidenceForContract(contract) {
     ], false))).slice(0, 16);
 }
 function validateResolveIOSupportNextActionContract(value) {
-    var e_11, _a;
+    var e_14, _a;
     var _b, _c, _d, _e, _f;
     var contract = cleanObject(value);
     var blockers = [];
@@ -3940,12 +4193,12 @@ function validateResolveIOSupportNextActionContract(value) {
             }
         }
     }
-    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    catch (e_14_1) { e_14 = { error: e_14_1 }; }
     finally {
         try {
             if (requiredStringFields_1_1 && !requiredStringFields_1_1.done && (_a = requiredStringFields_1.return)) _a.call(requiredStringFields_1);
         }
-        finally { if (e_11) throw e_11.error; }
+        finally { if (e_14) throw e_14.error; }
     }
     if (!Array.isArray(contract.nextCommands) || !contract.nextCommands.length) {
         blockers.push('NextActionContract.nextCommands must include at least the primary command.');
@@ -4964,7 +5217,7 @@ function buildResolveIOSupportV5ScopeDigest(input) {
     return raw.slice(0, maxChars);
 }
 function buildResolveIOSupportV5MicrotaskLedger(input) {
-    var e_12, _a;
+    var e_15, _a;
     var existing = Array.isArray(input.existing) ? input.existing : [];
     var completedByObjective = new Map();
     try {
@@ -4975,12 +5228,12 @@ function buildResolveIOSupportV5MicrotaskLedger(input) {
             }
         }
     }
-    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+    catch (e_15_1) { e_15 = { error: e_15_1 }; }
     finally {
         try {
             if (existing_1_1 && !existing_1_1.done && (_a = existing_1.return)) _a.call(existing_1);
         }
-        finally { if (e_12) throw e_12.error; }
+        finally { if (e_15) throw e_15.error; }
     }
     var now = isoNow(input.now);
     var requirements = cleanList(input.requirements, 30, 240);
@@ -6771,7 +7024,7 @@ function buildResolveIOSupportV5MicrotaskPrompt(input) {
     };
 }
 function summarizeResolveIOSupportV5MicrotaskUsage(bundle) {
-    var e_13, _a, e_14, _b;
+    var e_16, _a, e_17, _b;
     var byMicrotask = new Map();
     var bySection = new Map();
     var totalPromptTokenEstimate = 0;
@@ -6786,17 +7039,17 @@ function summarizeResolveIOSupportV5MicrotaskUsage(bundle) {
             existing.calls += 1;
             byMicrotask.set(usage.microtaskId, existing);
             try {
-                for (var _e = (e_14 = void 0, __values(usage.promptSections || [])), _f = _e.next(); !_f.done; _f = _e.next()) {
+                for (var _e = (e_17 = void 0, __values(usage.promptSections || [])), _f = _e.next(); !_f.done; _f = _e.next()) {
                     var section = _f.value;
                     bySection.set(section.name, (bySection.get(section.name) || 0) + section.tokenEstimate);
                 }
             }
-            catch (e_14_1) { e_14 = { error: e_14_1 }; }
+            catch (e_17_1) { e_17 = { error: e_17_1 }; }
             finally {
                 try {
                     if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
                 }
-                finally { if (e_14) throw e_14.error; }
+                finally { if (e_17) throw e_17.error; }
             }
             var hardCap = usage.lane === 'qa' ? promptBudget.qaMicrotaskHardCap : promptBudget.buildMicrotaskHardCap;
             if ((usage.promptTokenEstimate || 0) > hardCap) {
@@ -6804,12 +7057,12 @@ function summarizeResolveIOSupportV5MicrotaskUsage(bundle) {
             }
         }
     }
-    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+    catch (e_16_1) { e_16 = { error: e_16_1 }; }
     finally {
         try {
             if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
         }
-        finally { if (e_13) throw e_13.error; }
+        finally { if (e_16) throw e_16.error; }
     }
     return {
         totalPromptTokenEstimate: totalPromptTokenEstimate,