@resolveio/server-lib 22.3.210 → 22.3.212

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)
@@ -1420,6 +1458,174 @@ function buildResolveIOSupportDiagnosisEvidencePack(input) {
         generatedAt: generatedAt
     };
 }
+function inferResolveIOSupportIssueClassFromText(value) {
+    var text = cleanText(value, 3000).toLowerCase();
+    if (/\b(upload|import|csv|spreadsheet|attachment|file)\b/.test(text)) {
+        return 'upload_import';
+    }
+    if (/\b(invoice|pdf|export|print|printed|report|download)\b/.test(text)) {
+        return 'invoice_pdf_export';
+    }
+    if (/\b(filter|query|search|wrong customer|wrong account|mismatch)\b/.test(text)) {
+        return 'filter_query_mismatch';
+    }
+    if (/\b(route|auth|permission|login|hydrate|hydration|blank page|shell)\b/.test(text)) {
+        return 'route_auth_hydration';
+    }
+    if (/\b(slow|timeout|performance|latency|takes too long|hang)\b/.test(text)) {
+        return 'slow_query_performance';
+    }
+    if (/\b(submit|save|click|button|no-op|does nothing|not saving)\b/.test(text)) {
+        return 'no_op_submit';
+    }
+    return 'missing_wrong_data';
+}
+function firstSupportDiagnosisText() {
+    var e_5, _a;
+    var values = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        values[_i] = arguments[_i];
+    }
+    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 = cleanText(value, 1400);
+            if (text && !supportDiagnosisTextLooksGeneric(text, 12)) {
+                return text;
+            }
+        }
+    }
+    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 '';
+}
+function extractSupportDiagnosisLineValue(text, label, max) {
+    if (max === void 0) { max = 1000; }
+    var escaped = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    var match = String(text || '').match(new RegExp("(?:^|\\n)\\s*".concat(escaped, "\\s*:\\s*([^\\n]+)"), 'i'));
+    return cleanText(match === null || match === void 0 ? void 0 : match[1], max);
+}
+function inferSupportDiagnosisRouteModuleFromOwners(ownerFiles, text) {
+    var joinedOwners = ownerFiles.join('\n');
+    if (/part\/detail|part-detail|inventory/i.test("".concat(joinedOwners, "\n").concat(text))) {
+        return 'H2SKO part inventory detail / inventory print workflow';
+    }
+    if (/document\/pick-ticket|pick-ticket/i.test(joinedOwners)) {
+        return 'H2SKO pick-ticket print/report workflow';
+    }
+    if (/invoice/i.test("".concat(joinedOwners, "\n").concat(text))) {
+        return 'invoice/PDF/export workflow';
+    }
+    if (/upload|import/i.test("".concat(joinedOwners, "\n").concat(text))) {
+        return 'upload/import workflow';
+    }
+    return firstSupportDiagnosisText(extractSupportDiagnosisLineValue(text, 'Route'), extractSupportDiagnosisLineValue(text, 'Module'));
+}
+function buildSupportDiagnosisProofPlanScaffold(issueClass, complaint, routeModule) {
+    var target = cleanText(routeModule || complaint || 'the reported workflow', 300);
+    if (issueClass === 'upload_import') {
+        return {
+            before: 'Capture the target records/counts before re-running the customer import.',
+            before_state_unavailable_reason: '',
+            action: "Run the same upload/import path for ".concat(target, " with the staged customer attachment or an equivalent ticket fixture."),
+            after: 'Every expected imported row is attached/persisted with the correct relationships and no silently skipped rows.',
+            business_assertion: 'The import creates or updates all ticket-expected records, not just a successful upload shell.',
+            route: target,
+            data_assertion: 'Mongo/DOM row counts and representative imported records match the attachment contents.',
+            artifact_expectation: 'before count JSON, import action trace/screenshot, after count JSON, representative imported record proof',
+            business_proof_contract: {
+                issue_class: issueClass,
+                setup_state: 'Customer attachment or localhost fixture is available before import.',
+                action_under_test: 'Execute the import workflow end to end.',
+                expected_business_state_change: 'All expected rows/relationships exist after import.',
+                prohibited_false_pass: 'Upload completion, route load, screenshot, scorecard, or model claim alone is not acceptance.',
+                proof_artifacts: ['before Mongo/data snapshot', 'import action trace or screenshot', 'after Mongo/data snapshot', 'row-level mismatch report'],
+                data_or_dom_assertion: 'Imported record counts and key fields match the source attachment.'
+            }
+        };
+    }
+    var action = issueClass === 'invoice_pdf_export'
+        ? "Run the print/report/export path for ".concat(target, " using the named customer record.")
+        : issueClass === 'filter_query_mismatch'
+            ? "Run the filtered/search/query workflow for ".concat(target, " using the named customer/account context.")
+            : "Run the exact customer-reported workflow for ".concat(target, ".");
+    return {
+        before: 'Capture the customer-reported wrong/missing value before repair using the staged ticket context.',
+        before_state_unavailable_reason: '',
+        action: action,
+        after: 'The same workflow shows the expected customer/account data and no longer shows the wrong value.',
+        business_assertion: 'The reported business value is correct after the action, not merely that the route loaded.',
+        route: target,
+        data_assertion: 'DOM/print/report output and persisted source data agree for the named customer record.',
+        artifact_expectation: 'before screenshot/data snapshot, action trace, after screenshot/data snapshot, AIQaBusinessAssertion JSON',
+        business_proof_contract: {
+            issue_class: issueClass,
+            setup_state: 'The named customer record is present in the staged support data before action.',
+            action_under_test: action,
+            expected_business_state_change: 'The visible/output business data matches the expected persisted value.',
+            prohibited_false_pass: 'Route load, screenshot-only proof, scorecard pass, or model claim alone is not acceptance.',
+            proof_artifacts: ['before DOM/data snapshot', 'action trace/screenshot', 'after DOM/data snapshot', 'Mongo or persisted data comparison'],
+            data_or_dom_assertion: 'The displayed/output value matches the expected persisted customer value.'
+        }
+    };
+}
+function buildResolveIOSupportDiagnosisRetryScaffold(input) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    var existing = normalizeResolveIOSupportDiagnosisGate(input.diagnosisGate, input.now);
+    var scopeText = cleanText([
+        (_a = input.bundle) === null || _a === void 0 ? void 0 : _a.supportV5ScopeDigest,
+        (_c = (_b = input.bundle) === null || _b === void 0 ? void 0 : _b.supportV5SupervisorState) === null || _c === void 0 ? void 0 : _c.currentGoal,
+        (_e = (_d = input.bundle) === null || _d === void 0 ? void 0 : _d.supportV5SupervisorState) === null || _e === void 0 ? void 0 : _e.approvedScope
+    ].filter(Boolean).join('\n'), 3000);
+    var ownerFiles = Array.from(new Set(__spreadArray(__spreadArray([], __read(cleanList(existing === null || existing === void 0 ? void 0 : existing.owner_files, 8, 500)), false), __read(cleanList((_f = input.evidencePack) === null || _f === void 0 ? void 0 : _f.ownerFileHints, 8, 500)), false).map(normalizeOwnerFilePath).filter(Boolean))).slice(0, 8);
+    var complaint = firstSupportDiagnosisText(existing === null || existing === void 0 ? void 0 : existing.issue_case.customer_complaint, extractSupportDiagnosisLineValue(scopeText, 'Customer complaint'), extractSupportDiagnosisLineValue(scopeText, 'Issue'), extractSupportDiagnosisLineValue(scopeText, 'Approved scope'), scopeText);
+    var issueClass = normalizeIssueClass((existing === null || existing === void 0 ? void 0 : existing.issue_class) || ((_g = input.evidencePack) === null || _g === void 0 ? void 0 : _g.issueClassHint))
+        || inferResolveIOSupportIssueClassFromText("".concat(scopeText, "\n").concat(ownerFiles.join('\n')));
+    var routeModule = firstSupportDiagnosisText(existing === null || existing === void 0 ? void 0 : existing.issue_case.route_module, inferSupportDiagnosisRouteModuleFromOwners(ownerFiles, scopeText), extractSupportDiagnosisLineValue(scopeText, 'Route'), extractSupportDiagnosisLineValue(scopeText, 'Module'));
+    var expected = firstSupportDiagnosisText(existing === null || existing === void 0 ? void 0 : existing.issue_case.expected_result, extractSupportDiagnosisLineValue(scopeText, 'Expected'), complaint ? "The customer-reported workflow should use the correct business data for: ".concat(complaint) : '');
+    var observed = firstSupportDiagnosisText(existing === null || existing === void 0 ? void 0 : existing.issue_case.observed_result, extractSupportDiagnosisLineValue(scopeText, 'Observed'), complaint ? "The observed behavior is the customer report that needs reproduction: ".concat(complaint) : '');
+    var accountContext = firstSupportDiagnosisText(existing === null || existing === void 0 ? void 0 : existing.issue_case.account_customer_context, extractSupportDiagnosisLineValue(scopeText, 'Client'), extractSupportDiagnosisLineValue(scopeText, 'Customer'), extractSupportDiagnosisLineValue(scopeText, 'Reporter'), (_j = (_h = input.bundle) === null || _h === void 0 ? void 0 : _h.supportV5SupervisorState) === null || _j === void 0 ? void 0 : _j.currentGoal);
+    var proofPlan = (existing === null || existing === void 0 ? void 0 : existing.proof_plan) && (existing.proof_plan.action || existing.proof_plan.business_assertion)
+        ? existing.proof_plan
+        : buildSupportDiagnosisProofPlanScaffold(issueClass, complaint, routeModule);
+    return {
+        instruction: 'Starter only. Replace scaffolded guesses with verified ticket/code/browser/Mongo/log evidence before returning support_diagnosis_gate. Do not copy TODO/placeholder text and do not leave strings blank.',
+        support_diagnosis_gate: {
+            issue_case: {
+                customer_complaint: complaint || 'TODO: restate the customer complaint from the staged ticket/email.',
+                expected_result: expected || 'TODO: state the customer-visible expected business result.',
+                observed_result: observed || 'TODO: state the reproduced or classified wrong behavior.',
+                route_module: routeModule || 'TODO: identify the exact route/module/workflow.',
+                account_customer_context: accountContext || 'TODO: name the affected client/account/user context.',
+                reproduction_status: (existing === null || existing === void 0 ? void 0 : existing.issue_case.reproduction_status) || 'blocked',
+                reproduction_blocker: (existing === null || existing === void 0 ? void 0 : existing.issue_case.reproduction_blocker) || 'TODO: replace with blocker only if reproduction cannot be performed.'
+            },
+            issue_class: issueClass,
+            accepted_hypothesis: {
+                statement: firstSupportDiagnosisText(existing === null || existing === void 0 ? void 0 : existing.accepted_hypothesis.statement) || 'TODO: one falsifiable root-cause theory backed by current-ticket evidence.',
+                falsifiable_test: firstSupportDiagnosisText(existing === null || existing === void 0 ? void 0 : existing.accepted_hypothesis.falsifiable_test) || 'TODO: exact test that would prove this hypothesis wrong.',
+                evidence: cleanList(existing === null || existing === void 0 ? void 0 : existing.accepted_hypothesis.evidence, 6, 800)
+            },
+            rejected_alternatives: cleanList(existing === null || existing === void 0 ? void 0 : existing.rejected_alternatives, 4, 800),
+            failing_path: (existing === null || existing === void 0 ? void 0 : existing.failing_path) || {
+                frontend: '',
+                backend: '',
+                shared_library: '',
+                data_query: '',
+                description: routeModule || complaint || ''
+            },
+            owner_files: ownerFiles,
+            proof_plan: proofPlan,
+            evidence: (existing === null || existing === void 0 ? void 0 : existing.evidence) || [],
+            status: 'incomplete'
+        }
+    };
+}
 function normalizeSupportDiagnosisBusinessProofContract(value, issueClassHint) {
     var source = cleanObject(value);
     if (!Object.keys(source).length) {
@@ -1438,19 +1644,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_6, _a;
+    if (!Array.isArray(values)) {
+        return cleanList(values, 10, 700);
+    }
+    var result = [];
+    try {
+        for (var values_3 = __values(values), values_3_1 = values_3.next(); !values_3_1.done; values_3_1 = values_3.next()) {
+            var value = values_3_1.value;
+            var text = supportDiagnosisNarrativeText(value, 700);
+            if (text && !result.includes(text)) {
+                result.push(text);
+            }
+            if (result.length >= 10) {
+                break;
+            }
+        }
+    }
+    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 result;
+}
+function normalizeSupportDiagnosisProofPlanRows(values) {
+    var e_7, _a;
+    if (!Array.isArray(values)) {
+        return {};
+    }
+    var actions = [];
+    var proofRequired = [];
+    try {
+        for (var values_4 = __values(values), values_4_1 = values_4.next(); !values_4_1.done; values_4_1 = values_4.next()) {
+            var row = values_4_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_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (values_4_1 && !values_4_1.done && (_a = values_4.return)) _a.call(values_4);
+        }
+        finally { if (e_7) throw e_7.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_8, _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_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_8) throw e_8.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_9, _a;
     var normalized = normalizeOwnerFilePath(value);
     if (!normalized) {
         return [];
@@ -1472,12 +1821,12 @@ function ownerFileComparablePathKeys(value) {
             }
         }
     }
-    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
     finally {
         try {
             if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
         }
-        finally { if (e_5) throw e_5.error; }
+        finally { if (e_9) throw e_9.error; }
     }
     return Array.from(keys);
 }
@@ -1511,7 +1860,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);
 }
@@ -1529,7 +1878,7 @@ function supportDiagnosisTextLooksGeneric(value, minimumLength) {
     return compact.length < minimumLength
         || meaningfulWords.length < 3
         || /^(n a|na|none|null|unknown|todo|tbd|pending|fix|bug|issue|problem|broken|not working|works|should work)$/i.test(compact)
-        || /\b(todo|tbd|placeholder|unknown|guess|maybe|probably|something|somewhere|stuff|things?)\b/i.test(compact)
+        || /\b(todo|tbd|placeholder|replace with|do not copy|do not leave blank|ticket specific|unknown|guess|maybe|probably|something|somewhere|stuff|things?)\b/i.test(compact)
         || /^(fix|debug|investigate|check|look into|test|verify)( the)? (issue|bug|problem|ticket|route|page)$/i.test(compact)
         || /^(the )?(issue|bug|problem|ticket|route|page)( is)? (fixed|broken|not working|wrong)$/i.test(compact);
 }
@@ -1815,59 +2164,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 +2298,7 @@ function normalizeResolveIOSupportDiagnosisGate(value, now) {
     return gate;
 }
 function extractResolveIOSupportDiagnosisGateFromText(value, now) {
-    var e_6, _a;
+    var e_10, _a;
     var text = String(value || '').trim();
     if (!text) {
         return undefined;
@@ -1905,12 +2326,12 @@ function extractResolveIOSupportDiagnosisGateFromText(value, now) {
             }
         }
     }
-    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    catch (e_10_1) { e_10 = { error: e_10_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_10) throw e_10.error; }
     }
     return undefined;
 }
@@ -2073,7 +2494,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_11, _a;
     var keys = [];
     for (var _i = 1; _i < arguments.length; _i++) {
         keys[_i - 1] = arguments[_i];
@@ -2087,17 +2508,17 @@ function nestedObject(source) {
             }
         }
     }
-    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    catch (e_11_1) { e_11 = { error: e_11_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_11) throw e_11.error; }
     }
     return {};
 }
 function resolveSupportReplyReleaseGate(input) {
-    var e_8, _a;
+    var e_12, _a;
     var _b;
     var releaseEvidence = cleanObject(input.releaseEvidence);
     var releaseStatus = cleanText(input.releaseStatus
@@ -2168,12 +2589,12 @@ function resolveSupportReplyReleaseGate(input) {
             blockers.push("missing_".concat(field));
         }
     }
-    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    catch (e_12_1) { e_12 = { error: e_12_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_12) throw e_12.error; }
     }
     var shouldEvaluateHotfix = statusBlocked || commitProofRequired || Object.keys(hotfixEvidence).length > 0;
     var hotfixContinuation = shouldEvaluateHotfix
@@ -2219,7 +2640,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_13, _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 +2674,12 @@ function normalizeSupportBusinessProofAssertions(input) {
             });
         }
     }
-    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    catch (e_13_1) { e_13 = { error: e_13_1 }; }
     finally {
         try {
             if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
         }
-        finally { if (e_9) throw e_9.error; }
+        finally { if (e_13) throw e_13.error; }
     }
     var status = cleanText(input.businessAssertionStatus || input.outcomeLabel, 80);
     if (!assertions.length && (supportBusinessAssertionPassed(status) || supportBusinessAssertionRouteOnly(status) || supportBusinessAssertionFailed(status))) {
@@ -2348,7 +2769,7 @@ function supportBusinessProofAssertionHasStructuredContractMapping(assertion, ga
     return routeMatches && actionMatches && expectedStateMatches && hasBusinessDataProof;
 }
 function supportBusinessProofAssertionMatchesContract(assertion, gate) {
-    var e_10, _a;
+    var e_14, _a;
     if (!gate) {
         return false;
     }
@@ -2388,12 +2809,12 @@ function supportBusinessProofAssertionMatchesContract(assertion, gate) {
             }
         }
     }
-    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+    catch (e_14_1) { e_14 = { error: e_14_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_14) throw e_14.error; }
     }
     return overlap >= Math.min(5, Math.max(3, Math.ceil(proofWords.size * 0.45)));
 }
@@ -3918,7 +4339,7 @@ function supportManagerRequiredResetEvidenceForContract(contract) {
     ], false))).slice(0, 16);
 }
 function validateResolveIOSupportNextActionContract(value) {
-    var e_11, _a;
+    var e_15, _a;
     var _b, _c, _d, _e, _f;
     var contract = cleanObject(value);
     var blockers = [];
@@ -3940,12 +4361,12 @@ function validateResolveIOSupportNextActionContract(value) {
             }
         }
     }
-    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    catch (e_15_1) { e_15 = { error: e_15_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_15) throw e_15.error; }
     }
     if (!Array.isArray(contract.nextCommands) || !contract.nextCommands.length) {
         blockers.push('NextActionContract.nextCommands must include at least the primary command.');
@@ -4964,7 +5385,7 @@ function buildResolveIOSupportV5ScopeDigest(input) {
     return raw.slice(0, maxChars);
 }
 function buildResolveIOSupportV5MicrotaskLedger(input) {
-    var e_12, _a;
+    var e_16, _a;
     var existing = Array.isArray(input.existing) ? input.existing : [];
     var completedByObjective = new Map();
     try {
@@ -4975,12 +5396,12 @@ function buildResolveIOSupportV5MicrotaskLedger(input) {
             }
         }
     }
-    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+    catch (e_16_1) { e_16 = { error: e_16_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_16) throw e_16.error; }
     }
     var now = isoNow(input.now);
     var requirements = cleanList(input.requirements, 30, 240);
@@ -6549,6 +6970,14 @@ function buildResolveIOSupportV5MicrotaskPrompt(input) {
         ownerFiles: (diagnosisGate === null || diagnosisGate === void 0 ? void 0 : diagnosisGate.owner_files) || targetFiles,
         text: input.bundle.supportV5ScopeDigest || input.bundle.supportV5SupervisorState.currentGoal
     });
+    var diagnosisRetryScaffold = diagnosisActive
+        ? buildResolveIOSupportDiagnosisRetryScaffold({
+            bundle: input.bundle,
+            diagnosisGate: diagnosisGate,
+            evidencePack: diagnosisEvidencePack,
+            now: input.now
+        })
+        : undefined;
     var promptProbePlanValidation = validateResolveIOSupportIssueClassProbePlan(input.bundle.supportV5IssueClassProbePlan, diagnosisValidation.normalized || diagnosisGate, input.now);
     var promptProbePlan = promptProbePlanValidation.valid
         ? promptProbePlanValidation.normalized
@@ -6595,7 +7024,8 @@ function buildResolveIOSupportV5MicrotaskPrompt(input) {
             name: 'root_cause_first_diagnosis_contract',
             text: [
                 'Before any product-code repair, produce strict JSON only:',
-                '{"support_diagnosis_gate":{"issue_case":{"customer_complaint":"","expected_result":"","observed_result":"","route_module":"","account_customer_context":"","reproduction_status":"reproduced|blocked|classified","reproduction_blocker":""},"issue_class":"no_op_submit|missing_wrong_data|filter_query_mismatch|invoice_pdf_export|upload_import|route_auth_hydration|slow_query_performance","accepted_hypothesis":{"statement":"","falsifiable_test":"","evidence":[""]},"rejected_alternatives":[""],"failing_path":{"frontend":"","backend":"","shared_library":"","data_query":"","description":""},"owner_files":["small/exact/file.ts"],"proof_plan":{"before":"","before_state_unavailable_reason":"","action":"","after":"","business_assertion":"","route":"","data_assertion":"","artifact_expectation":"","business_proof_contract":{"issue_class":"same as diagnosis issue_class","setup_state":"","action_under_test":"","expected_business_state_change":"","prohibited_false_pass":"Route load, screenshot, scorecard, or model claim alone is not acceptance.","proof_artifacts":["browser trace/screenshot/json/mongo delta"],"data_or_dom_assertion":""}},"similar_tickets":[],"similar_commits":[],"evidence":[{"type":"ticket|browser|mongo|log|code|commit|qa|other","summary":"","artifactPath":""}],"status":"passed"}}',
+                'Required JSON shape: {"support_diagnosis_gate":{"issue_case":{"customer_complaint":"concrete customer complaint","expected_result":"concrete expected business result","observed_result":"concrete observed/reproduced behavior","route_module":"exact route/module/workflow","account_customer_context":"affected client/account/user","reproduction_status":"reproduced|blocked|classified","reproduction_blocker":"required only when blocked"},"issue_class":"no_op_submit|missing_wrong_data|filter_query_mismatch|invoice_pdf_export|upload_import|route_auth_hydration|slow_query_performance","accepted_hypothesis":{"statement":"one falsifiable root-cause theory","falsifiable_test":"exact test that could disprove it","evidence":["typed evidence with artifact path or concrete code/data citation"]},"rejected_alternatives":["rejected theory plus why"],"failing_path":{"frontend":"frontend event/path if applicable","backend":"method/publication/query if applicable","shared_library":"shared library path if applicable","data_query":"data/query path if applicable","description":"end-to-end failing path"},"owner_files":["small/exact/product-file.ts"],"proof_plan":{"before":"before-state business proof","before_state_unavailable_reason":"only if before proof cannot exist","action":"exact user/system action","after":"expected after-state business proof","business_assertion":"pass/fail assertion tied to customer issue","route":"route/workflow under test","data_assertion":"DOM/data/Mongo assertion","artifact_expectation":"specific artifacts to capture","business_proof_contract":{"issue_class":"same as diagnosis issue_class","setup_state":"setup state","action_under_test":"action under test","expected_business_state_change":"expected state change","prohibited_false_pass":"Route load, screenshot, scorecard, or model claim alone is not acceptance.","proof_artifacts":["specific DOM/data/Mongo/network/screenshot artifacts"],"data_or_dom_assertion":"assertion checked in DOM/data/Mongo"}},"similar_tickets":[],"similar_commits":[],"evidence":[{"type":"ticket|browser|mongo|log|code|commit|qa|other","summary":"concrete evidence summary","artifactPath":"path or code reference"}],"status":"passed"}}',
+                'Do not copy schema/example wording into the output. Empty strings, TODOs, placeholders, route-only proof, and ticket-only proof will fail validation.',
                 'Owner files must be a small exact editable set, not directories, globs, generated wrappers, or broad repo areas.',
                 'The accepted hypothesis must be falsifiable and backed by evidence; prior similar tickets or commits are hints only and cannot bypass fresh diagnosis.',
                 'For reproduction_status="reproduced", evidence must include at least one browser, Mongo, log, or QA evidence object with artifactPath so the runner can replay the proof.',
@@ -6665,6 +7095,10 @@ function buildResolveIOSupportV5MicrotaskPrompt(input) {
                 instruction: 'This JSON block is the diagnosis evidence pack. Do not request or invent a support-diagnosis-pack JSON file unless a concrete named ticket attachment/log is still absent from the staged support evidence context.'
             }, null, 2)
         } : undefined,
+        diagnosisActive && diagnosisRetryScaffold ? {
+            name: 'diagnosis_retry_scaffold',
+            text: JSON.stringify(diagnosisRetryScaffold, null, 2)
+        } : undefined,
         diagnosisActive && similarCaseHintsText ? {
             name: 'similar_accepted_fix_hints',
             text: similarCaseHintsText
@@ -6771,7 +7205,7 @@ function buildResolveIOSupportV5MicrotaskPrompt(input) {
     };
 }
 function summarizeResolveIOSupportV5MicrotaskUsage(bundle) {
-    var e_13, _a, e_14, _b;
+    var e_17, _a, e_18, _b;
     var byMicrotask = new Map();
     var bySection = new Map();
     var totalPromptTokenEstimate = 0;
@@ -6786,17 +7220,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_18 = 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_18_1) { e_18 = { error: e_18_1 }; }
             finally {
                 try {
                     if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
                 }
-                finally { if (e_14) throw e_14.error; }
+                finally { if (e_18) throw e_18.error; }
             }
             var hardCap = usage.lane === 'qa' ? promptBudget.qaMicrotaskHardCap : promptBudget.buildMicrotaskHardCap;
             if ((usage.promptTokenEstimate || 0) > hardCap) {
@@ -6804,12 +7238,12 @@ function summarizeResolveIOSupportV5MicrotaskUsage(bundle) {
             }
         }
     }
-    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+    catch (e_17_1) { e_17 = { error: e_17_1 }; }
     finally {
         try {
             if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
         }
-        finally { if (e_13) throw e_13.error; }
+        finally { if (e_17) throw e_17.error; }
     }
     return {
         totalPromptTokenEstimate: totalPromptTokenEstimate,