@resolveio/server-lib 22.3.158 → 22.3.159

package/util/support-runner-v5.js

@@ -47,14 +47,17 @@ 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.selectResolveIOSupportSimilarCaseHints = selectResolveIOSupportSimilarCaseHints;
 exports.evaluateResolveIOSupportDiagnosisEvidenceQuality = evaluateResolveIOSupportDiagnosisEvidenceQuality;
 exports.normalizeResolveIOSupportDiagnosisGate = normalizeResolveIOSupportDiagnosisGate;
 exports.extractResolveIOSupportDiagnosisGateFromText = extractResolveIOSupportDiagnosisGateFromText;
 exports.validateResolveIOSupportDiagnosisGate = validateResolveIOSupportDiagnosisGate;
+exports.evaluateResolveIOSupportBusinessProofReadiness = evaluateResolveIOSupportBusinessProofReadiness;
 exports.decideResolveIOSupportCustomerReplyPolicy = decideResolveIOSupportCustomerReplyPolicy;
 exports.buildResolveIOSupportIssueClassProbes = buildResolveIOSupportIssueClassProbes;
 exports.hashResolveIOSupportV5Evidence = hashResolveIOSupportV5Evidence;
 exports.decideResolveIOSupportV5RepeatedFailureStop = decideResolveIOSupportV5RepeatedFailureStop;
+exports.evaluateResolveIOSupportEvidenceFreshness = evaluateResolveIOSupportEvidenceFreshness;
 exports.changedFilesOutsideResolveIOSupportDiagnosisOwnerFiles = changedFilesOutsideResolveIOSupportDiagnosisOwnerFiles;
 exports.decideResolveIOSupportV5RepairGate = decideResolveIOSupportV5RepairGate;
 exports.applyResolveIOSupportDiagnosisGateToMicrotasks = applyResolveIOSupportDiagnosisGateToMicrotasks;
@@ -228,6 +231,199 @@ function normalizeSupportDiagnosisHints(values) {
         .filter(function (entry) { return entry.id || entry.ticketNumber || entry.title || entry.reason || entry.commitSha; })
         .slice(0, 8);
 }
+function normalizeSupportSimilarCaseSource(value) {
+    var normalized = cleanText(value, 80).toLowerCase();
+    if (/commit|git/.test(normalized)) {
+        return 'git_commit';
+    }
+    if (/ticket/.test(normalized)) {
+        return 'support_ticket';
+    }
+    if (/airun|ai_run|run/.test(normalized)) {
+        return 'airun';
+    }
+    return 'manual';
+}
+function supportOutcomeLooksAccepted(value) {
+    return /^(accepted|pass|passed|complete|completed|merged|released)$/i.test(cleanText(value, 80));
+}
+function supportOutcomeLooksRejected(value) {
+    return /\b(reject|rejected|false_pass|failed|failure|blocked|unknown|stopped|manual_handoff)\b/i.test(cleanText(value, 120));
+}
+function supportOwnerFileDirectory(value) {
+    var normalized = normalizeOwnerFilePath(value);
+    var parts = normalized.split('/').filter(Boolean);
+    return parts.length > 1 ? parts.slice(0, -1).join('/') : normalized;
+}
+function supportTextTokens(value) {
+    var stop = new Set(['the', 'and', 'for', 'with', 'that', 'this', 'from', 'into', 'when', 'where', 'what', 'have', 'has', 'had', 'not', 'but', 'are', 'was', 'were', 'issue', 'ticket', 'support']);
+    return Array.from(new Set(cleanText(value, 3000).toLowerCase()
+        .split(/[^a-z0-9_/-]+/g)
+        .map(function (token) { return token.trim(); })
+        .filter(function (token) { return token.length >= 3 && !stop.has(token); })))
+        .slice(0, 80);
+}
+function normalizeResolveIOSupportSimilarCaseCandidate(value) {
+    var _a, _b;
+    var source = cleanObject(value);
+    if (!Object.keys(source).length && typeof value !== 'string') {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        var summary = cleanText(value, 500);
+        return summary ? {
+            source: 'manual',
+            title: summary,
+            summary: summary,
+            keywords: supportTextTokens(summary)
+        } : undefined;
+    }
+    var metadata = cleanObject(source.metadata);
+    var runSourceIds = cleanObject(source.sourceIds || source.source_ids || metadata.sourceIds || metadata.source_ids);
+    var diagnosis = cleanObject(source.diagnosisGate || source.diagnosis_gate || source.supportV5DiagnosisGate || source.support_v5_diagnosis_gate || metadata.diagnosisGate || metadata.diagnosis_gate);
+    var sourceIds = cleanObject(source.sourceIds || source.source_ids || metadata.sourceIds || metadata.source_ids);
+    var sourceText = [
+        source.title,
+        source.summary,
+        source.message,
+        source.description,
+        source.reason,
+        source.commitMessage,
+        source.commit_message,
+        (_a = diagnosis.issue_case) === null || _a === void 0 ? void 0 : _a.customer_complaint,
+        (_b = diagnosis.accepted_hypothesis) === null || _b === void 0 ? void 0 : _b.statement
+    ].filter(Boolean).join(' ');
+    var ownerFiles = cleanList(source.ownerFiles
+        || source.owner_files
+        || source.files
+        || diagnosis.owner_files
+        || diagnosis.ownerFiles
+        || metadata.ownerFiles
+        || metadata.owner_files, 12, 300).map(normalizeOwnerFilePath).filter(Boolean);
+    var issueClass = cleanText(source.issueClass
+        || source.issue_class
+        || diagnosis.issue_class
+        || diagnosis.issueClass
+        || metadata.issueClass
+        || metadata.issue_class, 80);
+    var candidate = {
+        source: normalizeSupportSimilarCaseSource(source.source || source.type || source.runSource),
+        id: cleanText(source.id || source._id || source.runId || source.run_id, 160),
+        ticketNumber: cleanText(source.ticketNumber || source.ticket_number || source.sourceTicketNumber || sourceIds.ticketNumber || runSourceIds.ticketNumber, 80),
+        title: cleanText(source.title || source.name || source.summary, 300),
+        outcome: cleanText(source.outcome || source.status || source.outcomeLabel || source.outcome_label, 80),
+        issueClass: normalizeIssueClass(issueClass) || cleanText(issueClass, 80),
+        ownerFiles: ownerFiles,
+        commitSha: cleanText(source.commitSha || source.commit_sha || source.sha || source.sourceCommitSha || source.source_commit_sha, 80),
+        commitMessage: cleanText(source.commitMessage || source.commit_message || source.message, 300),
+        reason: cleanText(source.reason || source.matchReason || source.match_reason, 500),
+        summary: cleanText(source.summary || source.description || source.message || sourceText, 800),
+        keywords: cleanList(source.keywords || source.tags, 20, 80).concat(supportTextTokens(sourceText)).slice(0, 40),
+        updatedAt: isoNow(source.updatedAt || source.updated_at || source.recordedAt || source.recorded_at || source.createdAt || source.created_at),
+        metadata: metadata
+    };
+    if (!candidate.id && !candidate.ticketNumber && !candidate.title && !candidate.commitSha && !candidate.summary) {
+        return undefined;
+    }
+    if (candidate.commitSha && candidate.source === 'manual') {
+        candidate.source = 'git_commit';
+    }
+    if (candidate.ticketNumber && candidate.source === 'manual') {
+        candidate.source = 'support_ticket';
+    }
+    return candidate;
+}
+function selectResolveIOSupportSimilarCaseHints(input) {
+    var e_3, _a;
+    if (input === void 0) { input = {}; }
+    var issueClass = normalizeIssueClass(input.issueClass);
+    var ownerFiles = cleanList(input.ownerFiles, 12, 300).map(normalizeOwnerFilePath).filter(Boolean);
+    var ownerFileSet = new Set(ownerFiles);
+    var ownerDirs = new Set(ownerFiles.map(supportOwnerFileDirectory).filter(Boolean));
+    var textTokens = new Set(supportTextTokens(input.text));
+    var limit = Math.max(1, Math.min(12, Number(input.limit || 6)));
+    var normalized = (Array.isArray(input.candidates) ? input.candidates : [])
+        .map(normalizeResolveIOSupportSimilarCaseCandidate)
+        .filter(function (candidate) { return !!candidate; });
+    var ranked = [];
+    var ignoredCount = 0;
+    try {
+        for (var normalized_1 = __values(normalized), normalized_1_1 = normalized_1.next(); !normalized_1_1.done; normalized_1_1 = normalized_1.next()) {
+            var candidate = normalized_1_1.value;
+            var outcomeKnown = !!candidate.outcome;
+            var accepted = supportOutcomeLooksAccepted(candidate.outcome) || (!!candidate.commitSha && !supportOutcomeLooksRejected(candidate.outcome));
+            if (outcomeKnown && !accepted) {
+                ignoredCount += 1;
+                continue;
+            }
+            var signals = [];
+            var score = accepted ? 100 : 40;
+            var candidateIssueClass = normalizeIssueClass(candidate.issueClass);
+            if (issueClass && candidateIssueClass && issueClass === candidateIssueClass) {
+                score += 45;
+                signals.push("issue_class:".concat(issueClass));
+            }
+            var exactOwnerOverlap = candidate.ownerFiles.filter(function (file) { return ownerFileSet.has(normalizeOwnerFilePath(file)); });
+            if (exactOwnerOverlap.length) {
+                score += 35 + Math.min(20, exactOwnerOverlap.length * 5);
+                signals.push("owner_file_overlap:".concat(exactOwnerOverlap.slice(0, 3).join(',')));
+            }
+            var directoryOverlap = candidate.ownerFiles
+                .map(supportOwnerFileDirectory)
+                .filter(function (dir) { return dir && ownerDirs.has(dir); });
+            if (directoryOverlap.length && !exactOwnerOverlap.length) {
+                score += 18;
+                signals.push("owner_dir_overlap:".concat(Array.from(new Set(directoryOverlap)).slice(0, 2).join(',')));
+            }
+            var candidateTokens = new Set(__spreadArray(__spreadArray([], __read((candidate.keywords || [])), false), __read(supportTextTokens([candidate.title, candidate.summary, candidate.commitMessage].join(' '))), false));
+            var tokenOverlap = Array.from(candidateTokens).filter(function (token) { return textTokens.has(token); }).slice(0, 6);
+            if (tokenOverlap.length) {
+                score += Math.min(18, tokenOverlap.length * 3);
+                signals.push("weak_text_overlap:".concat(tokenOverlap.join(',')));
+            }
+            if (candidate.commitSha) {
+                score += 8;
+                signals.push('commit_linked');
+            }
+            if (!signals.length && score < 100) {
+                ignoredCount += 1;
+                continue;
+            }
+            ranked.push({
+                id: candidate.id,
+                ticketNumber: candidate.ticketNumber,
+                title: candidate.title,
+                outcome: candidate.outcome || (candidate.commitSha ? 'commit_hint' : ''),
+                issueClass: candidateIssueClass || candidate.issueClass,
+                ownerFiles: candidate.ownerFiles.slice(0, 8),
+                commitSha: candidate.commitSha,
+                commitMessage: candidate.commitMessage,
+                reason: signals.join('; '),
+                source: candidate.source,
+                score: score,
+                structuredSignals: signals,
+                advisoryOnly: true
+            });
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (normalized_1_1 && !normalized_1_1.done && (_a = normalized_1.return)) _a.call(normalized_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    var sorted = ranked
+        .sort(function (a, b) { return b.score - a.score || String(b.ticketNumber || b.commitSha || '').localeCompare(String(a.ticketNumber || a.commitSha || '')); })
+        .slice(0, limit);
+    return {
+        ranked: sorted,
+        similarTickets: sorted.filter(function (hint) { return hint.source !== 'git_commit'; }).slice(0, limit),
+        similarCommits: sorted.filter(function (hint) { return hint.source === 'git_commit' || !!hint.commitSha; }).slice(0, limit),
+        ignoredCount: ignoredCount,
+        generatedAt: isoNow(input.now)
+    };
+}
 function normalizeSupportDiagnosisBusinessProofContract(value, issueClassHint) {
     var source = cleanObject(value);
     if (!Object.keys(source).length) {
@@ -408,7 +604,7 @@ function normalizeResolveIOSupportDiagnosisGate(value, now) {
     return gate;
 }
 function extractResolveIOSupportDiagnosisGateFromText(value, now) {
-    var e_3, _a;
+    var e_4, _a;
     var text = String(value || '').trim();
     if (!text) {
         return undefined;
@@ -436,12 +632,12 @@ function extractResolveIOSupportDiagnosisGateFromText(value, now) {
             }
         }
     }
-    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    catch (e_4_1) { e_4 = { error: e_4_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; }
+        finally { if (e_4) throw e_4.error; }
     }
     return undefined;
 }
@@ -584,11 +780,289 @@ function normalizeSupportConfidenceLevel(value) {
     return normalized ? 'unknown' : 'unknown';
 }
 function supportReleaseLooksBlocked(value) {
-    return /\b(fail|failed|error|blocked|missing|empty|stale|denied|timeout|pending_manual|requested|in_progress|queued)\b/i.test(cleanText(value, 200));
+    return /\b(fail|failed|error|blocked|missing|empty|stale|denied|timeout)\b/i.test(cleanText(value, 200));
 }
 function supportBusinessAssertionPassed(value) {
     return /^(pass|passed|accepted|business_assertion_passed)$/i.test(cleanText(value, 80));
 }
+function supportBusinessAssertionFailed(value) {
+    return /^(fail|failed|blocked|needs_repair|business_assertion_failed)$/i.test(cleanText(value, 80));
+}
+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_5, _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;
+    var artifactPaths = cleanList(input.businessProofArtifacts, 30, 500);
+    var assertions = [];
+    try {
+        for (var _b = __values(Array.isArray(input.businessAssertions) ? input.businessAssertions : []), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var entry = _c.value;
+            var source = cleanObject(entry);
+            if (!Object.keys(source).length) {
+                continue;
+            }
+            var metadata = cleanObject(source.metadata);
+            assertions.push({
+                assertion: pickText(source, ['assertion', 'name', 'workflow', 'expected'], 1000) || (proofPlan === null || proofPlan === void 0 ? void 0 : proofPlan.business_assertion) || 'business assertion',
+                status: cleanText(source.status || source.outcome || source.result, 80),
+                workflow: pickText(source, ['workflow', 'workflowName'], 400),
+                route: pickText(source, ['route', 'url'], 500),
+                before: pickText(source, ['before', 'before_state', 'beforeState'], 1000),
+                action: pickText(source, ['action', 'action_under_test', 'actionUnderTest'], 1000),
+                expected: pickText(source, ['expected', 'expected_business_state_change', 'expectedBusinessStateChange'], 1000),
+                after: pickText(source, ['after', 'after_state', 'afterState'], 1000),
+                observed: pickText(source, ['observed', 'actual'], 1000),
+                dataProof: pickText(source, ['dataProof', 'data_proof', 'proof', 'domProof', 'dom_proof'], 1400),
+                mongoDelta: cleanObject(source.mongoDelta || source.mongo_delta),
+                artifactPaths: cleanList(source.artifactPaths || source.artifact_paths || source.artifacts, 30, 500),
+                message: pickText(source, ['message', 'reason', 'summary'], 1000),
+                acceptanceBlocked: source.acceptanceBlocked === true || source.acceptance_blocked === true || metadata.acceptanceBlocked === true || metadata.acceptance_blocked === true,
+                routeOnly: source.routeOnly === true || source.route_only === true || source.outcome === 'route_only_pass' || source.status === 'route_probe_pass' || metadata.routeOnly === true || metadata.route_only === true,
+                metadata: metadata
+            });
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    var status = cleanText(input.businessAssertionStatus || input.outcomeLabel, 80);
+    if (!assertions.length && (supportBusinessAssertionPassed(status) || supportBusinessAssertionRouteOnly(status) || supportBusinessAssertionFailed(status))) {
+        assertions.push({
+            assertion: (proofPlan === null || proofPlan === void 0 ? void 0 : proofPlan.business_assertion) || (proofContract === null || proofContract === void 0 ? void 0 : proofContract.data_or_dom_assertion) || 'business assertion',
+            status: status,
+            workflow: proofContract === null || proofContract === void 0 ? void 0 : proofContract.action_under_test,
+            route: (proofPlan === null || proofPlan === void 0 ? void 0 : proofPlan.route) || (gate === null || gate === void 0 ? void 0 : gate.issue_case.route_module),
+            before: proofPlan === null || proofPlan === void 0 ? void 0 : proofPlan.before,
+            action: (proofPlan === null || proofPlan === void 0 ? void 0 : proofPlan.action) || (proofContract === null || proofContract === void 0 ? void 0 : proofContract.action_under_test),
+            expected: (proofContract === null || proofContract === void 0 ? void 0 : proofContract.expected_business_state_change) || (proofPlan === null || proofPlan === void 0 ? void 0 : proofPlan.after),
+            after: proofPlan === null || proofPlan === void 0 ? void 0 : proofPlan.after,
+            observed: '',
+            dataProof: (proofContract === null || proofContract === void 0 ? void 0 : proofContract.data_or_dom_assertion) || (proofPlan === null || proofPlan === void 0 ? void 0 : proofPlan.data_assertion) || '',
+            mongoDelta: {},
+            artifactPaths: artifactPaths,
+            message: '',
+            acceptanceBlocked: supportBusinessAssertionRouteOnly(status),
+            routeOnly: supportBusinessAssertionRouteOnly(status),
+            metadata: {}
+        });
+    }
+    return assertions;
+}
+function supportBusinessProofAssertionText(assertion) {
+    return cleanText([
+        assertion.assertion,
+        assertion.workflow,
+        assertion.before,
+        assertion.action,
+        assertion.expected,
+        assertion.after,
+        assertion.observed,
+        assertion.dataProof,
+        assertion.message
+    ].filter(Boolean).join(' '), 4000);
+}
+function supportBusinessProofAssertionMatchesContract(assertion, gate) {
+    var e_6, _a;
+    if (!gate) {
+        return false;
+    }
+    var metadata = assertion.metadata || {};
+    if (metadata.supportDiagnosisProof === true
+        || metadata.support_diagnosis_proof === true
+        || metadata.diagnosisProofPlanMatched === true
+        || metadata.diagnosis_proof_plan_matched === true
+        || metadata.proofPlanMatched === true
+        || metadata.proof_plan_matched === true) {
+        return true;
+    }
+    var proofPlan = gate.proof_plan;
+    var proofContract = proofPlan.business_proof_contract;
+    var requiredParts = [
+        proofPlan.business_assertion,
+        proofPlan.after,
+        proofPlan.data_assertion,
+        proofContract === null || proofContract === void 0 ? void 0 : proofContract.expected_business_state_change,
+        proofContract === null || proofContract === void 0 ? void 0 : proofContract.data_or_dom_assertion
+    ].map(function (part) { return cleanText(part, 1000).toLowerCase(); }).filter(function (part) { return part.length >= 12; });
+    var assertionText = supportBusinessProofAssertionText(assertion).toLowerCase();
+    if (!requiredParts.length) {
+        return false;
+    }
+    if (requiredParts.some(function (part) { return assertionText.includes(part); })) {
+        return true;
+    }
+    var proofWords = new Set(requiredParts.join(' ').split(/[^a-z0-9]+/g).filter(function (word) { return word.length >= 5; }));
+    var assertionWords = new Set(assertionText.split(/[^a-z0-9]+/g).filter(function (word) { return word.length >= 5; }));
+    var overlap = 0;
+    try {
+        for (var proofWords_1 = __values(proofWords), proofWords_1_1 = proofWords_1.next(); !proofWords_1_1.done; proofWords_1_1 = proofWords_1.next()) {
+            var word = proofWords_1_1.value;
+            if (assertionWords.has(word)) {
+                overlap += 1;
+            }
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (proofWords_1_1 && !proofWords_1_1.done && (_a = proofWords_1.return)) _a.call(proofWords_1);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    return overlap >= Math.min(5, Math.max(3, Math.ceil(proofWords.size * 0.45)));
+}
+function supportBusinessProofArtifactFingerprint(paths) {
+    var normalized = cleanList(paths, 80, 500).sort();
+    return normalized.length ? hashResolveIOSupportV5Evidence({ artifacts: normalized }) : '';
+}
+function supportBusinessProofFingerprint(gate, assertion, artifactPaths) {
+    var _a;
+    if (artifactPaths === void 0) { artifactPaths = []; }
+    if (!gate || !assertion) {
+        return '';
+    }
+    var proofPlan = gate.proof_plan;
+    var proofContract = proofPlan.business_proof_contract;
+    return hashResolveIOSupportV5Evidence({
+        issueClass: gate.issue_class,
+        proofPlan: {
+            before: proofPlan.before,
+            action: proofPlan.action,
+            after: proofPlan.after,
+            businessAssertion: proofPlan.business_assertion,
+            dataAssertion: proofPlan.data_assertion,
+            contractAction: proofContract === null || proofContract === void 0 ? void 0 : proofContract.action_under_test,
+            contractExpected: proofContract === null || proofContract === void 0 ? void 0 : proofContract.expected_business_state_change,
+            contractAssertion: proofContract === null || proofContract === void 0 ? void 0 : proofContract.data_or_dom_assertion
+        },
+        assertion: {
+            assertion: assertion.assertion,
+            status: assertion.status,
+            workflow: assertion.workflow,
+            route: assertion.route,
+            before: assertion.before,
+            action: assertion.action,
+            expected: assertion.expected,
+            after: assertion.after,
+            observed: assertion.observed,
+            dataProof: assertion.dataProof,
+            mongoDelta: assertion.mongoDelta
+        },
+        artifacts: cleanList(((_a = assertion.artifactPaths) === null || _a === void 0 ? void 0 : _a.length) ? assertion.artifactPaths : artifactPaths, 80, 500).sort()
+    });
+}
+function defaultSupportBusinessProofReadinessFields(values) {
+    if (values === void 0) { values = {}; }
+    var artifactPaths = cleanList(values.artifactPaths, 80, 500);
+    return {
+        artifactPaths: artifactPaths,
+        proofFingerprint: cleanText(values.proofFingerprint, 160),
+        artifactFingerprint: cleanText(values.artifactFingerprint, 160) || supportBusinessProofArtifactFingerprint(artifactPaths),
+        proofFreshness: values.proofFreshness || (artifactPaths.length ? 'unknown' : 'missing')
+    };
+}
+function evaluateResolveIOSupportBusinessProofReadiness(input) {
+    if (input === void 0) { input = {}; }
+    var diagnosisValidation = validateResolveIOSupportDiagnosisGate(input.diagnosisGate);
+    var gate = diagnosisValidation.normalized;
+    var requiredEvidence = [
+        'valid SupportDiagnosisGate proof_plan',
+        'AIQaBusinessAssertion status=pass',
+        'business assertion maps to diagnosis proof_plan/business_proof_contract',
+        'artifact path for browser/data proof',
+        'DOM/data proof or Mongo delta for the expected business state change'
+    ];
+    if (!diagnosisValidation.valid || !gate) {
+        return __assign({ ready: false, status: 'blocked', reason: 'support_business_proof_waiting_on_valid_diagnosis', blockers: diagnosisValidation.blockers.length ? diagnosisValidation.blockers : ['Valid SupportDiagnosisGate is required before business proof can accept the ticket.'], requiredEvidence: requiredEvidence }, defaultSupportBusinessProofReadinessFields());
+    }
+    var assertions = normalizeSupportBusinessProofAssertions(input);
+    if (!assertions.length) {
+        return __assign({ ready: false, status: 'missing', reason: 'support_business_proof_missing_aiqa_business_assertion', blockers: ['No AIQaBusinessAssertion was recorded for the diagnosis proof_plan.'], requiredEvidence: requiredEvidence }, defaultSupportBusinessProofReadinessFields());
+    }
+    var artifactPaths = Array.from(new Set(assertions.flatMap(function (assertion) { return assertion.artifactPaths || []; })));
+    var artifactFingerprint = supportBusinessProofArtifactFingerprint(artifactPaths);
+    var failed = assertions.find(function (assertion) { return supportBusinessAssertionFailed(assertion.status); });
+    if (failed) {
+        var failedFingerprint = supportBusinessProofFingerprint(gate, failed, artifactPaths);
+        return __assign(__assign({ ready: false, status: 'failed', reason: 'support_business_proof_assertion_failed', blockers: [failed.message || failed.observed || failed.assertion || 'Business assertion failed.'], requiredEvidence: requiredEvidence }, defaultSupportBusinessProofReadinessFields({
+            artifactPaths: artifactPaths,
+            proofFingerprint: failedFingerprint,
+            artifactFingerprint: artifactFingerprint,
+            proofFreshness: 'fresh'
+        })), { matchedAssertion: failed });
+    }
+    var routeOnly = assertions.find(function (assertion) { return assertion.routeOnly || assertion.acceptanceBlocked || supportBusinessAssertionRouteOnly(assertion.status) || proofPlanLooksRouteOnly({
+        before: assertion.before || '',
+        action: assertion.action || '',
+        after: assertion.after || assertion.expected || '',
+        business_assertion: assertion.assertion || assertion.message || '',
+        data_assertion: assertion.dataProof || '',
+        artifact_expectation: assertion.artifactPaths.join(', ')
+    }); });
+    if (routeOnly) {
+        var routeOnlyFingerprint = supportBusinessProofFingerprint(gate, routeOnly, artifactPaths);
+        return __assign(__assign({ ready: false, status: 'route_only', reason: 'support_business_proof_route_only_or_acceptance_blocked', blockers: ['Route probe, shell/screenshot, or acceptance_blocked proof cannot accept the ticket. Run the issue-class business assertion.'], requiredEvidence: requiredEvidence }, defaultSupportBusinessProofReadinessFields({
+            artifactPaths: artifactPaths,
+            proofFingerprint: routeOnlyFingerprint,
+            artifactFingerprint: artifactFingerprint,
+            proofFreshness: 'fresh'
+        })), { matchedAssertion: routeOnly });
+    }
+    var passedAssertions = assertions.filter(function (assertion) { return supportBusinessAssertionPassed(assertion.status); });
+    var matched = passedAssertions.find(function (assertion) { return supportBusinessProofAssertionMatchesContract(assertion, gate); });
+    if (!matched) {
+        return __assign({ ready: false, status: 'weak', reason: 'support_business_proof_does_not_match_diagnosis_contract', blockers: ['A passed assertion exists, but it does not map to the diagnosis proof_plan/business_proof_contract.'], requiredEvidence: requiredEvidence }, defaultSupportBusinessProofReadinessFields({ artifactPaths: artifactPaths, artifactFingerprint: artifactFingerprint }));
+    }
+    var proofArtifactPaths = matched.artifactPaths.length ? matched.artifactPaths : artifactPaths;
+    var proofFingerprint = supportBusinessProofFingerprint(gate, matched, proofArtifactPaths);
+    var matchedArtifactFingerprint = supportBusinessProofArtifactFingerprint(proofArtifactPaths);
+    var previousProofFingerprint = cleanText(input.previousProofFingerprint, 160);
+    var previousArtifactFingerprint = cleanText(input.previousArtifactFingerprint, 160);
+    var sameProofAsPrevious = !!previousProofFingerprint && previousProofFingerprint === proofFingerprint;
+    var sameArtifactAsPrevious = !!previousArtifactFingerprint && previousArtifactFingerprint === matchedArtifactFingerprint;
+    if (sameProofAsPrevious || sameArtifactAsPrevious) {
+        return __assign(__assign({ ready: false, status: 'stale', reason: sameProofAsPrevious
+                ? 'support_business_proof_same_fingerprint_as_previous'
+                : 'support_business_proof_same_artifact_fingerprint_as_previous', blockers: ['Business proof did not produce a new proof/artifact fingerprint for this run. Rerun the issue-specific assertion and record fresh artifact proof.'], requiredEvidence: requiredEvidence }, defaultSupportBusinessProofReadinessFields({
+            artifactPaths: proofArtifactPaths,
+            proofFingerprint: proofFingerprint,
+            artifactFingerprint: matchedArtifactFingerprint,
+            proofFreshness: sameProofAsPrevious ? 'same_as_previous' : 'stale_artifact'
+        })), { matchedAssertion: matched });
+    }
+    if (!matched.artifactPaths.length && !artifactPaths.length) {
+        return __assign(__assign({ ready: false, status: 'weak', reason: 'support_business_proof_missing_artifact_path', blockers: ['Business proof must include at least one artifact path.'], requiredEvidence: requiredEvidence }, defaultSupportBusinessProofReadinessFields({
+            artifactPaths: artifactPaths,
+            proofFingerprint: proofFingerprint,
+            artifactFingerprint: matchedArtifactFingerprint
+        })), { matchedAssertion: matched });
+    }
+    var hasDataOrDomProof = !!cleanText(matched.dataProof, 50)
+        || Object.keys(cleanObject(matched.mongoDelta)).length > 0
+        || !!cleanText(matched.observed, 80)
+        || !!cleanText(matched.after, 80);
+    if (!hasDataOrDomProof) {
+        return __assign(__assign({ ready: false, status: 'weak', reason: 'support_business_proof_missing_dom_or_data_proof', blockers: ['Business proof must include DOM/data proof, observed result, after-state, or Mongo delta.'], requiredEvidence: requiredEvidence }, defaultSupportBusinessProofReadinessFields({
+            artifactPaths: proofArtifactPaths,
+            proofFingerprint: proofFingerprint,
+            artifactFingerprint: matchedArtifactFingerprint
+        })), { matchedAssertion: matched });
+    }
+    return __assign(__assign({ ready: true, status: 'passed', reason: 'support_business_proof_ready', blockers: [], requiredEvidence: requiredEvidence }, defaultSupportBusinessProofReadinessFields({
+        artifactPaths: proofArtifactPaths,
+        proofFingerprint: proofFingerprint,
+        artifactFingerprint: matchedArtifactFingerprint,
+        proofFreshness: 'fresh'
+    })), { matchedAssertion: matched });
+}
 function buildSupportClarificationQuestion(gate, blockers) {
     if ((gate === null || gate === void 0 ? void 0 : gate.issue_case.reproduction_status) === 'blocked' && gate.issue_case.reproduction_blocker) {
         return "Can you provide the missing detail needed to reproduce this issue: ".concat(gate.issue_case.reproduction_blocker, "?");
@@ -604,6 +1078,53 @@ function buildSupportClarificationQuestion(gate, blockers) {
     }
     return 'Can you send one concrete example record, screen, or action path where this issue still occurs?';
 }
+function buildResolveIOSupportHumanReviewPacket(input) {
+    return {
+        reviewType: input.reviewType,
+        title: cleanText(input.title, 200) || 'Review Support Runner Action',
+        summary: cleanText(input.summary || input.reason, 1000),
+        primaryAction: cleanText(input.primaryAction, 160) || 'review_support_runner_action',
+        question: cleanText(input.question, 1000) || undefined,
+        customerFacingDraftAllowed: input.customerFacingDraftAllowed === true,
+        customerSendAllowed: false,
+        requiresHumanApproval: input.requiresHumanApproval !== false,
+        safety: input.safety || 'internal_hold',
+        reason: cleanText(input.reason, 500),
+        blockers: cleanList(input.blockers, 20, 500),
+        requiredEvidence: cleanList(input.requiredEvidence, 30, 500),
+        evidenceRefs: cleanList(input.evidenceRefs, 40, 500),
+        nextCommands: cleanList(input.nextCommands, 20, 200),
+        forbiddenActions: Array.from(new Set(__spreadArray([
+            'Do not send customer email without explicit human approval.'
+        ], __read(cleanList(input.forbiddenActions, 20, 500)), false))),
+        costRisk: input.costRisk || 'small_model_or_qa',
+        createdAt: isoNow(input.now)
+    };
+}
+function supportAutonomousReviewTypeForAction(action) {
+    switch (action) {
+        case 'run_diagnosis_gate':
+            return 'diagnosis_gate';
+        case 'ask_customer_clarification':
+            return 'customer_clarification';
+        case 'run_owner_scoped_repair':
+        case 'revise_diagnosis_scope':
+            return 'owner_scoped_repair';
+        case 'run_business_proof_qa':
+            return 'business_proof_qa';
+        case 'repair_release_hotfix_first':
+        case 'ready_for_release_gate':
+            return 'release_hotfix';
+        case 'draft_customer_reply':
+            return 'customer_resolution_reply';
+        case 'collect_new_evidence':
+            return 'new_evidence';
+        case 'repair_infra_only':
+        case 'park_manual':
+        default:
+            return 'internal_hold';
+    }
+}
 function decideResolveIOSupportCustomerReplyPolicy(input) {
     var _a, _b, _c;
     if (input === void 0) { input = {}; }
@@ -613,10 +1134,16 @@ function decideResolveIOSupportCustomerReplyPolicy(input) {
     var shouldBlockConfidence = ((_a = input.confidence) === null || _a === void 0 ? void 0 : _a.shouldBlockPr) === true
         || ((_b = input.confidence) === null || _b === void 0 ? void 0 : _b.should_block_pr) === true
         || ((_c = input.confidence) === null || _c === void 0 ? void 0 : _c.blocked) === true;
-    var outcomeLabel = cleanText(input.outcomeLabel, 120).toLowerCase();
-    var businessPassed = supportBusinessAssertionPassed(input.businessAssertionStatus)
-        || outcomeLabel === 'accepted';
-    var artifactCount = cleanList(input.businessProofArtifacts, 20, 500).length;
+    var businessProofReadiness = evaluateResolveIOSupportBusinessProofReadiness({
+        diagnosisGate: input.diagnosisGate,
+        outcomeLabel: input.outcomeLabel,
+        businessAssertionStatus: input.businessAssertionStatus,
+        businessAssertions: input.businessAssertions,
+        businessProofArtifacts: input.businessProofArtifacts,
+        previousProofFingerprint: input.previousProofFingerprint,
+        previousArtifactFingerprint: input.previousArtifactFingerprint
+    });
+    var artifactCount = businessProofReadiness.artifactPaths.length;
     var unresolvedBlockers = cleanList(input.unresolvedBlockers, 20, 500);
     var releaseBlocked = supportReleaseLooksBlocked(input.releaseStatus);
     var requiredEvidence = [
@@ -630,6 +1157,7 @@ function decideResolveIOSupportCustomerReplyPolicy(input) {
         var canAskCustomer = (gate === null || gate === void 0 ? void 0 : gate.issue_case.reproduction_status) === 'blocked'
             || diagnosisValidation.blockers.some(function (blocker) { return /expected_result|observed_result|account_customer_context/.test(blocker); });
         if (canAskCustomer) {
+            var clarificationQuestion = buildSupportClarificationQuestion(gate, diagnosisValidation.blockers);
             return {
                 action: 'ask_clarification',
                 canDraftCustomerReply: true,
@@ -638,7 +1166,22 @@ function decideResolveIOSupportCustomerReplyPolicy(input) {
                 safety: 'needs_clarification',
                 reason: 'support_reply_waiting_on_customer_reproduction_detail',
                 requiredEvidence: requiredEvidence,
-                clarificationQuestion: buildSupportClarificationQuestion(gate, diagnosisValidation.blockers)
+                clarificationQuestion: clarificationQuestion,
+                humanReviewPacket: buildResolveIOSupportHumanReviewPacket({
+                    reviewType: 'customer_clarification',
+                    title: 'Review Customer Clarification',
+                    summary: 'The runner needs one customer detail before it can reproduce or continue safely.',
+                    primaryAction: 'review_customer_clarification',
+                    question: clarificationQuestion,
+                    customerFacingDraftAllowed: true,
+                    safety: 'needs_clarification',
+                    reason: 'support_reply_waiting_on_customer_reproduction_detail',
+                    blockers: diagnosisValidation.blockers,
+                    requiredEvidence: requiredEvidence,
+                    nextCommands: ['edit_clarification_question', 'send_after_human_review', 'park_ticket_until_customer_reply'],
+                    forbiddenActions: ['Do not run repair from a guessed reproduction path.'],
+                    costRisk: 'release_or_customer_send'
+                })
             };
         }
         return {
@@ -648,7 +1191,20 @@ function decideResolveIOSupportCustomerReplyPolicy(input) {
             confidenceLevel: confidenceLevel,
             safety: 'internal_hold',
             reason: 'support_reply_blocked_until_diagnosis_gate_validates',
-            requiredEvidence: requiredEvidence
+            requiredEvidence: requiredEvidence,
+            humanReviewPacket: buildResolveIOSupportHumanReviewPacket({
+                reviewType: 'internal_hold',
+                title: 'Complete Diagnosis Gate',
+                summary: 'Customer reply is blocked until the diagnosis gate validates.',
+                primaryAction: 'run_support_v5_read_only_diagnosis_gate',
+                safety: 'internal_hold',
+                reason: 'support_reply_blocked_until_diagnosis_gate_validates',
+                blockers: diagnosisValidation.blockers,
+                requiredEvidence: requiredEvidence,
+                nextCommands: ['retrieve_similar_tickets_and_commits', 'run_reproduction_or_classification_probe', 'write_support_diagnosis_gate_json'],
+                forbiddenActions: ['Do not draft a resolution reply before root-cause diagnosis validates.'],
+                costRisk: 'expensive_model'
+            })
         };
     }
     if (shouldBlockConfidence || confidenceLevel !== 'high') {
@@ -659,7 +1215,19 @@ function decideResolveIOSupportCustomerReplyPolicy(input) {
             confidenceLevel: confidenceLevel,
             safety: 'internal_hold',
             reason: shouldBlockConfidence ? 'support_reply_blocked_by_confidence_gate' : 'support_reply_requires_high_confidence',
-            requiredEvidence: requiredEvidence
+            requiredEvidence: requiredEvidence,
+            humanReviewPacket: buildResolveIOSupportHumanReviewPacket({
+                reviewType: 'internal_hold',
+                title: 'Review Confidence Gate',
+                summary: 'Customer reply is blocked until confidence is high and the confidence gate is not blocking.',
+                primaryAction: 'review_support_confidence_evidence',
+                safety: 'internal_hold',
+                reason: shouldBlockConfidence ? 'support_reply_blocked_by_confidence_gate' : 'support_reply_requires_high_confidence',
+                requiredEvidence: requiredEvidence,
+                nextCommands: ['inspect_confidence_basis', 'collect_missing_business_or_release_evidence'],
+                forbiddenActions: ['Do not draft a customer resolution from medium or low confidence.'],
+                costRisk: 'free_or_deterministic'
+            })
         };
     }
     if (unresolvedBlockers.length) {
@@ -670,7 +1238,20 @@ function decideResolveIOSupportCustomerReplyPolicy(input) {
             confidenceLevel: confidenceLevel,
             safety: 'internal_hold',
             reason: 'support_reply_blocked_by_unresolved_runner_blocker',
-            requiredEvidence: requiredEvidence
+            requiredEvidence: requiredEvidence,
+            humanReviewPacket: buildResolveIOSupportHumanReviewPacket({
+                reviewType: 'internal_hold',
+                title: 'Resolve Runner Blocker',
+                summary: 'Customer reply is blocked by unresolved runner blockers.',
+                primaryAction: 'review_support_runner_blocker',
+                safety: 'internal_hold',
+                reason: 'support_reply_blocked_by_unresolved_runner_blocker',
+                blockers: unresolvedBlockers,
+                requiredEvidence: requiredEvidence,
+                nextCommands: ['classify_blocker', 'collect_new_evidence_or_repair_smallest_gate'],
+                forbiddenActions: ['Do not send customer status as resolved while blockers remain.'],
+                costRisk: 'small_model_or_qa'
+            })
         };
     }
     if (releaseBlocked) {
@@ -681,18 +1262,49 @@ function decideResolveIOSupportCustomerReplyPolicy(input) {
             confidenceLevel: confidenceLevel,
             safety: 'internal_hold',
             reason: 'support_reply_blocked_until_release_or_hotfix_gate_finishes',
-            requiredEvidence: requiredEvidence
+            requiredEvidence: requiredEvidence,
+            humanReviewPacket: buildResolveIOSupportHumanReviewPacket({
+                reviewType: 'release_hotfix',
+                title: 'Finish Release Or Hotfix Gate',
+                summary: 'Business proof exists, but the customer reply is blocked until release or hotfix evidence is complete.',
+                primaryAction: 'repair_release_hotfix_first',
+                safety: 'internal_hold',
+                reason: 'support_reply_blocked_until_release_or_hotfix_gate_finishes',
+                blockers: [input.releaseStatus],
+                requiredEvidence: requiredEvidence,
+                nextCommands: ['record_hotfix_evidence', 'commit_and_push_hotfix_to_github', 'rerun_release_gate_once'],
+                forbiddenActions: ['Do not tell the customer the fix is live before release evidence passes.'],
+                costRisk: 'release_or_customer_send'
+            })
         };
     }
-    if (!businessPassed) {
+    if (!businessProofReadiness.ready) {
+        var replyReason = businessProofReadiness.reason === 'support_business_proof_route_only_or_acceptance_blocked'
+            ? 'support_reply_rejects_route_only_business_proof'
+            : 'support_reply_requires_business_assertion_pass';
+        var proofRequiredEvidence = Array.from(new Set(__spreadArray(__spreadArray([], __read(requiredEvidence), false), __read(businessProofReadiness.requiredEvidence), false)));
         return {
             action: 'hold_internal',
             canDraftCustomerReply: false,
             canSendCustomerReply: false,
             confidenceLevel: confidenceLevel,
             safety: 'internal_hold',
-            reason: 'support_reply_requires_business_assertion_pass',
-            requiredEvidence: requiredEvidence
+            reason: replyReason,
+            requiredEvidence: proofRequiredEvidence,
+            humanReviewPacket: buildResolveIOSupportHumanReviewPacket({
+                reviewType: 'business_proof_qa',
+                title: 'Run Business Proof QA',
+                summary: 'Customer reply is blocked until the issue-specific before/action/after assertion passes.',
+                primaryAction: 'run_support_v5_business_proof_qa_row',
+                safety: 'internal_hold',
+                reason: replyReason,
+                blockers: businessProofReadiness.blockers,
+                requiredEvidence: proofRequiredEvidence,
+                evidenceRefs: businessProofReadiness.artifactPaths,
+                nextCommands: ['execute_issue_class_probe', 'record_before_action_after_artifacts', 'write_aiqa_business_assertion'],
+                forbiddenActions: ['Route probe pass remains route evidence only.'],
+                costRisk: 'small_model_or_qa'
+            })
         };
     }
     if (!(gate === null || gate === void 0 ? void 0 : gate.proof_plan.business_proof_contract) || artifactCount < 1) {
@@ -703,7 +1315,20 @@ function decideResolveIOSupportCustomerReplyPolicy(input) {
             confidenceLevel: confidenceLevel,
             safety: 'internal_hold',
             reason: 'support_reply_requires_business_proof_contract_artifact',
-            requiredEvidence: requiredEvidence
+            requiredEvidence: requiredEvidence,
+            humanReviewPacket: buildResolveIOSupportHumanReviewPacket({
+                reviewType: 'business_proof_qa',
+                title: 'Attach Business Proof Artifact',
+                summary: 'Customer reply is blocked until the business proof contract and artifact are attached.',
+                primaryAction: 'record_business_proof_artifact',
+                safety: 'internal_hold',
+                reason: 'support_reply_requires_business_proof_contract_artifact',
+                requiredEvidence: requiredEvidence,
+                evidenceRefs: businessProofReadiness.artifactPaths,
+                nextCommands: ['attach_business_proof_contract', 'attach_artifact_path', 'rerun_reply_policy'],
+                forbiddenActions: ['Do not draft a resolution reply without a proof artifact.'],
+                costRisk: 'free_or_deterministic'
+            })
         };
     }
     return {
@@ -714,6 +1339,20 @@ function decideResolveIOSupportCustomerReplyPolicy(input) {
         safety: 'safe_to_draft',
         reason: 'support_reply_resolution_draft_allowed_after_business_proof',
         requiredEvidence: requiredEvidence,
+        humanReviewPacket: buildResolveIOSupportHumanReviewPacket({
+            reviewType: 'customer_resolution_reply',
+            title: 'Review Customer Resolution Reply',
+            summary: "Business proof is ready for ".concat(gate.issue_class, "; draft a customer-facing resolution for human review."),
+            primaryAction: 'review_customer_reply',
+            customerFacingDraftAllowed: true,
+            safety: 'safe_to_draft',
+            reason: 'support_reply_resolution_draft_allowed_after_business_proof',
+            requiredEvidence: requiredEvidence,
+            evidenceRefs: businessProofReadiness.artifactPaths,
+            nextCommands: ['summarize_business_proof', 'draft_customer_reply_for_human_review'],
+            forbiddenActions: ['Draft only; do not send automatically.'],
+            costRisk: 'release_or_customer_send'
+        }),
         draftBasis: {
             issueClass: gate.issue_class,
             businessProof: gate.proof_plan.business_proof_contract.expected_business_state_change,
@@ -722,7 +1361,6 @@ function decideResolveIOSupportCustomerReplyPolicy(input) {
     };
 }
 function buildResolveIOSupportIssueClassProbes(value) {
-    var _a;
     var validation = validateResolveIOSupportDiagnosisGate(value);
     var gate = validation.normalized || normalizeResolveIOSupportDiagnosisGate(value);
     if (!gate) {
@@ -732,49 +1370,69 @@ function buildResolveIOSupportIssueClassProbes(value) {
     var proofContract = gate.proof_plan.business_proof_contract;
     var proof = (proofContract === null || proofContract === void 0 ? void 0 : proofContract.expected_business_state_change) || gate.proof_plan.business_assertion;
     var assertion = (proofContract === null || proofContract === void 0 ? void 0 : proofContract.data_or_dom_assertion) || gate.proof_plan.data_assertion || gate.proof_plan.after;
-    var artifacts = ((_a = proofContract === null || proofContract === void 0 ? void 0 : proofContract.proof_artifacts) === null || _a === void 0 ? void 0 : _a.length)
-        ? " Required artifacts: ".concat(proofContract.proof_artifacts.join(', '), ".")
-        : '';
+    var contractArtifacts = cleanList(proofContract === null || proofContract === void 0 ? void 0 : proofContract.proof_artifacts, 8, 160);
     var common = {
         issue_class: gate.issue_class,
         probe_type: 'issue_class_probe',
         route: route,
+        state_transition: {
+            before: gate.proof_plan.before || gate.proof_plan.before_state_unavailable_reason || (proofContract === null || proofContract === void 0 ? void 0 : proofContract.setup_state) || '',
+            action: gate.proof_plan.action || (proofContract === null || proofContract === void 0 ? void 0 : proofContract.action_under_test) || '',
+            after: gate.proof_plan.after || (proofContract === null || proofContract === void 0 ? void 0 : proofContract.expected_business_state_change) || '',
+            assertion: assertion || gate.proof_plan.business_assertion || ''
+        },
+        acceptance_gate: 'aiqa_business_assertion',
         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.'
+            expected: proof || 'Before/action/after proof shows the submit is no longer a no-op.',
+            failureClass: 'business',
+            requiredArtifacts: ['before form state', 'submit action trace', 'post-submit DOM/data proof', 'method/network result']
         },
         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.'
+            expected: proof || 'Visible data and persisted data match the customer expectation.',
+            failureClass: 'business',
+            requiredArtifacts: ['expected source record', 'visible DOM/data snapshot', 'persisted data comparison']
         },
         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.'
+            expected: proof || 'Filter/query output contains the correct included rows and excludes the wrong rows.',
+            failureClass: 'business',
+            requiredArtifacts: ['filter input trace', 'included/excluded row proof', 'query or publication result proof']
         },
         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.'
+            expected: proof || 'Generated artifact contains the expected customer-visible rows, totals, or fields.',
+            failureClass: 'business',
+            requiredArtifacts: ['export trigger trace', 'generated file artifact path', 'parsed artifact content proof']
         },
         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.'
+            expected: proof || 'Import shows a success result and persisted rows/counts changed as expected.',
+            failureClass: 'business',
+            requiredArtifacts: ['input file fixture', 'import result message', 'persisted row/count delta']
         },
         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.'
+            expected: proof || 'Route hydrates with the required controls/data for the affected account.',
+            failureClass: 'route',
+            requiredArtifacts: ['auth context', 'hydrated DOM proof', 'console/network error log']
         },
         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.'
+            expected: proof || 'Performance evidence shows the slow path improved without changing results.',
+            failureClass: 'business',
+            requiredArtifacts: ['before timing', 'after timing', 'result equivalence proof', 'query/log trace']
         }
     };
     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: proofContract
+    var requiredArtifacts = Array.from(new Set(__spreadArray(__spreadArray([], __read(contractArtifacts), false), __read(selected.requiredArtifacts), false)));
+    return [__assign(__assign({}, common), { failure_class: selected.failureClass, objective: "Issue-class probe for ".concat(gate.issue_class, ": ").concat(gate.issue_case.customer_complaint), action: proofContract
                 ? "".concat(proofContract.action_under_test, " ").concat(selected.action)
-                : selected.action, expected_evidence: "".concat(selected.expected).concat(assertion ? " Assertion: ".concat(assertion, ".") : '').concat(artifacts).trim() })];
+                : selected.action, expected_evidence: "".concat(selected.expected).concat(assertion ? " Assertion: ".concat(assertion, ".") : '').concat(requiredArtifacts.length ? " Required artifacts: ".concat(requiredArtifacts.join(', '), ".") : '').trim(), expected_business_proof: proof || gate.proof_plan.business_assertion, required_artifacts: requiredArtifacts })];
 }
 function hashResolveIOSupportV5Evidence(value) {
     var raw = typeof value === 'string' ? value : JSON.stringify(value || {});
@@ -811,7 +1469,6 @@ function decideResolveIOSupportV5RepeatedFailureStop(input) {
             stepType: entry.stepType,
             failureClass: entry.failureClass,
             blocker: entry.blocker || entry.summary,
-            blockerFingerprint: entry.blockerFingerprint,
             evidenceHash: entry.evidenceHash,
             changedFiles: entry.changedFiles,
             artifactPaths: entry.artifactPaths,
@@ -824,8 +1481,10 @@ function decideResolveIOSupportV5RepeatedFailureStop(input) {
             stepType: latestRecord === null || latestRecord === void 0 ? void 0 : latestRecord.stepType,
             failureClass: failureClass,
             blocker: input.blocker,
-            blockerFingerprint: blockerFingerprint,
-            evidenceHash: evidenceHash
+            evidenceHash: evidenceHash,
+            changedFiles: cleanList(input.changedFiles, 40, 500),
+            artifactPaths: cleanList(input.artifactPaths, 40, 500),
+            summary: input.blocker
         },
         maxSameFailureRepeats: limit,
         maxPingPongTransitions: 3,
@@ -848,17 +1507,39 @@ function decideResolveIOSupportV5RepeatedFailureStop(input) {
             failureClass: failureClass,
             blockerFingerprint: blockerFingerprint,
             evidenceHash: evidenceHash,
+            newEvidence: managerDecision.newEvidence,
+            materialEvidence: managerDecision.materialEvidence,
+            evidenceStrength: managerDecision.evidenceStrength,
+            evidenceSignals: managerDecision.evidenceSignals,
             reason: 'support_v5_ping_pong_failure_loop'
         };
     }
-    if (managerDecision.action === 'park_repeated_failure' && managerDecision.newEvidence) {
+    if (managerDecision.action === 'park_repeated_failure' && managerDecision.newEvidence && !managerDecision.materialEvidence) {
+        return {
+            shouldStop: true,
+            repeatedCount: managerDecision.sameFailureCount,
+            failureClass: failureClass,
+            blockerFingerprint: blockerFingerprint,
+            evidenceHash: evidenceHash,
+            newEvidence: managerDecision.newEvidence,
+            materialEvidence: managerDecision.materialEvidence,
+            evidenceStrength: managerDecision.evidenceStrength,
+            evidenceSignals: managerDecision.evidenceSignals,
+            reason: 'support_v5_same_failure_with_weak_evidence'
+        };
+    }
+    if (managerDecision.newEvidence && managerDecision.materialEvidence) {
         return {
             shouldStop: false,
             repeatedCount: managerDecision.sameFailureCount,
             failureClass: failureClass,
             blockerFingerprint: blockerFingerprint,
             evidenceHash: evidenceHash,
-            reason: 'support_v5_retry_allowed_changed_evidence_hash'
+            newEvidence: managerDecision.newEvidence,
+            materialEvidence: managerDecision.materialEvidence,
+            evidenceStrength: managerDecision.evidenceStrength,
+            evidenceSignals: managerDecision.evidenceSignals,
+            reason: 'support_v5_retry_allowed_material_evidence'
         };
     }
     if (managerDecision.action === 'park_repeated_failure') {
@@ -868,6 +1549,10 @@ function decideResolveIOSupportV5RepeatedFailureStop(input) {
             failureClass: failureClass,
             blockerFingerprint: blockerFingerprint,
             evidenceHash: evidenceHash,
+            newEvidence: managerDecision.newEvidence,
+            materialEvidence: managerDecision.materialEvidence,
+            evidenceStrength: managerDecision.evidenceStrength,
+            evidenceSignals: managerDecision.evidenceSignals,
             reason: 'support_v5_same_failure_class_without_new_evidence'
         };
     }
@@ -893,11 +1578,125 @@ function decideResolveIOSupportV5RepeatedFailureStop(input) {
         failureClass: failureClass,
         blockerFingerprint: blockerFingerprint,
         evidenceHash: evidenceHash,
+        newEvidence: managerDecision.newEvidence,
+        materialEvidence: managerDecision.materialEvidence,
+        evidenceStrength: managerDecision.evidenceStrength,
+        evidenceSignals: managerDecision.evidenceSignals,
         reason: repeatedCount >= limit
             ? 'support_v5_same_failure_class_without_new_evidence'
             : 'support_v5_retry_allowed_new_or_below_repeat_limit'
     };
 }
+function evaluateResolveIOSupportEvidenceFreshness(input) {
+    var _a;
+    var history = Array.isArray(input.history) ? input.history : [];
+    var latest = history.length ? history[history.length - 1] : undefined;
+    var rawFailureClass = cleanText(input.failureClass || (latest === null || latest === void 0 ? void 0 : latest.failureClass), 80).toLowerCase();
+    var failureClass = rawFailureClass || 'unknown';
+    var blocker = cleanText(input.blocker || (latest === null || latest === void 0 ? void 0 : latest.blocker) || (latest === null || latest === void 0 ? void 0 : latest.summary), 1200);
+    var changedFiles = cleanList(input.changedFiles || (latest === null || latest === void 0 ? void 0 : latest.changedFiles), 40, 500);
+    var artifactPaths = cleanList(input.artifactPaths || (latest === null || latest === void 0 ? void 0 : latest.artifactPaths), 40, 500);
+    var explicitEvidenceHash = cleanText(input.evidenceHash || (latest === null || latest === void 0 ? void 0 : latest.evidenceHash), 120);
+    var evidenceHash = explicitEvidenceHash || hashResolveIOSupportV5Evidence(input.evidence || artifactPaths || blocker || (latest === null || latest === void 0 ? void 0 : latest.summary) || '');
+    var blockerFingerprint = fingerprintResolveIOSupportV5Blocker(blocker || (latest === null || latest === void 0 ? void 0 : latest.summary) || '');
+    var missing = !history.length && !rawFailureClass && !blocker && !explicitEvidenceHash && !artifactPaths.length && !changedFiles.length;
+    if (missing) {
+        return {
+            status: 'missing',
+            failureClass: '',
+            blockerFingerprint: '',
+            evidenceHash: '',
+            sameFailureCount: 0,
+            pingPongCount: 0,
+            newEvidence: false,
+            materialEvidence: false,
+            evidenceStrength: 'none',
+            evidenceSignals: [],
+            loopBudgetShouldReset: false,
+            canRetry: true,
+            mustCollectNewEvidence: false,
+            productRepairFailure: false,
+            reason: 'support_evidence_freshness_waiting_for_first_failure_or_proof',
+            requiredResetEvidence: [
+                'current blocker fingerprint',
+                'evidence hash',
+                'artifact path when available'
+            ],
+            changedFiles: changedFiles,
+            artifactPaths: artifactPaths
+        };
+    }
+    var current = {
+        outcome: 'needs_repair',
+        lane: cleanText(input.lane || (latest === null || latest === void 0 ? void 0 : latest.lane), 80) || (latest === null || latest === void 0 ? void 0 : latest.lane),
+        stepType: cleanText(input.stepType || (latest === null || latest === void 0 ? void 0 : latest.stepType), 80) || (latest === null || latest === void 0 ? void 0 : latest.stepType),
+        failureClass: failureClass,
+        blocker: blocker,
+        evidenceHash: evidenceHash,
+        changedFiles: changedFiles,
+        artifactPaths: artifactPaths,
+        summary: blocker
+    };
+    var policy = (0, ai_runner_manager_policy_1.decideResolveIOAIManagerPolicy)({
+        history: history.map(function (entry) { return ({
+            outcome: entry.outcome,
+            lane: entry.lane,
+            stepType: entry.stepType,
+            failureClass: entry.failureClass,
+            blocker: entry.blocker || entry.summary,
+            evidenceHash: entry.evidenceHash,
+            changedFiles: entry.changedFiles,
+            artifactPaths: entry.artifactPaths,
+            summary: entry.summary,
+            recordedAt: entry.recordedAt
+        }); }),
+        current: current,
+        maxSameFailureRepeats: Math.max(1, Number(input.limit || 2) || 2),
+        maxPingPongTransitions: 3,
+        infraFailureClasses: input.ignoreInfra !== false ? ['infra', 'compile'] : []
+    });
+    var status = 'retry_below_limit';
+    if (policy.action === 'retry_infra') {
+        status = 'infra_ignored';
+    }
+    else if (policy.action === 'park_ping_pong') {
+        status = 'ping_pong';
+    }
+    else if (policy.action === 'park_repeated_failure') {
+        status = policy.newEvidence ? 'weak_evidence' : 'stale_repeated';
+    }
+    else if (policy.newEvidence && policy.materialEvidence) {
+        status = 'material_evidence';
+    }
+    else if (policy.newEvidence && !policy.materialEvidence) {
+        status = 'weak_evidence';
+    }
+    else if (policy.loopBudgetShouldReset || policy.reason === 'manager_policy_new_failure_or_lane') {
+        status = 'fresh';
+    }
+    var mustCollectNewEvidence = policy.action === 'park_repeated_failure'
+        || policy.action === 'park_ping_pong';
+    return {
+        status: status,
+        failureClass: policy.failureClass,
+        blockerFingerprint: blockerFingerprint || policy.blockerFingerprint,
+        evidenceHash: policy.evidenceHash,
+        sameFailureCount: policy.sameFailureCount,
+        pingPongCount: policy.pingPongCount,
+        newEvidence: policy.newEvidence,
+        materialEvidence: policy.materialEvidence,
+        evidenceStrength: policy.evidenceStrength,
+        evidenceSignals: policy.evidenceSignals,
+        loopBudgetShouldReset: policy.loopBudgetShouldReset,
+        canRetry: !mustCollectNewEvidence,
+        mustCollectNewEvidence: mustCollectNewEvidence,
+        productRepairFailure: policy.productRepairFailure,
+        reason: policy.reason,
+        requiredResetEvidence: Array.from(new Set(__spreadArray(__spreadArray([], __read(cleanList(policy.recoveryPlan.loopResetEvidence, 12, 500)), false), __read(cleanList((_a = policy.recoveryAction) === null || _a === void 0 ? void 0 : _a.successCriteria, 12, 500)), false))).slice(0, 18),
+        changedFiles: changedFiles,
+        artifactPaths: artifactPaths
+    };
+}
 function changedFilesOutsideResolveIOSupportDiagnosisOwnerFiles(diagnosisGate, changedFiles, options) {
     if (options === void 0) { options = {}; }
     var validation = validateResolveIOSupportDiagnosisGate(diagnosisGate);
@@ -935,6 +1734,8 @@ function decideResolveIOSupportV5RepairGate(input) {
         blocker: input.blocker,
         evidence: input.evidence,
         evidenceHash: input.evidenceHash,
+        changedFiles: input.changedFiles,
+        artifactPaths: input.artifactPaths,
         limit: Math.max(1, Number(input.maxRepeatedNoProgress || 2) || 2),
         ignoreInfra: true
     }) : undefined;
@@ -1125,7 +1926,7 @@ function buildResolveIOSupportV5ScopeDigest(input) {
     return raw.slice(0, maxChars);
 }
 function buildResolveIOSupportV5MicrotaskLedger(input) {
-    var e_4, _a;
+    var e_7, _a;
     var existing = Array.isArray(input.existing) ? input.existing : [];
     var completedByObjective = new Map();
     try {
@@ -1136,12 +1937,12 @@ function buildResolveIOSupportV5MicrotaskLedger(input) {
             }
         }
     }
-    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
     finally {
         try {
             if (existing_1_1 && !existing_1_1.done && (_a = existing_1.return)) _a.call(existing_1);
         }
-        finally { if (e_4) throw e_4.error; }
+        finally { if (e_7) throw e_7.error; }
     }
     var now = isoNow(input.now);
     var requirements = cleanList(input.requirements, 30, 240);
@@ -1452,6 +2253,8 @@ function decideResolveIOSupportV5Continuation(bundle) {
         failureClass: last.failureClass,
         blocker: last.blocker || last.summary,
         evidenceHash: last.evidenceHash,
+        changedFiles: last.changedFiles,
+        artifactPaths: last.artifactPaths,
         limit: budget.maxRepeatedNoProgress,
         ignoreInfra: true
     }) : null;
@@ -1488,6 +2291,9 @@ function decideResolveIOSupportV5Continuation(bundle) {
         return __assign({ action: 'park', reason: 'support_v5_budget_guard', nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || 'cleanup', repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: budgetExceeded }, recoveryFieldsFor(recoveryPlan_5));
     }
     var lastFailureClass = cleanText(last === null || last === void 0 ? void 0 : last.failureClass, 80).toLowerCase();
+    var materialEvidenceRetryAllowed = (repeatedFailure === null || repeatedFailure === void 0 ? void 0 : repeatedFailure.shouldStop) === false
+        && repeatedFailure.newEvidence === true
+        && repeatedFailure.materialEvidence === true;
     if (repeatedNoProgressCount > budget.maxRepeatedNoProgress && /^(infra|compile)$/.test(lastFailureClass)) {
         var recoveryPlan_6 = recoveryPlanFor('retry_infra', 'support_v5_infra_or_compile_repair_required', {
             failureClass: lastFailureClass,
@@ -1495,24 +2301,24 @@ function decideResolveIOSupportV5Continuation(bundle) {
         });
         return __assign({ action: 'continue', reason: 'support_v5_infra_or_compile_repair_required', nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || 'compile_check', repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: budgetExceeded }, recoveryFieldsFor(recoveryPlan_6));
     }
-    if (repeatedNoProgressCount > budget.maxRepeatedNoProgress) {
-        var recoveryPlan_7 = recoveryPlanFor('park_repeated_failure', 'support_v5_repeated_no_progress', {
+    if (repeatedFailure === null || repeatedFailure === void 0 ? void 0 : repeatedFailure.shouldStop) {
+        var recoveryPlan_7 = recoveryPlanFor(repeatedFailure.reason === 'support_v5_ping_pong_failure_loop' ? 'park_ping_pong' : 'park_repeated_failure', repeatedFailure.reason, {
+            failureClass: repeatedFailure.failureClass,
             productRepairFailure: true
         });
-        return __assign({ action: 'park', reason: 'support_v5_repeated_no_progress', nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || 'cleanup', repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: budgetExceeded }, recoveryFieldsFor(recoveryPlan_7));
+        return __assign({ action: 'park', reason: repeatedFailure.reason, nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || 'cleanup', repeatedNoProgressCount: repeatedFailure.repeatedCount, budgetExceeded: budgetExceeded }, recoveryFieldsFor(recoveryPlan_7));
     }
-    if (repeatedFailure === null || repeatedFailure === void 0 ? void 0 : repeatedFailure.shouldStop) {
-        var recoveryPlan_8 = recoveryPlanFor(repeatedFailure.reason === 'support_v5_ping_pong_failure_loop' ? 'park_ping_pong' : 'park_repeated_failure', repeatedFailure.reason, {
-            failureClass: repeatedFailure.failureClass,
+    if (repeatedNoProgressCount > budget.maxRepeatedNoProgress && !materialEvidenceRetryAllowed) {
+        var recoveryPlan_8 = recoveryPlanFor('park_repeated_failure', 'support_v5_repeated_no_progress', {
             productRepairFailure: true
         });
-        return __assign({ action: 'park', reason: repeatedFailure.reason, nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || 'cleanup', repeatedNoProgressCount: repeatedFailure.repeatedCount, budgetExceeded: budgetExceeded }, recoveryFieldsFor(recoveryPlan_8));
+        return __assign({ action: 'park', reason: 'support_v5_repeated_no_progress', nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || 'cleanup', repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: budgetExceeded }, recoveryFieldsFor(recoveryPlan_8));
     }
     var recoveryPlan = recoveryPlanFor('continue', 'support_v5_continue');
     return __assign({ action: 'continue', reason: 'support_v5_continue', nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || bundle.supportV5SupervisorState.activeStep, repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, recoveryFieldsFor(recoveryPlan));
 }
 function decideResolveIOSupportV5AutonomousNextAction(input) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     var bundle = input.bundle;
     var activeMicrotask = selectResolveIOSupportV5ActiveMicrotask(bundle.supportV5MicrotaskLedger || [], bundle.supportV5ActiveMicrotaskId);
     var diagnosisValidation = validateResolveIOSupportDiagnosisGate(bundle.supportV5DiagnosisGate, {
@@ -1528,6 +2334,7 @@ function decideResolveIOSupportV5AutonomousNextAction(input) {
         evidence: input.evidence,
         evidenceHash: input.evidenceHash,
         history: bundle.supportV5StepHistory,
+        artifactPaths: input.artifactPaths,
         maxOwnerFiles: input.maxOwnerFiles,
         allowTestsOutsideOwnerFiles: true
     });
@@ -1537,19 +2344,153 @@ function decideResolveIOSupportV5AutonomousNextAction(input) {
         outcomeLabel: input.outcomeLabel,
         confidence: input.confidence,
         businessAssertionStatus: input.businessAssertionStatus,
+        businessAssertions: input.businessAssertions,
         businessProofArtifacts: input.businessProofArtifacts,
+        previousProofFingerprint: input.previousProofFingerprint,
+        previousArtifactFingerprint: input.previousArtifactFingerprint,
         unresolvedBlockers: input.unresolvedBlockers,
         releaseStatus: input.releaseStatus
     });
+    var businessProofReadiness = evaluateResolveIOSupportBusinessProofReadiness({
+        diagnosisGate: bundle.supportV5DiagnosisGate,
+        outcomeLabel: input.outcomeLabel,
+        businessAssertionStatus: input.businessAssertionStatus,
+        businessAssertions: input.businessAssertions,
+        businessProofArtifacts: input.businessProofArtifacts,
+        previousProofFingerprint: input.previousProofFingerprint,
+        previousArtifactFingerprint: input.previousArtifactFingerprint
+    });
+    var evidenceFreshness = evaluateResolveIOSupportEvidenceFreshness({
+        history: bundle.supportV5StepHistory,
+        failureClass: input.failureClass,
+        blocker: input.blocker,
+        evidence: input.evidence,
+        evidenceHash: input.evidenceHash,
+        changedFiles: input.changedFiles,
+        artifactPaths: input.artifactPaths || input.businessProofArtifacts,
+        lane: (activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.lane) || 'supervisor',
+        stepType: activeStepType,
+        limit: buildResolveIOSupportV5Budget(bundle.supportV5Budget).maxRepeatedNoProgress,
+        ignoreInfra: true
+    });
     var ownerFiles = ((_a = diagnosisValidation.normalized) === null || _a === void 0 ? void 0 : _a.owner_files) || repairGate.ownerFiles || [];
     var proofContract = (_b = diagnosisValidation.normalized) === null || _b === void 0 ? void 0 : _b.proof_plan.business_proof_contract;
     var expectedProof = (proofContract === null || proofContract === void 0 ? void 0 : proofContract.data_or_dom_assertion)
         || ((_c = diagnosisValidation.normalized) === null || _c === void 0 ? void 0 : _c.proof_plan.business_assertion)
         || (activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.acceptanceProof)
         || '';
+    var issueClassProbes = diagnosisValidation.valid && diagnosisValidation.normalized
+        ? buildResolveIOSupportIssueClassProbes(diagnosisValidation.normalized)
+        : [];
+    var activeIssueClassProbe = issueClassProbes[0];
+    var issueClassProbeEvidence = activeIssueClassProbe
+        ? Array.from(new Set(__spreadArray([
+            "AIQaBusinessAssertion mapped to ".concat(activeIssueClassProbe.issue_class),
+            "state transition: ".concat(activeIssueClassProbe.state_transition.before || 'before', " -> ").concat(activeIssueClassProbe.state_transition.action || activeIssueClassProbe.action, " -> ").concat(activeIssueClassProbe.state_transition.after || 'after')
+        ], __read(activeIssueClassProbe.required_artifacts.map(function (artifact) { return "artifact: ".concat(artifact); })), false)))
+        : [];
+    var buildRootCauseReadiness = function (action, reason, fields, primaryCommand, nextCommands, blockers) {
+        var _a;
+        var statusByAction = {
+            run_diagnosis_gate: 'diagnosis_required',
+            ask_customer_clarification: 'customer_clarification_required',
+            repair_infra_only: 'infra_repair_only',
+            revise_diagnosis_scope: 'scope_revision_required',
+            run_owner_scoped_repair: 'owner_scoped_repair_ready',
+            run_business_proof_qa: 'business_proof_required',
+            repair_release_hotfix_first: 'release_hotfix_required',
+            collect_new_evidence: 'collect_new_evidence',
+            draft_customer_reply: 'customer_reply_draft_ready',
+            ready_for_release_gate: 'release_gate_ready',
+            park_manual: 'parked'
+        };
+        var nextGateByStatus = {
+            diagnosis_required: 'diagnosis',
+            customer_clarification_required: 'customer_reply',
+            infra_repair_only: 'infra',
+            scope_revision_required: 'scope',
+            owner_scoped_repair_ready: 'repair',
+            business_proof_required: 'business_proof',
+            release_hotfix_required: 'release',
+            release_gate_ready: 'release',
+            customer_reply_draft_ready: 'customer_reply',
+            collect_new_evidence: 'evidence',
+            parked: 'manual'
+        };
+        var status = statusByAction[action] || 'parked';
+        var diagnosisValid = diagnosisValidation.valid === true;
+        var ownerFilesReady = diagnosisValid && ownerFiles.length > 0;
+        var proofPlanReady = diagnosisValid && !!proofContract;
+        var rootCauseFirstSatisfied = diagnosisValid && ownerFilesReady && proofPlanReady;
+        var sameFailureParked = evidenceFreshness.mustCollectNewEvidence === true
+            || (action === 'collect_new_evidence' && /repeated|no_progress|ping_pong|same failure|same evidence/i.test(reason));
+        return {
+            status: status,
+            nextGate: nextGateByStatus[status],
+            nextCommand: primaryCommand || nextCommands[0] || action,
+            rootCauseFirstSatisfied: rootCauseFirstSatisfied,
+            diagnosisValid: diagnosisValid,
+            ownerFilesReady: ownerFilesReady,
+            proofPlanReady: proofPlanReady,
+            businessProofReady: businessProofReadiness.ready === true,
+            infraOnly: action === 'repair_infra_only',
+            sameFailureParked: sameFailureParked,
+            canEditProductCode: fields.canEditProductCode === true && rootCauseFirstSatisfied,
+            canRunIssueClassProbe: rootCauseFirstSatisfied && (action === 'run_business_proof_qa' || status === 'business_proof_required'),
+            canRunBusinessProofQa: rootCauseFirstSatisfied && (action === 'run_business_proof_qa' || !businessProofReadiness.ready),
+            canRelease: action === 'ready_for_release_gate' && businessProofReadiness.ready === true,
+            canDraftCustomerReply: (action === 'draft_customer_reply' && businessProofReadiness.ready === true)
+                || action === 'ask_customer_clarification',
+            requiresHumanDecision: action === 'park_manual' || fields.canRunAutonomously !== true,
+            reason: reason,
+            blockers: blockers,
+            ownerFiles: ownerFiles,
+            issueClass: ((_a = diagnosisValidation.normalized) === null || _a === void 0 ? void 0 : _a.issue_class) || repairGate.issueClass,
+            expectedProof: expectedProof,
+            issueClassProbes: issueClassProbes,
+            businessProofStatus: businessProofReadiness.status,
+            proofFingerprint: businessProofReadiness.proofFingerprint,
+            artifactFingerprint: businessProofReadiness.artifactFingerprint,
+            proofFreshness: businessProofReadiness.proofFreshness
+        };
+    };
     var makeDecision = function (action, label, reason, fields) {
         var _a;
-        return ({
+        var primaryCommand = fields.primaryCommand || action;
+        var nextCommands = fields.nextCommands || [primaryCommand];
+        var requiredEvidence = fields.requiredEvidence || [];
+        var blockers = fields.blockers || [];
+        var rootCauseReadiness = buildRootCauseReadiness(action, reason, fields, primaryCommand, nextCommands, blockers);
+        var forbiddenActions = Array.from(new Set(__spreadArray([
+            'Do not send customer email without explicit human approval.',
+            'Do not broaden owner_files without revised diagnosis evidence.',
+            'Do not accept route-load, screenshot-only, scorecard-only, or model-claim proof.'
+        ], __read((fields.forbiddenActions || [])), false)));
+        var humanReviewPacket = fields.humanReviewPacket
+            || (action === 'draft_customer_reply' && customerReplyPolicy.humanReviewPacket ? customerReplyPolicy.humanReviewPacket : undefined)
+            || buildResolveIOSupportHumanReviewPacket({
+                reviewType: supportAutonomousReviewTypeForAction(action),
+                title: label,
+                summary: reason,
+                primaryAction: primaryCommand,
+                customerFacingDraftAllowed: fields.canDraftCustomerReply === true,
+                safety: action === 'draft_customer_reply' ? 'safe_to_draft' : 'internal_hold',
+                reason: reason,
+                blockers: blockers,
+                requiredEvidence: requiredEvidence,
+                evidenceRefs: businessProofReadiness.artifactPaths,
+                nextCommands: nextCommands,
+                forbiddenActions: forbiddenActions,
+                costRisk: fields.canHotfixBackend === true || action === 'draft_customer_reply'
+                    ? 'release_or_customer_send'
+                    : fields.canRunModel === true
+                        ? 'expensive_model'
+                        : fields.canRunQa === true
+                            ? 'small_model_or_qa'
+                            : 'free_or_deterministic',
+                now: input.now
+            });
+        return {
             action: action,
             label: label,
             reason: reason,
@@ -1563,25 +2504,27 @@ function decideResolveIOSupportV5AutonomousNextAction(input) {
             lane: fields.lane || (activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.lane) || 'supervisor',
             stepType: fields.stepType || activeStepType,
             microtaskId: activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.microtaskId,
-            primaryCommand: fields.primaryCommand || action,
-            nextCommands: fields.nextCommands || [fields.primaryCommand || action],
-            requiredEvidence: fields.requiredEvidence || [],
-            forbiddenActions: Array.from(new Set(__spreadArray([
-                'Do not send customer email without explicit human approval.',
-                'Do not broaden owner_files without revised diagnosis evidence.',
-                'Do not accept route-load, screenshot-only, scorecard-only, or model-claim proof.'
-            ], __read((fields.forbiddenActions || [])), false))),
-            blockers: fields.blockers || [],
+            primaryCommand: primaryCommand,
+            nextCommands: nextCommands,
+            requiredEvidence: requiredEvidence,
+            forbiddenActions: forbiddenActions,
+            blockers: blockers,
             ownerFiles: ownerFiles,
             issueClass: ((_a = diagnosisValidation.normalized) === null || _a === void 0 ? void 0 : _a.issue_class) || repairGate.issueClass,
             expectedProof: expectedProof,
+            issueClassProbes: issueClassProbes,
             activeMicrotask: activeMicrotask,
             diagnosisValidation: diagnosisValidation,
             repairGate: repairGate,
             continuation: continuation,
             customerReplyPolicy: customerReplyPolicy,
+            businessProofReadiness: businessProofReadiness,
+            evidenceFreshness: evidenceFreshness,
+            rootCauseReadiness: rootCauseReadiness,
+            humanReviewPacket: humanReviewPacket,
+            hotfixContinuation: fields.hotfixContinuation,
             recordedAt: isoNow(input.now)
-        });
+        };
     };
     if (continuation.action === 'park' && continuation.reason === 'support_v5_budget_guard') {
         return makeDecision('park_manual', 'Park Manual', continuation.reason, {
@@ -1607,6 +2550,25 @@ function decideResolveIOSupportV5AutonomousNextAction(input) {
             forbiddenActions: ['Do not run another product-code repair until blockerFingerprint or evidenceHash changes.']
         });
     }
+    if (customerReplyPolicy.action === 'ask_clarification') {
+        return makeDecision('ask_customer_clarification', 'Ask Customer Clarification', customerReplyPolicy.reason, {
+            canRunAutonomously: false,
+            canRunModel: false,
+            canEditProductCode: false,
+            canDraftCustomerReply: true,
+            lane: 'customer',
+            stepType: 'customer_reply',
+            primaryCommand: ((_d = customerReplyPolicy.humanReviewPacket) === null || _d === void 0 ? void 0 : _d.primaryAction) || 'review_customer_clarification',
+            nextCommands: ((_e = customerReplyPolicy.humanReviewPacket) === null || _e === void 0 ? void 0 : _e.nextCommands) || ['edit_clarification_question', 'send_after_human_review', 'park_ticket_until_customer_reply'],
+            requiredEvidence: customerReplyPolicy.requiredEvidence,
+            blockers: diagnosisValidation.blockers,
+            forbiddenActions: [
+                'Do not run repair from a guessed reproduction path.',
+                'Do not send customer email without explicit human approval.'
+            ],
+            humanReviewPacket: customerReplyPolicy.humanReviewPacket
+        });
+    }
     if (repairGate.action === 'diagnose_only' || (activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.type) === 'diagnosis_gate' || !diagnosisValidation.valid) {
         return makeDecision('run_diagnosis_gate', 'Run Diagnosis Gate', 'support_v5_root_cause_first_required', {
             canRunAutonomously: true,
@@ -1672,17 +2634,59 @@ function decideResolveIOSupportV5AutonomousNextAction(input) {
         });
     }
     if (supportReleaseLooksBlocked(input.releaseStatus)) {
+        var releaseBlocker = cleanList(input.unresolvedBlockers, 20, 500).join('; ')
+            || cleanText(input.blocker || input.releaseStatus, 1000)
+            || 'Support release is blocked.';
+        var hotfixContinuation = (0, ai_runner_manager_policy_1.decideResolveIOAIManagerHotfixContinuation)({
+            evidence: input.hotfixEvidence,
+            policy: input.releasePolicy,
+            releaseGatePassed: input.releaseGatePassed,
+            failureClass: 'release',
+            blocker: releaseBlocker,
+            now: input.now
+        });
+        var hotfixPrimaryCommandByAction = {
+            record_hotfix_evidence: 'record_hotfix_evidence',
+            request_force_deploy_reason: 'request_force_deploy_reason',
+            rerun_release_gate: 'rerun_support_release_gate_once',
+            continue_runner: 'continue_support_runner_after_committed_hotfix',
+            allow_one_full_deploy: 'execute_one_full_deploy_with_force_evidence',
+            park_manual: 'park_support_release_manual'
+        };
+        var hotfixNextCommands = Array.from(new Set(__spreadArray(__spreadArray([
+            'classify_release_blocker',
+            'prepare_hotfix_patch_without_live_apply',
+            'commit_and_push_hotfix_to_github',
+            'record_github_commit_for_hotfix'
+        ], __read(hotfixContinuation.nextCommands), false), [
+            'apply_backend_hotfix_only_after_commit_proof',
+            'rerun_release_gate_once'
+        ], false)));
+        var hotfixRequiredEvidence = Array.from(new Set(__spreadArray([
+            'hotfix evidence',
+            'full sourceCommitSha, githubCommitUrl, and passed gitPushStatus for the exact pushed GitHub commit',
+            'checksum before/after',
+            'health/self-test pass',
+            'release gate result'
+        ], __read(hotfixContinuation.requiredEvidence), false)));
+        var hotfixForbiddenActions = [
+            'Do not apply a live hotfix before the exact diff is committed and pushed to GitHub.',
+            'Do not mark a hotfix durable without sourceCommitSha, githubCommitUrl, and passed gitPushStatus.',
+            'Do not run a full deploy to clear a duplicate release loop unless force evidence explicitly allows one.'
+        ];
         return makeDecision('repair_release_hotfix_first', 'Hotfix Release', 'support_v5_release_blocked_hotfix_first', {
-            canRunAutonomously: true,
+            canRunAutonomously: hotfixContinuation.action !== 'park_manual',
             canRunModel: false,
             canEditProductCode: false,
-            canHotfixBackend: true,
+            canHotfixBackend: hotfixContinuation.action !== 'park_manual',
             lane: 'release',
             stepType: 'release_gate',
-            primaryCommand: 'run_support_release_hotfix_first_gate',
-            nextCommands: ['classify_release_blocker', 'hotfix_backend_or_release_artifact', 'record_github_commit_for_hotfix', 'rerun_release_gate_once'],
-            requiredEvidence: ['hotfix evidence', 'sourceCommitSha and githubCommitUrl', 'health/self-test pass', 'release gate result'],
-            blockers: cleanList(input.unresolvedBlockers, 20, 500)
+            primaryCommand: hotfixPrimaryCommandByAction[hotfixContinuation.action] || 'record_hotfix_evidence',
+            nextCommands: hotfixNextCommands,
+            requiredEvidence: hotfixRequiredEvidence,
+            blockers: Array.from(new Set(__spreadArray(__spreadArray([], __read(cleanList(input.unresolvedBlockers, 20, 500)), false), __read(hotfixContinuation.blockers), false))),
+            forbiddenActions: hotfixForbiddenActions,
+            hotfixContinuation: hotfixContinuation
         });
     }
     if ((activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.lane) === 'qa' || /^(qa_row|qa_retest|business_proof|route_probe|issue_class_probe)$/.test(activeStepType)) {
@@ -1695,7 +2699,7 @@ function decideResolveIOSupportV5AutonomousNextAction(input) {
             stepType: /^(qa_row|qa_retest|business_proof|route_probe|issue_class_probe)$/.test(activeStepType) ? activeStepType : 'qa_row',
             primaryCommand: 'run_support_v5_business_proof_qa_row',
             nextCommands: ['start_local_stack_if_needed', 'execute_issue_class_probe', 'record_before_action_after_artifacts', 'write_aiqa_business_assertion'],
-            requiredEvidence: ['AIQaBusinessAssertion pass', 'DOM/data proof', 'artifact path', 'Mongo delta when data-changing'],
+            requiredEvidence: Array.from(new Set(__spreadArray(['AIQaBusinessAssertion pass', 'DOM/data proof', 'artifact path', 'Mongo delta when data-changing'], __read(issueClassProbeEvidence), false))),
             forbiddenActions: ['Route probe pass alone remains route evidence only.']
         });
     }
@@ -1712,7 +2716,22 @@ function decideResolveIOSupportV5AutonomousNextAction(input) {
             forbiddenActions: ['Draft only; do not send.']
         });
     }
-    if (!activeMicrotask && supportBusinessAssertionPassed(input.businessAssertionStatus || input.outcomeLabel)) {
+    if (!activeMicrotask && diagnosisValidation.valid && !businessProofReadiness.ready) {
+        return makeDecision('run_business_proof_qa', 'Run Business Proof QA', businessProofReadiness.reason, {
+            canRunAutonomously: true,
+            canRunQa: true,
+            canRunModel: false,
+            canEditProductCode: false,
+            lane: 'qa',
+            stepType: 'business_proof',
+            primaryCommand: 'run_support_v5_business_proof_qa_row',
+            nextCommands: ['execute_issue_class_probe', 'record_before_action_after_artifacts', 'write_aiqa_business_assertion'],
+            requiredEvidence: Array.from(new Set(__spreadArray(__spreadArray([], __read(businessProofReadiness.requiredEvidence), false), __read(issueClassProbeEvidence), false))),
+            blockers: businessProofReadiness.blockers,
+            forbiddenActions: ['Do not run release or customer reply until businessProofReadiness.ready=true.']
+        });
+    }
+    if (!activeMicrotask && businessProofReadiness.ready) {
         return makeDecision('ready_for_release_gate', 'Run Release Gate', 'support_v5_business_proof_complete_release_gate_ready', {
             canRunAutonomously: true,
             canRunQa: true,
@@ -1758,7 +2777,7 @@ function buildResolveIOSupportV5DiagnoseFirstPrompt(lines) {
     ].filter(Boolean);
 }
 function buildResolveIOSupportV5MicrotaskPrompt(input) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g;
     var activeMicrotask = selectResolveIOSupportV5ActiveMicrotask(input.bundle.supportV5MicrotaskLedger || [], input.bundle.supportV5ActiveMicrotaskId);
     var diagnosisValidation = validateResolveIOSupportDiagnosisGate(input.bundle.supportV5DiagnosisGate);
     var diagnosisGate = diagnosisValidation.normalized || input.bundle.supportV5DiagnosisGate;
@@ -1781,6 +2800,39 @@ 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 similarCaseSelection = Array.isArray(input.similarCaseHints)
+        ? selectResolveIOSupportSimilarCaseHints({
+            candidates: input.similarCaseHints,
+            issueClass: diagnosisGate === null || diagnosisGate === void 0 ? void 0 : diagnosisGate.issue_class,
+            ownerFiles: diagnosisGate === null || diagnosisGate === void 0 ? void 0 : diagnosisGate.owner_files,
+            text: input.bundle.supportV5ScopeDigest || input.bundle.supportV5SupervisorState.currentGoal,
+            limit: 5
+        })
+        : input.similarCaseHints && typeof input.similarCaseHints === 'object'
+            ? {
+                ranked: cleanObject(input.similarCaseHints).ranked || [],
+                similarTickets: cleanObject(input.similarCaseHints).similarTickets || cleanObject(input.similarCaseHints).similar_tickets || [],
+                similarCommits: cleanObject(input.similarCaseHints).similarCommits || cleanObject(input.similarCaseHints).similar_commits || [],
+                ignoredCount: Number(cleanObject(input.similarCaseHints).ignoredCount || cleanObject(input.similarCaseHints).ignored_count || 0),
+                generatedAt: cleanText(cleanObject(input.similarCaseHints).generatedAt || cleanObject(input.similarCaseHints).generated_at, 120)
+            }
+            : undefined;
+    var similarCaseHintsText = ((_d = similarCaseSelection === null || similarCaseSelection === void 0 ? void 0 : similarCaseSelection.ranked) === null || _d === void 0 ? void 0 : _d.length)
+        ? __spreadArray([
+            'Similar accepted fix hints. Advisory only: use these to prioritize inspection paths, not as proof.'
+        ], __read(similarCaseSelection.ranked.slice(0, 5).map(function (hint, index) {
+            var _a;
+            return [
+                "".concat(index + 1, ". source=").concat(hint.source || 'unknown', " score=").concat(Number(hint.score || 0)),
+                hint.ticketNumber ? "ticket=".concat(hint.ticketNumber) : '',
+                hint.commitSha ? "commit=".concat(hint.commitSha) : '',
+                hint.issueClass ? "issue_class=".concat(hint.issueClass) : '',
+                ((_a = hint.ownerFiles) === null || _a === void 0 ? void 0 : _a.length) ? "owner_files=".concat(hint.ownerFiles.slice(0, 4).join(', ')) : '',
+                hint.reason ? "signals=".concat(hint.reason) : '',
+                hint.title ? "title=".concat(cleanText(hint.title, 180)) : ''
+            ].filter(Boolean).join(' | ');
+        })), false).join('\n')
+        : '';
     var qaRow = input.activeQaRow || (activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.lane) === 'qa'
         ? input.activeQaRow || laneMemory.activeQaRow || input.bundle.supportV5SupervisorState.currentQaRow
         : undefined;
@@ -1822,11 +2874,15 @@ function buildResolveIOSupportV5MicrotaskPrompt(input) {
                 "Owner files: ".concat(diagnosisGate.owner_files.join(', ')),
                 "Business proof required: ".concat(diagnosisGate.proof_plan.business_assertion),
                 diagnosisGate.proof_plan.business_proof_contract
-                    ? "Business proof contract: ".concat((_d = diagnosisGate.proof_plan.business_proof_contract) === null || _d === void 0 ? void 0 : _d.action_under_test, " -> ").concat((_e = diagnosisGate.proof_plan.business_proof_contract) === null || _e === void 0 ? void 0 : _e.expected_business_state_change, "; assertion ").concat((_f = diagnosisGate.proof_plan.business_proof_contract) === null || _f === void 0 ? void 0 : _f.data_or_dom_assertion)
+                    ? "Business proof contract: ".concat((_e = diagnosisGate.proof_plan.business_proof_contract) === null || _e === void 0 ? void 0 : _e.action_under_test, " -> ").concat((_f = diagnosisGate.proof_plan.business_proof_contract) === null || _f === void 0 ? void 0 : _f.expected_business_state_change, "; assertion ").concat((_g = diagnosisGate.proof_plan.business_proof_contract) === null || _g === void 0 ? void 0 : _g.data_or_dom_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.'
         },
+        diagnosisActive && similarCaseHintsText ? {
+            name: 'similar_accepted_fix_hints',
+            text: similarCaseHintsText
+        } : undefined,
         {
             name: 'scope_digest',
             text: cleanText(input.bundle.supportV5ScopeDigest || input.bundle.supportV5SupervisorState.approvedScope, 900)
@@ -1872,6 +2928,7 @@ function buildResolveIOSupportV5MicrotaskPrompt(input) {
                 'Launch Puppeteer from `PUPPETEER_EXECUTABLE_PATH || CHROME_BIN`, seed localStorage from `qa-artifacts/auth-bootstrap-storage-state.json`, then navigate to the active QA route.',
                 'Before passing, confirm `qa-artifacts/auth-bootstrap-result.json` used the ticket reporter or named affected user when available. If it used generic admin/dev while `qa-live-data-seed-result.json.selected.qa_user_context` names a reporter/affected user, rerun auth as that user or return needs-fix.',
                 'Drive the visible customer workflow for this one row. Capture a new customer-facing screenshot/caption and update `qa-artifacts/qa-coverage-matrix.json` with workflow, route, data id/name, assertion, screenshot path, caption, and pass/failed/blocked status.',
+                'Also write `qa-artifacts/aiqa-business-assertion.json` with one AIQaBusinessAssertion object: assertion, status, workflow, route, before, action, expected, after/observed, dataProof or mongoDelta, artifactPaths, and metadata.supportDiagnosisProof=true only when it maps to the active SupportDiagnosisGate proof_plan.',
                 'After selecting any From/To, source/target, dropdown, combobox, rio-select, filter, item, customer, yard, chemical, or treatment-plan value, read the visible control text back from the DOM. If it still contains placeholder text such as Select Chemical, Select Yard, Select Customer, Select Treatment Plan Type, Loading..., empty, null, or undefined, do not click the action button and do not mark pass. Capture the selected-state blocker screenshot/DOM text and return needs-fix.',
                 'If the row needs persisted data proof, create that proof yourself in the same bounded QA command by querying localhost QA Mongo through process.env.MONGO_URL after the visible UI action. Write the result under qa-artifacts/ as JSON and reference that path in the matrix. Do not ask for a missing post-action DB artifact while the local QA stack is running; either write it or return needs-fix with the exact query/script error. For update-interchangeables rows, the JSON must include concrete non-placeholder fromText and toText, before/after counts or sample documents for treatment plans and tank/interchangeable records, and must fail if either selected value is only an arrow/placeholder or if the persisted collections are empty.',
                 'If the row names multiple concrete entities such as assets, units, BOLs, invoices, chemicals, customers, yards, or numbered records, prove every named entity. Do not pass by proving only one representative record.',
@@ -1891,7 +2948,7 @@ function buildResolveIOSupportV5MicrotaskPrompt(input) {
                     ? '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); });
+    ].filter(function (section) { return !!section && !!cleanText(section.text, 20); });
     var promptSections = sections.map(function (section) { return ({
         name: section.name,
         tokenEstimate: estimateTextTokens(section.text)
@@ -1915,7 +2972,7 @@ function buildResolveIOSupportV5MicrotaskPrompt(input) {
     };
 }
 function summarizeResolveIOSupportV5MicrotaskUsage(bundle) {
-    var e_5, _a, e_6, _b;
+    var e_8, _a, e_9, _b;
     var byMicrotask = new Map();
     var bySection = new Map();
     var totalPromptTokenEstimate = 0;
@@ -1930,17 +2987,17 @@ function summarizeResolveIOSupportV5MicrotaskUsage(bundle) {
             existing.calls += 1;
             byMicrotask.set(usage.microtaskId, existing);
             try {
-                for (var _e = (e_6 = void 0, __values(usage.promptSections || [])), _f = _e.next(); !_f.done; _f = _e.next()) {
+                for (var _e = (e_9 = 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_6_1) { e_6 = { error: e_6_1 }; }
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
             finally {
                 try {
                     if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
                 }
-                finally { if (e_6) throw e_6.error; }
+                finally { if (e_9) throw e_9.error; }
             }
             var hardCap = usage.lane === 'qa' ? promptBudget.qaMicrotaskHardCap : promptBudget.buildMicrotaskHardCap;
             if ((usage.promptTokenEstimate || 0) > hardCap) {
@@ -1948,12 +3005,12 @@ function summarizeResolveIOSupportV5MicrotaskUsage(bundle) {
             }
         }
     }
-    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
     finally {
         try {
             if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
         }
-        finally { if (e_5) throw e_5.error; }
+        finally { if (e_8) throw e_8.error; }
     }
     return {
         totalPromptTokenEstimate: totalPromptTokenEstimate,