@resolveio/server-lib 22.3.127 → 22.3.129

package/util/support-runner-v5.js

@@ -47,6 +47,14 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeResolveIOSupportDiagnosisGate = normalizeResolveIOSupportDiagnosisGate;
+exports.extractResolveIOSupportDiagnosisGateFromText = extractResolveIOSupportDiagnosisGateFromText;
+exports.validateResolveIOSupportDiagnosisGate = validateResolveIOSupportDiagnosisGate;
+exports.buildResolveIOSupportIssueClassProbes = buildResolveIOSupportIssueClassProbes;
+exports.hashResolveIOSupportV5Evidence = hashResolveIOSupportV5Evidence;
+exports.decideResolveIOSupportV5RepeatedFailureStop = decideResolveIOSupportV5RepeatedFailureStop;
+exports.changedFilesOutsideResolveIOSupportDiagnosisOwnerFiles = changedFilesOutsideResolveIOSupportDiagnosisOwnerFiles;
+exports.applyResolveIOSupportDiagnosisGateToMicrotasks = applyResolveIOSupportDiagnosisGateToMicrotasks;
 exports.fingerprintResolveIOSupportV5Blocker = fingerprintResolveIOSupportV5Blocker;
 exports.buildResolveIOSupportV5Budget = buildResolveIOSupportV5Budget;
 exports.buildResolveIOSupportV5PromptBudget = buildResolveIOSupportV5PromptBudget;
@@ -61,6 +69,7 @@ exports.buildResolveIOSupportV5DiagnoseFirstPrompt = buildResolveIOSupportV5Diag
 exports.buildResolveIOSupportV5MicrotaskPrompt = buildResolveIOSupportV5MicrotaskPrompt;
 exports.summarizeResolveIOSupportV5MicrotaskUsage = summarizeResolveIOSupportV5MicrotaskUsage;
 exports.buildResolveIOSupportV5Incident = buildResolveIOSupportV5Incident;
+var ai_runner_manager_policy_1 = require("./ai-runner-manager-policy");
 function isoNow(value) {
     if (value instanceof Date) {
         return value.toISOString();
@@ -104,6 +113,518 @@ function cleanList(values, limit, max) {
     }
     return result;
 }
+function cleanObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function pickText(source, fields, max) {
+    var e_2, _a;
+    if (max === void 0) { max = 1000; }
+    try {
+        for (var fields_1 = __values(fields), fields_1_1 = fields_1.next(); !fields_1_1.done; fields_1_1 = fields_1.next()) {
+            var field = fields_1_1.value;
+            var normalized = cleanText(source === null || source === void 0 ? void 0 : source[field], max);
+            if (normalized) {
+                return normalized;
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (fields_1_1 && !fields_1_1.done && (_a = fields_1.return)) _a.call(fields_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return '';
+}
+function normalizeIssueClass(value) {
+    var normalized = cleanText(value, 80)
+        .toLowerCase()
+        .replace(/[\s-]+/g, '_');
+    var aliases = {
+        no_op: 'no_op_submit',
+        no_op_submit: 'no_op_submit',
+        submit_noop: 'no_op_submit',
+        missing_data: 'missing_wrong_data',
+        wrong_data: 'missing_wrong_data',
+        missing_wrong_data: 'missing_wrong_data',
+        filter_mismatch: 'filter_query_mismatch',
+        query_mismatch: 'filter_query_mismatch',
+        filter_query_mismatch: 'filter_query_mismatch',
+        invoice_pdf_export: 'invoice_pdf_export',
+        pdf_export: 'invoice_pdf_export',
+        export: 'invoice_pdf_export',
+        upload: 'upload_import',
+        import: 'upload_import',
+        upload_import: 'upload_import',
+        route_auth: 'route_auth_hydration',
+        auth_hydration: 'route_auth_hydration',
+        route_auth_hydration: 'route_auth_hydration',
+        slow_query: 'slow_query_performance',
+        performance: 'slow_query_performance',
+        slow_query_performance: 'slow_query_performance'
+    };
+    return aliases[normalized] || '';
+}
+function normalizeReproductionStatus(value) {
+    var normalized = cleanText(value, 80).toLowerCase();
+    if (/blocked|unable|cannot/.test(normalized)) {
+        return 'blocked';
+    }
+    if (/classif|triag|inferred/.test(normalized)) {
+        return 'classified';
+    }
+    return 'reproduced';
+}
+function normalizeSupportDiagnosisEvidence(values) {
+    var allowed = new Set(['ticket', 'browser', 'mongo', 'log', 'code', 'commit', 'qa', 'other']);
+    if (!Array.isArray(values)) {
+        var summary = cleanText(values, 1200);
+        return summary ? [{ type: 'other', summary: summary }] : [];
+    }
+    var stringEvidence = values
+        .filter(function (entry) { return typeof entry === 'string'; })
+        .map(function (entry) { return ({
+        type: 'other',
+        summary: cleanText(entry, 1200)
+    }); });
+    var objectEvidence = values
+        .filter(function (entry) { return entry && typeof entry === 'object' && !Array.isArray(entry); })
+        .map(function (entry) {
+        var type = cleanText(entry.type, 80).toLowerCase();
+        return {
+            type: (allowed.has(type) ? type : 'other'),
+            summary: cleanText(entry.summary || entry.message || entry.evidence || entry.reason, 1200),
+            artifactPath: cleanText(entry.artifactPath || entry.path || entry.file, 500)
+        };
+    });
+    return stringEvidence.concat(objectEvidence)
+        .filter(function (entry) { return entry.summary; })
+        .slice(0, 20);
+}
+function normalizeSupportDiagnosisHints(values) {
+    return (Array.isArray(values) ? values : [])
+        .map(function (entry) {
+        if (typeof entry === 'string') {
+            return { reason: cleanText(entry, 500) };
+        }
+        var value = cleanObject(entry);
+        return {
+            id: cleanText(value.id || value._id, 160),
+            ticketNumber: cleanText(value.ticketNumber || value.ticket_number || value.sourceTicketNumber, 80),
+            title: cleanText(value.title || value.summary, 300),
+            outcome: cleanText(value.outcome || value.status, 80),
+            issueClass: cleanText(value.issueClass || value.issue_class, 80),
+            ownerFiles: cleanList(value.ownerFiles || value.owner_files || value.files, 8, 240),
+            commitSha: cleanText(value.commitSha || value.commit_sha, 80),
+            commitMessage: cleanText(value.commitMessage || value.commit_message, 300),
+            reason: cleanText(value.reason || value.matchReason || value.match_reason, 500)
+        };
+    })
+        .filter(function (entry) { return entry.id || entry.ticketNumber || entry.title || entry.reason || entry.commitSha; })
+        .slice(0, 8);
+}
+function normalizeOwnerFilePath(value) {
+    return cleanText(value, 500)
+        .replace(/\\/g, '/')
+        .replace(/^\.\/+/, '')
+        .replace(/^\/+/, '')
+        .replace(/\s+$/g, '');
+}
+function ownerFileLooksBroad(value) {
+    var normalized = normalizeOwnerFilePath(value);
+    return !normalized
+        || normalized.includes('*')
+        || normalized.endsWith('/')
+        || !/\.[a-z0-9]+$/i.test(normalized)
+        || /^(\.|src|server|angular|client|app|lib|packages?)$/i.test(normalized)
+        || /(^|\/)(node_modules|dist|build|coverage|\.git)(\/|$)/i.test(normalized);
+}
+function normalizeResolveIOSupportDiagnosisGate(value, now) {
+    var source = cleanObject(value);
+    if (!Object.keys(source).length) {
+        return undefined;
+    }
+    var issueCaseSource = cleanObject(source.issue_case || source.issueCase);
+    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 issueClass = normalizeIssueClass(source.issue_class || source.issueClass);
+    var ownerFiles = cleanList(source.owner_files || source.ownerFiles, 20, 500)
+        .map(normalizeOwnerFilePath)
+        .filter(Boolean);
+    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),
+            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)
+        },
+        rejected_alternatives: cleanList(source.rejected_alternatives || source.rejectedAlternatives, 10, 700),
+        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)
+        },
+        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),
+            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)
+        },
+        similar_tickets: normalizeSupportDiagnosisHints(source.similar_tickets || source.similarTickets),
+        similar_commits: normalizeSupportDiagnosisHints(source.similar_commits || source.similarCommits),
+        evidence: normalizeSupportDiagnosisEvidence(source.evidence),
+        status: cleanText(source.status, 80).toLowerCase() || 'incomplete',
+        updatedAt: isoNow(now || source.updatedAt || source.updated_at)
+    };
+    if (!['missing', 'incomplete', 'blocked', 'passed'].includes(gate.status)) {
+        gate.status = 'incomplete';
+    }
+    return gate;
+}
+function extractResolveIOSupportDiagnosisGateFromText(value, now) {
+    var e_3, _a;
+    var text = String(value || '').trim();
+    if (!text) {
+        return undefined;
+    }
+    var candidates = [];
+    var fenced = Array.from(text.matchAll(/```(?:json)?\s*([\s\S]*?)```/gi)).map(function (match) { return match[1]; });
+    candidates.push.apply(candidates, __spreadArray([], __read(fenced), false));
+    var jsonBlock = text.match(/\{[\s\S]*\}/);
+    if (jsonBlock) {
+        candidates.push(jsonBlock[0]);
+    }
+    try {
+        for (var candidates_1 = __values(candidates), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {
+            var candidate = candidates_1_1.value;
+            try {
+                var parsed = JSON.parse(candidate);
+                var wrapped = (parsed === null || parsed === void 0 ? void 0 : parsed.support_diagnosis_gate) || (parsed === null || parsed === void 0 ? void 0 : parsed.supportDiagnosisGate) || (parsed === null || parsed === void 0 ? void 0 : parsed.diagnosis_gate) || (parsed === null || parsed === void 0 ? void 0 : parsed.diagnosisGate) || parsed;
+                var normalized = normalizeResolveIOSupportDiagnosisGate(wrapped, now);
+                if (normalized) {
+                    return normalized;
+                }
+            }
+            catch (_b) {
+                // Continue trying less exact JSON candidates.
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (candidates_1_1 && !candidates_1_1.done && (_a = candidates_1.return)) _a.call(candidates_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return undefined;
+}
+function validateResolveIOSupportDiagnosisGate(value, options) {
+    if (options === void 0) { options = {}; }
+    var normalized = normalizeResolveIOSupportDiagnosisGate(value);
+    if (!normalized) {
+        return { valid: false, status: 'missing', blockers: ['SupportDiagnosisGate is missing.'] };
+    }
+    var blockers = [];
+    var maxOwnerFiles = Math.max(1, Number(options.maxOwnerFiles || 8) || 8);
+    if (!normalized.issue_case.customer_complaint) {
+        blockers.push('Diagnosis issue_case.customer_complaint is required.');
+    }
+    if (!normalized.issue_case.expected_result) {
+        blockers.push('Diagnosis issue_case.expected_result is required.');
+    }
+    if (!normalized.issue_case.observed_result) {
+        blockers.push('Diagnosis issue_case.observed_result is required.');
+    }
+    if (!normalized.issue_case.route_module) {
+        blockers.push('Diagnosis issue_case.route_module is required.');
+    }
+    if (!normalized.issue_case.account_customer_context) {
+        blockers.push('Diagnosis issue_case.account_customer_context is required.');
+    }
+    if (normalized.issue_case.reproduction_status === 'blocked' && !normalized.issue_case.reproduction_blocker) {
+        blockers.push('Diagnosis blocked reproduction requires issue_case.reproduction_blocker.');
+    }
+    if (!normalizeIssueClass(normalized.issue_class)) {
+        blockers.push('Diagnosis issue_class must be one of the supported issue-class probes.');
+    }
+    if (!normalized.accepted_hypothesis.statement) {
+        blockers.push('Diagnosis accepted_hypothesis.statement is required.');
+    }
+    if (!normalized.accepted_hypothesis.falsifiable_test) {
+        blockers.push('Diagnosis accepted_hypothesis.falsifiable_test is required.');
+    }
+    if (!normalized.accepted_hypothesis.evidence.length) {
+        blockers.push('Diagnosis accepted_hypothesis.evidence must cite proof.');
+    }
+    if (!normalized.rejected_alternatives.length) {
+        blockers.push('Diagnosis rejected_alternatives must include at least one rejected theory.');
+    }
+    if (!normalized.failing_path.description
+        && !normalized.failing_path.frontend
+        && !normalized.failing_path.backend
+        && !normalized.failing_path.shared_library
+        && !normalized.failing_path.data_query) {
+        blockers.push('Diagnosis failing_path must identify frontend, backend, query, shared library, or path description.');
+    }
+    if (!normalized.owner_files.length) {
+        blockers.push('Diagnosis owner_files must contain the small editable file set.');
+    }
+    if (normalized.owner_files.length > maxOwnerFiles) {
+        blockers.push("Diagnosis owner_files has ".concat(normalized.owner_files.length, " entries; maximum is ").concat(maxOwnerFiles, "."));
+    }
+    var broadFiles = normalized.owner_files.filter(ownerFileLooksBroad);
+    if (broadFiles.length) {
+        blockers.push("Diagnosis owner_files contains broad or unsafe path(s): ".concat(broadFiles.join(', '), "."));
+    }
+    if (!normalized.proof_plan.before && !normalized.proof_plan.before_state_unavailable_reason) {
+        blockers.push('Diagnosis proof_plan.before is required unless proof_plan.before_state_unavailable_reason explains why before-state proof is impossible.');
+    }
+    if (!normalized.proof_plan.action) {
+        blockers.push('Diagnosis proof_plan.action is required.');
+    }
+    if (!normalized.proof_plan.after) {
+        blockers.push('Diagnosis proof_plan.after is required.');
+    }
+    if (!normalized.proof_plan.business_assertion) {
+        blockers.push('Diagnosis proof_plan.business_assertion is required.');
+    }
+    if (!normalized.evidence.length) {
+        blockers.push('Diagnosis evidence must include ticket/code/browser/log/Mongo proof.');
+    }
+    normalized.status = blockers.length ? 'incomplete' : 'passed';
+    return {
+        valid: blockers.length === 0,
+        status: normalized.status,
+        blockers: blockers,
+        normalized: normalized
+    };
+}
+function buildResolveIOSupportIssueClassProbes(value) {
+    var validation = validateResolveIOSupportDiagnosisGate(value);
+    var gate = validation.normalized || normalizeResolveIOSupportDiagnosisGate(value);
+    if (!gate) {
+        return [];
+    }
+    var route = gate.proof_plan.route || gate.issue_case.route_module;
+    var proof = gate.proof_plan.business_assertion;
+    var common = {
+        issue_class: gate.issue_class,
+        probe_type: 'issue_class_probe',
+        route: route,
+        blocks_acceptance_without_business_assertion: true
+    };
+    var map = {
+        no_op_submit: {
+            action: "Submit the customer action on ".concat(route || 'the affected screen', " and assert a persisted state change or explicit validation message."),
+            expected: proof || 'Before/action/after proof shows the submit is no longer a no-op.'
+        },
+        missing_wrong_data: {
+            action: "Load the named record/list on ".concat(route || 'the affected route', " and compare visible data to the expected persisted source."),
+            expected: proof || 'Visible data and persisted data match the customer expectation.'
+        },
+        filter_query_mismatch: {
+            action: 'Apply the reported filter/query inputs and assert the returned rows/counts match the expected dataset.',
+            expected: proof || 'Filter/query output contains the correct included rows and excludes the wrong rows.'
+        },
+        invoice_pdf_export: {
+            action: 'Generate the invoice/PDF/export from the affected route and inspect the downloaded/generated artifact.',
+            expected: proof || 'Generated artifact contains the expected customer-visible rows, totals, or fields.'
+        },
+        upload_import: {
+            action: 'Run the upload/import workflow with a representative file and assert parsed plus persisted results.',
+            expected: proof || 'Import shows a success result and persisted rows/counts changed as expected.'
+        },
+        route_auth_hydration: {
+            action: 'Open the route as the affected user and assert authenticated hydration reaches the functional screen, not a shell.',
+            expected: proof || 'Route hydrates with the required controls/data for the affected account.'
+        },
+        slow_query_performance: {
+            action: 'Run the reported query/workflow with timing/log evidence before and after the fix.',
+            expected: proof || 'Performance evidence shows the slow path improved without changing results.'
+        }
+    };
+    var selected = map[gate.issue_class];
+    return [__assign(__assign({}, common), { objective: "Issue-class probe for ".concat(gate.issue_class, ": ").concat(gate.issue_case.customer_complaint), action: selected.action, expected_evidence: selected.expected })];
+}
+function hashResolveIOSupportV5Evidence(value) {
+    var raw = typeof value === 'string' ? value : JSON.stringify(value || {});
+    var normalized = cleanText(raw, 8000)
+        .toLowerCase()
+        .replace(/[a-f0-9]{16,}/g, '<id>')
+        .replace(/\b\d{2,}\b/g, '<n>');
+    var hash = 0;
+    for (var index = 0; index < normalized.length; index += 1) {
+        hash = ((hash << 5) - hash + normalized.charCodeAt(index)) | 0;
+    }
+    return "ev-".concat(Math.abs(hash).toString(36) || '0');
+}
+function decideResolveIOSupportV5RepeatedFailureStop(input) {
+    var failureClass = cleanText(input.failureClass || 'unknown', 80).toLowerCase();
+    var blockerFingerprint = fingerprintResolveIOSupportV5Blocker(input.blocker || '');
+    var evidenceHash = cleanText(input.evidenceHash, 80) || hashResolveIOSupportV5Evidence(input.evidence || input.blocker || '');
+    var limit = Math.max(1, Number(input.limit || 2) || 2);
+    var latestRecord = (input.history || [])[(input.history || []).length - 1];
+    var managerDecision = (0, ai_runner_manager_policy_1.decideResolveIOAIManagerPolicy)({
+        history: (input.history || []).map(function (entry) { return ({
+            outcome: entry.outcome,
+            lane: entry.lane,
+            stepType: entry.stepType,
+            failureClass: entry.failureClass,
+            blocker: entry.blocker || entry.summary,
+            blockerFingerprint: entry.blockerFingerprint,
+            evidenceHash: entry.evidenceHash,
+            changedFiles: entry.changedFiles,
+            artifactPaths: entry.artifactPaths,
+            summary: entry.summary,
+            recordedAt: entry.recordedAt
+        }); }),
+        current: {
+            outcome: 'needs_repair',
+            lane: latestRecord === null || latestRecord === void 0 ? void 0 : latestRecord.lane,
+            stepType: latestRecord === null || latestRecord === void 0 ? void 0 : latestRecord.stepType,
+            failureClass: failureClass,
+            blocker: input.blocker,
+            blockerFingerprint: blockerFingerprint,
+            evidenceHash: evidenceHash
+        },
+        maxSameFailureRepeats: limit,
+        maxPingPongTransitions: 3,
+        infraFailureClasses: input.ignoreInfra !== false ? ['infra', 'compile'] : []
+    });
+    if (managerDecision.action === 'retry_infra') {
+        return {
+            shouldStop: false,
+            repeatedCount: 0,
+            failureClass: failureClass,
+            blockerFingerprint: blockerFingerprint,
+            evidenceHash: evidenceHash,
+            reason: 'support_v5_infra_failures_do_not_count_as_product_repair_loops'
+        };
+    }
+    if (managerDecision.action === 'park_ping_pong') {
+        return {
+            shouldStop: true,
+            repeatedCount: managerDecision.pingPongCount,
+            failureClass: failureClass,
+            blockerFingerprint: blockerFingerprint,
+            evidenceHash: evidenceHash,
+            reason: 'support_v5_ping_pong_failure_loop'
+        };
+    }
+    if (managerDecision.action === 'park_repeated_failure') {
+        return {
+            shouldStop: true,
+            repeatedCount: managerDecision.sameFailureCount,
+            failureClass: failureClass,
+            blockerFingerprint: blockerFingerprint,
+            evidenceHash: evidenceHash,
+            reason: 'support_v5_same_failure_class_without_new_evidence'
+        };
+    }
+    var repeatedCount = 0;
+    for (var index = (input.history || []).length - 1; index >= 0; index -= 1) {
+        var item = input.history[index];
+        if (item.outcome === 'pass' || item.outcome === 'ready_for_merge') {
+            break;
+        }
+        var itemFailureClass = cleanText(item.failureClass || 'unknown', 80).toLowerCase();
+        var itemBlockerFingerprint = cleanText(item.blockerFingerprint, 80)
+            || fingerprintResolveIOSupportV5Blocker(item.blocker || item.summary || '');
+        var itemEvidenceHash = cleanText(item.evidenceHash, 80)
+            || hashResolveIOSupportV5Evidence(item.artifactPaths || item.blocker || item.summary || '');
+        if (itemFailureClass !== failureClass || itemBlockerFingerprint !== blockerFingerprint || itemEvidenceHash !== evidenceHash) {
+            break;
+        }
+        repeatedCount += 1;
+    }
+    return {
+        shouldStop: repeatedCount >= limit,
+        repeatedCount: repeatedCount,
+        failureClass: failureClass,
+        blockerFingerprint: blockerFingerprint,
+        evidenceHash: evidenceHash,
+        reason: repeatedCount >= limit
+            ? 'support_v5_same_failure_class_without_new_evidence'
+            : 'support_v5_retry_allowed_new_or_below_repeat_limit'
+    };
+}
+function changedFilesOutsideResolveIOSupportDiagnosisOwnerFiles(diagnosisGate, changedFiles, options) {
+    if (options === void 0) { options = {}; }
+    var validation = validateResolveIOSupportDiagnosisGate(diagnosisGate);
+    if (!validation.valid || !validation.normalized) {
+        return cleanList(changedFiles, 80, 500);
+    }
+    var owners = new Set(validation.normalized.owner_files.map(normalizeOwnerFilePath));
+    return cleanList(changedFiles, 120, 500)
+        .map(normalizeOwnerFilePath)
+        .filter(function (filePath) {
+        if (!filePath) {
+            return false;
+        }
+        if (owners.has(filePath)) {
+            return false;
+        }
+        if (options.allowTests && /(^|\/)(tests?|spec|__tests__)(\/|$)|\.(?:spec|test)\.[jt]sx?$/i.test(filePath)) {
+            return false;
+        }
+        return true;
+    });
+}
+function applyResolveIOSupportDiagnosisGateToMicrotasks(bundle, diagnosisGate) {
+    var validation = validateResolveIOSupportDiagnosisGate(diagnosisGate);
+    var gate = validation.normalized;
+    if (!gate) {
+        return bundle;
+    }
+    var ownerFiles = gate.owner_files;
+    var probes = buildResolveIOSupportIssueClassProbes(gate);
+    var now = isoNow();
+    var ledger = (bundle.supportV5MicrotaskLedger || []).map(function (task) {
+        var _a;
+        if (task.type === 'diagnosis_gate') {
+            return __assign(__assign({}, task), { status: validation.valid ? 'pass' : 'needs_repair', blocker: validation.valid ? '' : validation.blockers.join(' | '), updatedAt: now });
+        }
+        if (task.lane === 'build' && /repair|product_repair|build_repair/i.test(String(task.type || ''))) {
+            return __assign(__assign({}, task), { targetFiles: ownerFiles, contextRefs: Array.from(new Set(__spreadArray(__spreadArray([], __read((task.contextRefs || [])), false), ['supportV5DiagnosisGate', 'owner_files'], false))), selfGate: "Repair only the diagnosed owner files unless you revise the diagnosis with new evidence. Owner files: ".concat(ownerFiles.join(', '), "."), acceptanceProof: gate.proof_plan.business_assertion, dependsOn: Array.from(new Set(__spreadArray(__spreadArray([], __read((task.dependsOn || [])), false), [stableIdFromText('diagnosis', bundle.supportV5ScopeDigest || gate.issue_case.customer_complaint)], false))), updatedAt: now });
+        }
+        if (task.lane === 'qa' && task.type === 'qa_row') {
+            return __assign(__assign({}, task), { contextRefs: Array.from(new Set(__spreadArray(__spreadArray([], __read((task.contextRefs || [])), false), ['supportV5DiagnosisGate', 'proof_plan'], false))), selfGate: ((_a = probes[0]) === null || _a === void 0 ? void 0 : _a.action) || task.selfGate, acceptanceProof: gate.proof_plan.business_assertion || task.acceptanceProof, targetFiles: ownerFiles, updatedAt: now });
+        }
+        return task;
+    });
+    var nextActive = selectResolveIOSupportV5ActiveMicrotask(ledger, bundle.supportV5ActiveMicrotaskId);
+    return __assign(__assign({}, bundle), { supportV5DiagnosisGate: gate, supportV5MicrotaskLedger: ledger, supportV5ActiveMicrotaskId: nextActive === null || nextActive === void 0 ? void 0 : nextActive.microtaskId, supportV5LaneMemory: __assign(__assign({}, bundle.supportV5LaneMemory), { build: __assign(__assign({}, bundle.supportV5LaneMemory.build), { changedFiles: ownerFiles, scopeSummary: [
+                    bundle.supportV5LaneMemory.build.scopeSummary,
+                    "Diagnosis issue class: ".concat(gate.issue_class),
+                    "Accepted hypothesis: ".concat(gate.accepted_hypothesis.statement),
+                    "Owner files: ".concat(ownerFiles.join(', '))
+                ].filter(Boolean).join(' | '), updatedAt: now }), qa: __assign(__assign({}, bundle.supportV5LaneMemory.qa), { activeQaRow: {
+                    workflow: gate.proof_plan.business_assertion,
+                    route: gate.proof_plan.route || gate.issue_case.route_module,
+                    assertion: gate.proof_plan.after,
+                    status: 'pending'
+                }, updatedAt: now }) }) });
+}
 function stableIdFromText(prefix, value) {
     var text = cleanText(value, 2000).toLowerCase();
     var hash = 0;
@@ -166,7 +687,7 @@ function buildResolveIOSupportV5ScopeDigest(input) {
     return raw.slice(0, maxChars);
 }
 function buildResolveIOSupportV5MicrotaskLedger(input) {
-    var e_2, _a;
+    var e_4, _a;
     var existing = Array.isArray(input.existing) ? input.existing : [];
     var completedByObjective = new Map();
     try {
@@ -177,12 +698,12 @@ function buildResolveIOSupportV5MicrotaskLedger(input) {
             }
         }
     }
-    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
     finally {
         try {
             if (existing_1_1 && !existing_1_1.done && (_a = existing_1.return)) _a.call(existing_1);
         }
-        finally { if (e_2) throw e_2.error; }
+        finally { if (e_4) throw e_4.error; }
     }
     var now = isoNow(input.now);
     var requirements = cleanList(input.requirements, 30, 240);
@@ -190,6 +711,28 @@ function buildResolveIOSupportV5MicrotaskLedger(input) {
         ? requirements
         : cleanText(input.scopeDigest, 1000).split(/\s+\|\s+|\r?\n/g).map(function (line) { return line.trim(); }).filter(Boolean).slice(0, 12);
     var ledger = [];
+    var diagnosisObjective = "Root-cause-first diagnosis gate for: ".concat(cleanText(input.scopeDigest, 360) || 'support ticket');
+    var diagnosisId = stableIdFromText('diagnosis', diagnosisObjective);
+    var existingDiagnosis = existing.find(function (task) { return (task === null || task === void 0 ? void 0 : task.type) === 'diagnosis_gate' || (task === null || task === void 0 ? void 0 : task.microtaskId) === diagnosisId; });
+    ledger.push(existingDiagnosis && (existingDiagnosis.status === 'pass' || existingDiagnosis.status === 'parked') ? existingDiagnosis : {
+        microtaskId: diagnosisId,
+        lane: 'build',
+        type: 'diagnosis_gate',
+        status: (existingDiagnosis === null || existingDiagnosis === void 0 ? void 0 : existingDiagnosis.status) || 'pending',
+        objective: diagnosisObjective,
+        targetFiles: [],
+        contextRefs: ['scope_digest', 'support_context', 'similar_tickets', 'similar_commits'],
+        selfGate: 'Read-only diagnosis only: reproduce or explicitly classify the issue, accept one falsifiable root-cause hypothesis, reject alternatives, identify the failing path, cap owner_files, and define before/action/after business proof.',
+        acceptanceProof: 'Valid ResolveIOSupportDiagnosisGate JSON with issue_case, issue_class, accepted_hypothesis, rejected_alternatives, failing_path, owner_files, proof_plan, evidence, and status=passed.',
+        threadKey: input.buildThreadKey,
+        promptTokenEstimate: existingDiagnosis === null || existingDiagnosis === void 0 ? void 0 : existingDiagnosis.promptTokenEstimate,
+        attempts: (existingDiagnosis === null || existingDiagnosis === void 0 ? void 0 : existingDiagnosis.attempts) || 0,
+        dependsOn: [],
+        parentScopeId: stableIdFromText('scope', diagnosisObjective),
+        blocker: existingDiagnosis === null || existingDiagnosis === void 0 ? void 0 : existingDiagnosis.blocker,
+        createdAt: (existingDiagnosis === null || existingDiagnosis === void 0 ? void 0 : existingDiagnosis.createdAt) || now,
+        updatedAt: (existingDiagnosis === null || existingDiagnosis === void 0 ? void 0 : existingDiagnosis.updatedAt) || now
+    });
     sourceRequirements.forEach(function (requirement, index) {
         var objective = cleanText(requirement, 240);
         if (!objective) {
@@ -210,7 +753,7 @@ function buildResolveIOSupportV5MicrotaskLedger(input) {
             acceptanceProof: 'Concrete code/data proof for this behavior, with changed files listed.',
             threadKey: input.buildThreadKey,
             attempts: 0,
-            dependsOn: [],
+            dependsOn: [diagnosisId],
             parentScopeId: stableIdFromText('scope', objective),
             createdAt: now,
             updatedAt: now
@@ -227,7 +770,7 @@ function buildResolveIOSupportV5MicrotaskLedger(input) {
             acceptanceProof: 'QA matrix row pass with route/data assertion, screenshot/caption artifact, and persisted before/after row/count/value proof for data-changing workflows.',
             threadKey: input.qaThreadKey,
             attempts: 0,
-            dependsOn: [buildId],
+            dependsOn: [diagnosisId, buildId],
             parentScopeId: stableIdFromText('scope', objective),
             createdAt: now,
             updatedAt: now
@@ -248,7 +791,7 @@ function selectResolveIOSupportV5ActiveMicrotask(ledger, preferredId) {
         || ledger.find(function (task) { return task.status === 'blocked'; });
 }
 function initializeResolveIOSupportV5State(input) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
     var now = isoNow(input.now);
     var existing = input.existing || {};
     var existingSupervisor = existing.supportV5SupervisorState;
@@ -260,6 +803,8 @@ function initializeResolveIOSupportV5State(input) {
     var buildThreadKey = cleanText(input.buildThreadKey || ((_a = existingLaneMemory.build) === null || _a === void 0 ? void 0 : _a.threadKey) || "support:".concat(input.ticketId || input.jobId, ":job:").concat(input.jobId, ":build"), 240);
     var qaThreadKey = cleanText(input.qaThreadKey || ((_b = existingLaneMemory.qa) === null || _b === void 0 ? void 0 : _b.threadKey) || "support:".concat(input.ticketId || input.jobId, ":job:").concat(input.jobId, ":qa"), 240);
     var budget = buildResolveIOSupportV5Budget(existing.supportV5Budget);
+    var existingDiagnosisGate = normalizeResolveIOSupportDiagnosisGate(existing.supportV5DiagnosisGate);
+    var diagnosisValidation = validateResolveIOSupportDiagnosisGate(existingDiagnosisGate);
     var scopeDigest = cleanText(existing.supportV5ScopeDigest, 4000) || buildResolveIOSupportV5ScopeDigest({
         goal: (existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.currentGoal) || "Resolve support ticket ".concat(ticketLabel),
         approvedScope: scope,
@@ -274,7 +819,7 @@ function initializeResolveIOSupportV5State(input) {
         existing: existing.supportV5MicrotaskLedger
     });
     var activeMicrotask = selectResolveIOSupportV5ActiveMicrotask(ledger, existing.supportV5ActiveMicrotaskId);
-    return {
+    var initialized = {
         supportWorkflowVersion: 'v5',
         supportV5SupervisorState: {
             version: 'v5',
@@ -282,8 +827,8 @@ function initializeResolveIOSupportV5State(input) {
             currentGoal: (existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.currentGoal) || "Resolve support ticket ".concat(ticketLabel),
             approvedScope: (existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.approvedScope) || scope,
             prBranch: cleanText(input.prBranch || (existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.prBranch) || '', 240),
-            activeStep: (existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.activeStep) || 'compile_check',
-            activeBlocker: (existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.activeBlocker) || '',
+            activeStep: (existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.activeStep) || (diagnosisValidation.valid ? 'compile_check' : 'diagnosis_gate'),
+            activeBlocker: (existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.activeBlocker) || (diagnosisValidation.valid ? '' : 'SupportDiagnosisGate required before product-code repair.'),
             lastGoodCheckpoint: (existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.lastGoodCheckpoint) || 'v5_initialized',
             currentQaRow: existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.currentQaRow,
             processLease: input.processLease || (existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.processLease),
@@ -291,6 +836,7 @@ function initializeResolveIOSupportV5State(input) {
             noEmailUnlessApproved: true,
             updatedAt: now
         },
+        supportV5DiagnosisGate: diagnosisValidation.valid ? diagnosisValidation.normalized : existingDiagnosisGate,
         supportV5LaneMemory: {
             build: {
                 lane: 'build',
@@ -325,24 +871,49 @@ function initializeResolveIOSupportV5State(input) {
             ? existing.supportV5RunnerIncidents.slice(-80)
             : [],
         supportV5MicrotaskLedger: ledger,
-        supportV5ActiveMicrotaskId: activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.microtaskId,
+        supportV5ActiveMicrotaskId: diagnosisValidation.valid
+            ? activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.microtaskId
+            : ((_u = ledger.find(function (task) { return task.type === 'diagnosis_gate' && !['pass', 'parked'].includes(task.status); })) === null || _u === void 0 ? void 0 : _u.microtaskId) || (activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.microtaskId),
         supportV5ScopeDigest: scopeDigest,
         supportV5MicrotaskUsageHistory: Array.isArray(existing.supportV5MicrotaskUsageHistory)
             ? existing.supportV5MicrotaskUsageHistory.slice(-200)
+            : [],
+        supportV5FailureFingerprints: Array.isArray(existing.supportV5FailureFingerprints)
+            ? existing.supportV5FailureFingerprints.slice(-200)
             : []
     };
+    return diagnosisValidation.valid && diagnosisValidation.normalized
+        ? applyResolveIOSupportDiagnosisGateToMicrotasks(initialized, diagnosisValidation.normalized)
+        : initialized;
 }
 function recordResolveIOSupportV5Step(bundle, step) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     var now = isoNow(step.now);
     var promptTokens = Math.max(0, Number(step.promptTokenEstimate || 0) || 0);
     var runtimeMs = Math.max(0, Number(step.runtimeMs || 0) || 0);
     var microtaskId = cleanText(step.microtaskId || bundle.supportV5ActiveMicrotaskId, 160);
-    var record = __assign(__assign({}, (microtaskId ? { microtaskId: microtaskId } : {})), { stepType: step.stepType, outcome: step.outcome, lane: step.lane, model: cleanText(step.model, 80), threadKey: cleanText(step.threadKey, 240), promptTokenEstimate: promptTokens || undefined, runtimeMs: runtimeMs || undefined, summary: cleanText(step.summary || step.blocker || step.outcome, 1200), blocker: cleanText(step.blocker, 1200), changedFiles: cleanList(step.changedFiles, 80, 500), artifactPaths: cleanList(step.artifactPaths, 80, 500), recordedAt: now });
+    var normalizedDiagnosisGate = step.diagnosisGate
+        ? normalizeResolveIOSupportDiagnosisGate(step.diagnosisGate, now)
+        : undefined;
+    var blockerFingerprint = step.blocker || step.summary
+        ? fingerprintResolveIOSupportV5Blocker(step.blocker || step.summary || '')
+        : undefined;
+    var evidenceHash = cleanText(step.evidenceHash, 80)
+        || (((_a = step.artifactPaths) === null || _a === void 0 ? void 0 : _a.length) || step.blocker || step.summary
+            ? hashResolveIOSupportV5Evidence(((_b = step.artifactPaths) === null || _b === void 0 ? void 0 : _b.length) ? step.artifactPaths : "".concat(step.blocker || '', "\n").concat(step.summary || ''))
+            : (0, ai_runner_manager_policy_1.hashResolveIOAIManagerEvidence)({
+                failureClass: step.failureClass,
+                blocker: step.blocker,
+                summary: step.summary,
+                changedFiles: step.changedFiles,
+                artifactPaths: step.artifactPaths
+            }));
+    var record = __assign(__assign({}, (microtaskId ? { microtaskId: microtaskId } : {})), { stepType: step.stepType, outcome: step.outcome, lane: step.lane, model: cleanText(step.model, 80), threadKey: cleanText(step.threadKey, 240), promptTokenEstimate: promptTokens || undefined, runtimeMs: runtimeMs || undefined, summary: cleanText(step.summary || step.blocker || step.outcome, 1200), blocker: cleanText(step.blocker, 1200), changedFiles: cleanList(step.changedFiles, 80, 500), artifactPaths: cleanList(step.artifactPaths, 80, 500), diagnosisGate: normalizedDiagnosisGate, failureClass: cleanText(step.failureClass, 80) || undefined, blockerFingerprint: blockerFingerprint, evidenceHash: evidenceHash, recordedAt: now });
+    var diagnosisGate = normalizedDiagnosisGate || bundle.supportV5DiagnosisGate;
     var laneMemory = __assign({}, bundle.supportV5LaneMemory);
     if (step.lane === 'build' || step.lane === 'qa') {
         var previous = laneMemory[step.lane];
-        laneMemory[step.lane] = __assign(__assign({}, previous), { activeBlocker: record.blocker || previous.activeBlocker || '', activeQaRow: step.activeQaRow || previous.activeQaRow, changedFiles: ((_a = record.changedFiles) === null || _a === void 0 ? void 0 : _a.length) ? record.changedFiles : previous.changedFiles, artifactPaths: ((_b = record.artifactPaths) === null || _b === void 0 ? void 0 : _b.length) ? record.artifactPaths : previous.artifactPaths, latestPromptTokenEstimate: promptTokens || previous.latestPromptTokenEstimate, updatedAt: now });
+        laneMemory[step.lane] = __assign(__assign({}, previous), { activeBlocker: record.blocker || previous.activeBlocker || '', activeQaRow: step.activeQaRow || previous.activeQaRow, changedFiles: ((_c = record.changedFiles) === null || _c === void 0 ? void 0 : _c.length) ? record.changedFiles : previous.changedFiles, artifactPaths: ((_d = record.artifactPaths) === null || _d === void 0 ? void 0 : _d.length) ? record.artifactPaths : previous.artifactPaths, latestPromptTokenEstimate: promptTokens || previous.latestPromptTokenEstimate, updatedAt: now });
     }
     var supervisor = __assign(__assign({}, bundle.supportV5SupervisorState), { status: step.outcome === 'ready_for_merge' ? 'complete' : (step.outcome === 'park_manual' || step.outcome === 'budget_stop' ? 'parked' : 'active'), activeStep: step.stepType, activeBlocker: record.blocker || '', currentQaRow: step.activeQaRow || bundle.supportV5SupervisorState.currentQaRow, lastGoodCheckpoint: step.outcome === 'pass' || step.outcome === 'ready_for_merge'
             ? step.stepType
@@ -360,8 +931,37 @@ function recordResolveIOSupportV5Step(bundle, step) {
                     : 'in_progress';
         return __assign(__assign({}, task), { status: status, blocker: record.blocker || task.blocker, promptTokenEstimate: promptTokens || task.promptTokenEstimate, attempts: task.attempts + (step.outcome === 'pass' || step.outcome === 'ready_for_merge' ? 0 : 1), updatedAt: now });
     });
+    var failureFingerprint = record.failureClass && record.blockerFingerprint && record.evidenceHash
+        ? {
+            stepType: record.stepType,
+            failureClass: cleanText(record.failureClass, 80),
+            blockerFingerprint: record.blockerFingerprint,
+            evidenceHash: record.evidenceHash,
+            recordedAt: now
+        }
+        : undefined;
+    var managerDecision = (0, ai_runner_manager_policy_1.decideResolveIOAIManagerPolicy)({
+        history: __spreadArray(__spreadArray([], __read(bundle.supportV5StepHistory), false), [record], false),
+        current: record,
+        maxSameFailureRepeats: buildResolveIOSupportV5Budget(bundle.supportV5Budget).maxRepeatedNoProgress,
+        maxPingPongTransitions: 3,
+        infraFailureClasses: ['infra', 'compile']
+    });
+    var previousRecord = bundle.supportV5StepHistory[bundle.supportV5StepHistory.length - 1];
+    var nextLoopCount = managerDecision.loopBudgetShouldReset
+        || (previousRecord === null || previousRecord === void 0 ? void 0 : previousRecord.failureClass) !== record.failureClass
+        || (previousRecord === null || previousRecord === void 0 ? void 0 : previousRecord.blockerFingerprint) !== record.blockerFingerprint
+        || (previousRecord === null || previousRecord === void 0 ? void 0 : previousRecord.evidenceHash) !== record.evidenceHash
+        ? 1
+        : bundle.supportV5Budget.loopCount + 1;
     var nextMicrotask = selectResolveIOSupportV5ActiveMicrotask(ledger, bundle.supportV5ActiveMicrotaskId);
-    return __assign(__assign({}, bundle), { supportV5SupervisorState: supervisor, supportV5LaneMemory: laneMemory, supportV5StepHistory: __spreadArray(__spreadArray([], __read(bundle.supportV5StepHistory), false), [record], false).slice(-100), supportV5Budget: __assign(__assign({}, bundle.supportV5Budget), { totalPromptTokenEstimate: bundle.supportV5Budget.totalPromptTokenEstimate + promptTokens, totalRuntimeMs: bundle.supportV5Budget.totalRuntimeMs + runtimeMs, loopCount: bundle.supportV5Budget.loopCount + 1 }), supportV5MicrotaskLedger: ledger, supportV5ActiveMicrotaskId: nextMicrotask === null || nextMicrotask === void 0 ? void 0 : nextMicrotask.microtaskId, supportV5MicrotaskUsageHistory: bundle.supportV5MicrotaskUsageHistory || [] });
+    var nextBundle = __assign(__assign({}, bundle), { supportV5SupervisorState: supervisor, supportV5DiagnosisGate: diagnosisGate, supportV5LaneMemory: laneMemory, supportV5StepHistory: __spreadArray(__spreadArray([], __read(bundle.supportV5StepHistory), false), [record], false).slice(-100), supportV5Budget: __assign(__assign({}, bundle.supportV5Budget), { totalPromptTokenEstimate: bundle.supportV5Budget.totalPromptTokenEstimate + promptTokens, totalRuntimeMs: bundle.supportV5Budget.totalRuntimeMs + runtimeMs, loopCount: nextLoopCount }), supportV5MicrotaskLedger: ledger, supportV5ActiveMicrotaskId: nextMicrotask === null || nextMicrotask === void 0 ? void 0 : nextMicrotask.microtaskId, supportV5MicrotaskUsageHistory: bundle.supportV5MicrotaskUsageHistory || [], supportV5FailureFingerprints: failureFingerprint
+            ? __spreadArray(__spreadArray([], __read((bundle.supportV5FailureFingerprints || [])), false), [failureFingerprint], false).slice(-200)
+            : (bundle.supportV5FailureFingerprints || []) });
+    if (normalizedDiagnosisGate && validateResolveIOSupportDiagnosisGate(normalizedDiagnosisGate).valid) {
+        return applyResolveIOSupportDiagnosisGateToMicrotasks(nextBundle, normalizedDiagnosisGate);
+    }
+    return nextBundle;
 }
 function recordResolveIOSupportV5MicrotaskUsage(bundle, usage) {
     var record = __assign(__assign({}, usage), { microtaskId: cleanText(usage.microtaskId, 160), threadKey: cleanText(usage.threadKey, 240), model: cleanText(usage.model, 80), promptTokenEstimate: Math.max(0, Number(usage.promptTokenEstimate || 0) || 0), promptSections: Array.isArray(usage.promptSections)
@@ -400,6 +1000,14 @@ function decideResolveIOSupportV5Continuation(bundle) {
     }
     var budgetExceeded = budget.loopCount >= budget.maxLoopsPerTicket
         || ((last === null || last === void 0 ? void 0 : last.promptTokenEstimate) || 0) > budget.maxPromptTokensPerNonInitialStep;
+    var repeatedFailure = last ? decideResolveIOSupportV5RepeatedFailureStop({
+        history: history,
+        failureClass: last.failureClass,
+        blocker: last.blocker || last.summary,
+        evidenceHash: last.evidenceHash,
+        limit: budget.maxRepeatedNoProgress,
+        ignoreInfra: true
+    }) : null;
     if (budgetExceeded) {
         return {
             action: 'park',
@@ -418,6 +1026,15 @@ function decideResolveIOSupportV5Continuation(bundle) {
             budgetExceeded: budgetExceeded
         };
     }
+    if (repeatedFailure === null || repeatedFailure === void 0 ? void 0 : repeatedFailure.shouldStop) {
+        return {
+            action: 'park',
+            reason: repeatedFailure.reason,
+            nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || 'cleanup',
+            repeatedNoProgressCount: repeatedFailure.repeatedCount,
+            budgetExceeded: budgetExceeded
+        };
+    }
     return {
         action: 'continue',
         reason: 'support_v5_continue',
@@ -451,6 +1068,9 @@ function buildResolveIOSupportV5DiagnoseFirstPrompt(lines) {
 function buildResolveIOSupportV5MicrotaskPrompt(input) {
     var _a, _b, _c;
     var activeMicrotask = selectResolveIOSupportV5ActiveMicrotask(input.bundle.supportV5MicrotaskLedger || [], input.bundle.supportV5ActiveMicrotaskId);
+    var diagnosisValidation = validateResolveIOSupportDiagnosisGate(input.bundle.supportV5DiagnosisGate);
+    var diagnosisGate = diagnosisValidation.normalized || input.bundle.supportV5DiagnosisGate;
+    var diagnosisActive = (activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.type) === 'diagnosis_gate';
     var budget = buildResolveIOSupportV5PromptBudget();
     var repairLike = Boolean(input.failureText || (activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.status) === 'needs_repair' || /repair/i.test(String(input.stage || (activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.type) || '')));
     var cap = repairLike
@@ -469,7 +1089,9 @@ function buildResolveIOSupportV5MicrotaskPrompt(input) {
     var artifactPaths = cleanList(((_b = input.artifactPaths) === null || _b === void 0 ? void 0 : _b.length) ? input.artifactPaths : laneMemory.artifactPaths, 8, 200);
     var targetFiles = cleanList(((_c = input.targetFiles) === null || _c === void 0 ? void 0 : _c.length) ? input.targetFiles : activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.targetFiles, 5, 160);
     var contextSnippets = cleanList(input.contextSnippets, 5, 360);
-    var qaRow = input.activeQaRow || (activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.lane) === 'qa' ? input.activeQaRow || laneMemory.activeQaRow || input.bundle.supportV5SupervisorState.currentQaRow : undefined;
+    var qaRow = input.activeQaRow || (activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.lane) === 'qa'
+        ? input.activeQaRow || laneMemory.activeQaRow || input.bundle.supportV5SupervisorState.currentQaRow
+        : undefined;
     var sections = [
         {
             name: 'microtask_contract',
@@ -479,11 +1101,33 @@ function buildResolveIOSupportV5MicrotaskPrompt(input) {
                 'Do exactly one microtask and one proof gate. Do not replay ticket triage, prior plans, attachments, broad QA checklist, or unrelated scope.',
                 'If context is insufficient, request the smallest missing file/log/artifact by path and park this microtask; do not broaden the prompt.',
                 'Do not send customer email. Do not deploy. Do not spawn duplicate server/client/Mongo/browser/Codex processes.',
-                input.lane === 'qa'
-                    ? 'QA lane hard boundary: the platform preflight owns compile, dependency install, Mongo/server/client startup, and Angular startup. This lane owns only browser/data proof and QA artifacts unless the prompt explicitly says preflight was skipped.'
-                    : 'Build lane hard boundary: do not run `npm run build-dev`, `ng build`, `npm run server`, `npm run client`, `ng serve`, `run-local-qa.sh`, browser automation, or any watch/long-lived command. If a broad compile gate is needed, run only `npm run build-prod -- --watch=false`; otherwise use a targeted finite check or return the precise blocker.'
+                diagnosisActive
+                    ? 'Diagnosis gate hard boundary: read-only investigation only. Do not edit source, generated files, package files, tests, fixtures, QA artifacts, or local data. Return the diagnosis JSON contract only.'
+                    : input.lane === 'qa'
+                        ? 'QA lane hard boundary: the platform preflight owns compile, dependency install, Mongo/server/client startup, and Angular startup. This lane owns only browser/data proof and QA artifacts unless the prompt explicitly says preflight was skipped.'
+                        : 'Build lane hard boundary: do not run `npm run build-dev`, `ng build`, `npm run server`, `npm run client`, `ng serve`, `run-local-qa.sh`, browser automation, or any watch/long-lived command. If a broad compile gate is needed, run only `npm run build-prod -- --watch=false`; otherwise use a targeted finite check or return the precise blocker.'
             ].join('\n')
         },
+        diagnosisActive ? {
+            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":""},"similar_tickets":[],"similar_commits":[],"evidence":[{"type":"ticket|browser|mongo|log|code|commit|qa|other","summary":"","artifactPath":""}],"status":"passed"}}',
+                '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.',
+                'The proof plan must be before/action/after business proof. If before-state proof is impossible, explain exactly why in before_state_unavailable_reason.'
+            ].join('\n')
+        } : {
+            name: 'diagnosis_gate_context',
+            text: diagnosisValidation.valid && diagnosisGate ? [
+                "Diagnosis issue class: ".concat(diagnosisGate.issue_class),
+                "Accepted hypothesis: ".concat(diagnosisGate.accepted_hypothesis.statement),
+                "Failing path: ".concat(diagnosisGate.failing_path.description || diagnosisGate.failing_path.frontend || diagnosisGate.failing_path.backend || ''),
+                "Owner files: ".concat(diagnosisGate.owner_files.join(', ')),
+                "Business proof required: ".concat(diagnosisGate.proof_plan.business_assertion),
+                "Before/action/after: ".concat(diagnosisGate.proof_plan.before || diagnosisGate.proof_plan.before_state_unavailable_reason, " -> ").concat(diagnosisGate.proof_plan.action, " -> ").concat(diagnosisGate.proof_plan.after)
+            ].filter(Boolean).join('\n') : 'SupportDiagnosisGate is not valid. Park instead of editing product code.'
+        },
         {
             name: 'scope_digest',
             text: cleanText(input.bundle.supportV5ScopeDigest || input.bundle.supportV5SupervisorState.approvedScope, 900)
@@ -542,9 +1186,11 @@ function buildResolveIOSupportV5MicrotaskPrompt(input) {
         },
         {
             name: 'return_contract',
-            text: input.lane === 'qa'
-                ? 'Return strict JSON only: {"status":"pass"|"needs-fix"|"blocked","microtaskId":"","summary":"","evidence":[""],"artifacts":[""],"next_actions":[""]}.'
-                : 'Return concise Markdown with: Microtask Result, Root Cause, Changes, Self-Gate, Acceptance Proof, Residual Risk.'
+            text: diagnosisActive
+                ? 'Return strict JSON only with support_diagnosis_gate. Do not include Markdown and do not edit files.'
+                : input.lane === 'qa'
+                    ? 'Return strict JSON only: {"status":"pass"|"needs-fix"|"blocked","microtaskId":"","summary":"","evidence":[""],"artifacts":[""],"next_actions":[""]}.'
+                    : 'Return concise Markdown with: Microtask Result, Root Cause, Changes, Self-Gate, Acceptance Proof, Residual Risk.'
         }
     ].filter(function (section) { return cleanText(section.text, 20); });
     var promptSections = sections.map(function (section) { return ({
@@ -570,7 +1216,7 @@ function buildResolveIOSupportV5MicrotaskPrompt(input) {
     };
 }
 function summarizeResolveIOSupportV5MicrotaskUsage(bundle) {
-    var e_3, _a, e_4, _b;
+    var e_5, _a, e_6, _b;
     var byMicrotask = new Map();
     var bySection = new Map();
     var totalPromptTokenEstimate = 0;
@@ -585,17 +1231,17 @@ function summarizeResolveIOSupportV5MicrotaskUsage(bundle) {
             existing.calls += 1;
             byMicrotask.set(usage.microtaskId, existing);
             try {
-                for (var _e = (e_4 = void 0, __values(usage.promptSections || [])), _f = _e.next(); !_f.done; _f = _e.next()) {
+                for (var _e = (e_6 = 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_4_1) { e_4 = { error: e_4_1 }; }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
             finally {
                 try {
                     if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
                 }
-                finally { if (e_4) throw e_4.error; }
+                finally { if (e_6) throw e_6.error; }
             }
             var hardCap = usage.lane === 'qa' ? promptBudget.qaMicrotaskHardCap : promptBudget.buildMicrotaskHardCap;
             if ((usage.promptTokenEstimate || 0) > hardCap) {
@@ -603,12 +1249,12 @@ function summarizeResolveIOSupportV5MicrotaskUsage(bundle) {
             }
         }
     }
-    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
     finally {
         try {
             if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
         }
-        finally { if (e_3) throw e_3.error; }
+        finally { if (e_5) throw e_5.error; }
     }
     return {
         totalPromptTokenEstimate: totalPromptTokenEstimate,