@resolveio/server-lib 22.3.198 → 22.3.200

package/util/ai-run-evidence-adapters.js

@@ -1819,6 +1819,34 @@ function buildSupportQaEvidence(input) {
     if (Object.keys(managerRecoveryExecutionProof).length) {
         evidence.managerRecoveryExecutionProof = managerRecoveryExecutionProof;
     }
+    var autonomyApproval = supportAutonomyApprovalObject(ticket, job, evidence);
+    var productRepairDispatchGuard = supportProductRepairDispatchGuardObject(ticket, job, evidence);
+    var humanDecisionRequest = supportHumanDecisionRequestObject(ticket, job, evidence);
+    var managerContinuation = supportManagerContinuationObject(ticket, job, evidence);
+    var prReadinessContract = supportPrReadinessContractObject(ticket, job, evidence);
+    var prReviewContract = supportPrReviewContractObject(ticket, job, evidence);
+    var prCreationResult = supportPrCreationResultObject(ticket, job, evidence);
+    if (Object.keys(autonomyApproval).length) {
+        evidence.supportV5AutonomyApproval = autonomyApproval;
+    }
+    if (Object.keys(productRepairDispatchGuard).length) {
+        evidence.supportProductRepairDispatchGuard = productRepairDispatchGuard;
+    }
+    if (Object.keys(humanDecisionRequest).length) {
+        evidence.supportHumanDecisionRequest = humanDecisionRequest;
+    }
+    if (Object.keys(managerContinuation).length) {
+        evidence.supportManagerContinuation = managerContinuation;
+    }
+    if (Object.keys(prReadinessContract).length) {
+        evidence.supportPrReadinessContract = prReadinessContract;
+    }
+    if (Object.keys(prReviewContract).length) {
+        evidence.supportPrReviewContract = prReviewContract;
+    }
+    if (Object.keys(prCreationResult).length) {
+        evidence.supportPrCreationResult = prCreationResult;
+    }
     if (Object.keys(preflightGate).length) {
         evidence.supportV5PreflightGate = preflightGate;
         applySupportPreflightGateToQaEvidence(evidence, preflightGate);
@@ -2083,6 +2111,1673 @@ function supportCustomerReplyReadinessGate(contract, now) {
         }
     };
 }
+function supportProofBackedCustomerReplySendObject(ticket, job, evidence) {
+    var ticketAutomation = plainObject(ticket.automation);
+    var ticketReplyPolicy = plainObject(ticketAutomation.customer_reply_policy || ticketAutomation.customerReplyPolicy);
+    var jobReplyPolicy = plainObject(job.customerReplyPolicy || job.customer_reply_policy);
+    return evidenceObject(evidence.proofBackedCustomerReply, evidence.proof_backed_customer_reply, evidence.customerReplySendContract, evidence.customer_reply_send_contract, evidence.supportProofBackedCustomerReplySendContract, evidence.support_proof_backed_customer_reply_send_contract, job.proofBackedCustomerReply, job.proof_backed_customer_reply, job.customerReplySendContract, job.customer_reply_send_contract, job.supportProofBackedCustomerReplySendContract, job.support_proof_backed_customer_reply_send_contract, jobReplyPolicy.last_proof_backed_send_contract, jobReplyPolicy.lastProofBackedSendContract, jobReplyPolicy.last_manual_send, jobReplyPolicy.lastManualSend, ticketReplyPolicy.last_proof_backed_send_contract, ticketReplyPolicy.lastProofBackedSendContract, ticketReplyPolicy.last_manual_send, ticketReplyPolicy.lastManualSend);
+}
+function supportCustomerReplySendGuardObject(ticket, job, evidence) {
+    var ticketAutomation = plainObject(ticket.automation);
+    var ticketReplyPolicy = plainObject(ticketAutomation.customer_reply_policy || ticketAutomation.customerReplyPolicy);
+    var jobReplyPolicy = plainObject(job.customerReplyPolicy || job.customer_reply_policy);
+    var evidenceReplyPolicy = plainObject(evidence.customerReplyPolicy || evidence.customer_reply_policy);
+    var sendContract = supportProofBackedCustomerReplySendObject(ticket, job, evidence);
+    return evidenceObject(evidence.customerReplySendGuard, evidence.customer_reply_send_guard, evidence.supportCustomerReplySendGuard, evidence.support_customer_reply_send_guard, evidenceReplyPolicy.last_send_guard, evidenceReplyPolicy.lastSendGuard, evidenceReplyPolicy.last_blocked_send_guard, evidenceReplyPolicy.lastBlockedSendGuard, job.customerReplySendGuard, job.customer_reply_send_guard, job.supportCustomerReplySendGuard, job.support_customer_reply_send_guard, jobReplyPolicy.last_send_guard, jobReplyPolicy.lastSendGuard, jobReplyPolicy.last_blocked_send_guard, jobReplyPolicy.lastBlockedSendGuard, ticketReplyPolicy.last_send_guard, ticketReplyPolicy.lastSendGuard, ticketReplyPolicy.last_blocked_send_guard, ticketReplyPolicy.lastBlockedSendGuard, sendContract.send_guard, sendContract.sendGuard);
+}
+function supportProofBackedCustomerReplySendGate(sendContract, sendGuard, now) {
+    if ((!sendContract || !Object.keys(sendContract).length) && (!sendGuard || !Object.keys(sendGuard).length)) {
+        return undefined;
+    }
+    var contract = plainObject(sendContract.send_contract || sendContract.sendContract || sendContract);
+    var guard = plainObject(sendGuard.send_guard || sendGuard.sendGuard || sendGuard || contract.send_guard || contract.sendGuard);
+    var statusText = cleanText(contract.status || guard.status, 160).toLowerCase();
+    var sentAfterManualApproval = /sent_after_manual_approval|manual_send_complete|sent/.test(statusText);
+    var guardAllowed = guard.allowed === true || /ready_for_manual_send|allowed/.test(cleanText(guard.status, 160));
+    var directSendAllowed = guard.direct_send_allowed === true || guard.directSendAllowed === true || contract.direct_send_allowed === true || contract.directSendAllowed === true;
+    var requiresHumanApproval = guard.requires_human_approval !== false
+        && guard.requiresHumanApproval !== false
+        && contract.requires_human_approval !== false
+        && contract.requiresHumanApproval !== false;
+    var proofBacked = guard.proof_backed === true || guard.proofBacked === true || contract.proof_backed === true || contract.proofBacked === true;
+    var businessProofReady = guard.business_proof_ready === true || guard.businessProofReady === true || contract.business_proof_ready === true || contract.businessProofReady === true;
+    var releaseReady = guard.release_ready === true || guard.releaseReady === true || contract.release_ready === true || contract.releaseReady === true;
+    var diagnosisReady = guard.diagnosis_ready === true || guard.diagnosisReady === true || contract.diagnosis_ready === true || contract.diagnosisReady === true;
+    var probePlanReady = guard.issue_class_probe_plan_ready === true || guard.issueClassProbePlanReady === true || contract.issue_class_probe_plan_ready === true || contract.issueClassProbePlanReady === true;
+    var pullRequestUrl = cleanText(contract.pull_request_url || contract.pullRequestUrl || guard.pull_request_url || guard.pullRequestUrl, 500);
+    var blockers = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray([], __read(cleanStringList(guard.blockers, 40, 500)), false), __read(cleanStringList(contract.blockers, 40, 500)), false), [
+        directSendAllowed ? 'Direct customer send is not allowed; proof-backed replies require manual review/send.' : '',
+        requiresHumanApproval ? '' : 'Proof-backed customer reply must require human approval.',
+        (sentAfterManualApproval || guardAllowed) && !proofBacked ? 'Customer reply is not proof-backed.' : '',
+        (sentAfterManualApproval || guardAllowed) && !businessProofReady ? 'AIQaBusinessAssertion business proof is not ready.' : '',
+        (sentAfterManualApproval || guardAllowed) && !releaseReady ? 'Release or hotfix proof is not ready.' : '',
+        (sentAfterManualApproval || guardAllowed) && !diagnosisReady ? 'Root-cause diagnosis is not ready.' : '',
+        (sentAfterManualApproval || guardAllowed) && !probePlanReady ? 'Issue-class probe plan is not ready.' : '',
+        (sentAfterManualApproval || guardAllowed) && !pullRequestUrl ? 'Proof-backed customer reply is missing the current PR reference.' : ''
+    ], false).filter(Boolean)));
+    var status = sentAfterManualApproval && blockers.length === 0
+        ? 'pass'
+        : guardAllowed && blockers.length === 0
+            ? 'warn'
+            : 'blocked';
+    return {
+        key: 'support_proof_backed_customer_reply_send',
+        label: 'Support proof-backed customer reply send',
+        status: status,
+        reason: status === 'pass'
+            ? 'Proof-backed customer reply was sent after manual approval with PR, business proof, release, diagnosis, and issue-class probe evidence.'
+            : status === 'warn'
+                ? 'Proof-backed customer reply is ready for manual review/send; automatic direct send remains blocked.'
+                : blockers.join('; ') || cleanText(guard.policy_reason || contract.reason || 'Proof-backed customer reply send is blocked.', 1200),
+        evidenceRefs: cleanStringList(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(asArray(contract.evidence_refs || contract.evidenceRefs)), false), __read(asArray(guard.evidence_refs || guard.evidenceRefs)), false), __read(asArray(contract.required_evidence || contract.requiredEvidence)), false), [
+            pullRequestUrl
+        ], false), 80, 500),
+        recordedAt: isoNow(now || contract.sent_at || contract.sentAt || contract.checked_at || contract.checkedAt || guard.checked_at || guard.checkedAt),
+        metadata: {
+            contractId: cleanText(contract.contract_id || contract.contractId, 180),
+            status: cleanText(contract.status || guard.status, 160),
+            guardStatus: cleanText(guard.status, 160),
+            allowed: guardAllowed,
+            sentAfterManualApproval: sentAfterManualApproval,
+            directSendAllowed: directSendAllowed,
+            manualSendAfterReviewAllowed: guard.manual_send_after_review_allowed === true || guard.manualSendAfterReviewAllowed === true || sentAfterManualApproval,
+            requiresHumanApproval: requiresHumanApproval,
+            proofBacked: proofBacked,
+            businessProofReady: businessProofReady,
+            releaseReady: releaseReady,
+            diagnosisReady: diagnosisReady,
+            issueClassProbePlanReady: probePlanReady,
+            confidenceLevel: cleanText(guard.confidence_level || guard.confidenceLevel || contract.confidence_level || contract.confidenceLevel, 120),
+            nextAction: cleanText(guard.next_action || guard.nextAction, 160),
+            pullRequestUrl: pullRequestUrl,
+            jobId: cleanText(contract.job_id || contract.jobId || guard.job_id || guard.jobId, 180),
+            readinessContractId: cleanText(contract.readiness_contract_id || contract.readinessContractId || guard.readiness_contract_id || guard.readinessContractId, 180),
+            readinessStatus: cleanText(contract.readiness_status || contract.readinessStatus || guard.readiness_status || guard.readinessStatus, 160),
+            messageHash: cleanText(contract.message_hash || contract.messageHash, 180),
+            recipients: cleanStringList(contract.recipients, 20, 240),
+            requiredEvidence: cleanStringList(contract.required_evidence || contract.requiredEvidence || guard.required_evidence || guard.requiredEvidence, 40, 500),
+            blockers: blockers
+        }
+    };
+}
+function supportAutonomyDecisionObject(ticket, job, evidence) {
+    return plainObject(job.supportV5AutonomousDecision
+        || job.support_v5_autonomous_decision
+        || evidence.supportV5AutonomousDecision
+        || evidence.support_v5_autonomous_decision
+        || ticket.supportV5AutonomousDecision
+        || ticket.support_v5_autonomous_decision);
+}
+function supportAutonomyApprovalObject(ticket, job, evidence) {
+    var ticketAutomation = plainObject(ticket.automation);
+    var ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
+    var runnerConsole = plainObject(ticketAutomation.runner_console || ticketAutomation.runnerConsole);
+    var autonomousDecision = supportAutonomyDecisionObject(ticket, job, evidence);
+    return evidenceObject(job.supportV5AutonomyApproval, job.support_v5_autonomy_approval, job.autonomyApproval, job.autonomy_approval, evidence.supportV5AutonomyApproval, evidence.support_v5_autonomy_approval, evidence.autonomyApproval, evidence.autonomy_approval, autonomousDecision.autonomyApproval, autonomousDecision.autonomy_approval, ticket.supportV5AutonomyApproval, ticket.support_v5_autonomy_approval, ticket.autonomyApproval, ticket.autonomy_approval, runnerConsole.autonomy_approval, runnerConsole.autonomyApproval, ticketManager.autonomy_approval, ticketManager.autonomyApproval);
+}
+function supportProductRepairDispatchGuardObject(ticket, job, evidence) {
+    var ticketAutomation = plainObject(ticket.automation);
+    var ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
+    var runnerConsole = plainObject(ticketAutomation.runner_console || ticketAutomation.runnerConsole);
+    var autonomousDecision = supportAutonomyDecisionObject(ticket, job, evidence);
+    var recovery = plainObject(autonomousDecision.managerRecovery || autonomousDecision.manager_recovery);
+    var directive = plainObject(recovery.directive);
+    return evidenceObject(job.supportProductRepairDispatchGuard, job.support_product_repair_dispatch_guard, job.productRepairDispatchGuard, job.product_repair_dispatch_guard, evidence.supportProductRepairDispatchGuard, evidence.support_product_repair_dispatch_guard, evidence.productRepairDispatchGuard, evidence.product_repair_dispatch_guard, autonomousDecision.productRepairDispatchGuard, autonomousDecision.product_repair_dispatch_guard, recovery.productRepairDispatchGuard, recovery.product_repair_dispatch_guard, directive.productRepairDispatchGuard, directive.product_repair_dispatch_guard, ticket.supportProductRepairDispatchGuard, ticket.support_product_repair_dispatch_guard, ticket.productRepairDispatchGuard, ticket.product_repair_dispatch_guard, runnerConsole.last_product_repair_dispatch_guard, runnerConsole.lastProductRepairDispatchGuard, runnerConsole.product_repair_dispatch_guard, runnerConsole.productRepairDispatchGuard, ticketManager.last_product_repair_dispatch_guard, ticketManager.lastProductRepairDispatchGuard, ticketManager.product_repair_dispatch_guard, ticketManager.productRepairDispatchGuard);
+}
+function supportAutoloopApprovalBlockObject(ticket, job, evidence) {
+    var ticketAutomation = plainObject(ticket.automation);
+    var ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
+    var runnerConsole = plainObject(ticketAutomation.runner_console || ticketAutomation.runnerConsole);
+    var autoloop = plainObject(ticketAutomation.autoloop || ticket.autoloop);
+    return evidenceObject(job.supportAutoloopApprovalBlock, job.support_autoloop_approval_block, job.autoloopApprovalBlock, job.autoloop_approval_block, evidence.supportAutoloopApprovalBlock, evidence.support_autoloop_approval_block, evidence.autoloopApprovalBlock, evidence.autoloop_approval_block, ticket.supportAutoloopApprovalBlock, ticket.support_autoloop_approval_block, ticket.autoloopApprovalBlock, ticket.autoloop_approval_block, autoloop.last_approval_block, autoloop.lastApprovalBlock, autoloop.approval_block, autoloop.approvalBlock, runnerConsole.last_autoloop_approval_block, runnerConsole.lastAutoloopApprovalBlock, ticketManager.last_autoloop_approval_block, ticketManager.lastAutoloopApprovalBlock);
+}
+function supportAutoloopNoProgressObject(ticket, job, evidence) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+    var ticketAutomation = plainObject(ticket.automation);
+    var ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
+    var runnerConsole = plainObject(ticketAutomation.runner_console || ticketAutomation.runnerConsole);
+    var autoloop = plainObject(ticketAutomation.autoloop || ticket.autoloop);
+    var explicit = evidenceObject(job.supportAutoloopNoProgress, job.support_autoloop_no_progress, job.autoloopNoProgress, job.autoloop_no_progress, evidence.supportAutoloopNoProgress, evidence.support_autoloop_no_progress, evidence.autoloopNoProgress, evidence.autoloop_no_progress, ticket.supportAutoloopNoProgress, ticket.support_autoloop_no_progress, ticket.autoloopNoProgress, ticket.autoloop_no_progress, autoloop.last_no_progress_block, autoloop.lastNoProgressBlock, autoloop.no_progress_block, autoloop.noProgressBlock, runnerConsole.last_autoloop_no_progress, runnerConsole.lastAutoloopNoProgress, ticketManager.last_autoloop_no_progress, ticketManager.lastAutoloopNoProgress);
+    var history = asArray(explicit.history || autoloop.history)
+        .map(function (entry) { return plainObject(entry); })
+        .filter(function (entry) { return Object.keys(entry).length > 0; })
+        .slice(-12);
+    if (Object.keys(explicit).length) {
+        return __assign(__assign({ source: 'support_autoloop_no_progress' }, explicit), { status: explicit.status || autoloop.status, run_id: explicit.run_id || explicit.runId || autoloop.run_id || autoloop.runId, handoff_required: (_c = (_b = (_a = explicit.handoff_required) !== null && _a !== void 0 ? _a : explicit.handoffRequired) !== null && _b !== void 0 ? _b : autoloop.handoff_required) !== null && _c !== void 0 ? _c : autoloop.handoffRequired, no_progress_streak: (_f = (_e = (_d = explicit.no_progress_streak) !== null && _d !== void 0 ? _d : explicit.noProgressStreak) !== null && _e !== void 0 ? _e : autoloop.no_progress_streak) !== null && _f !== void 0 ? _f : autoloop.noProgressStreak, last_progress_signal: (_j = (_h = (_g = explicit.last_progress_signal) !== null && _g !== void 0 ? _g : explicit.lastProgressSignal) !== null && _h !== void 0 ? _h : autoloop.last_progress_signal) !== null && _j !== void 0 ? _j : autoloop.lastProgressSignal, last_progress_reasons: explicit.last_progress_reasons || explicit.lastProgressReasons || autoloop.last_progress_reasons || autoloop.lastProgressReasons, last_evidence_changed: (_m = (_l = (_k = explicit.last_evidence_changed) !== null && _k !== void 0 ? _k : explicit.lastEvidenceChanged) !== null && _l !== void 0 ? _l : explicit.evidence_changed) !== null && _m !== void 0 ? _m : explicit.evidenceChanged, last_evidence_reasons: explicit.last_evidence_reasons || explicit.lastEvidenceReasons || explicit.evidence_reasons || explicit.evidenceReasons, last_strict_gate_reason: explicit.last_strict_gate_reason || explicit.lastStrictGateReason || autoloop.last_strict_gate_reason || autoloop.lastStrictGateReason, last_error: explicit.last_error || explicit.lastError || autoloop.last_error || autoloop.lastError, last_continuation_decision: explicit.last_continuation_decision || explicit.lastContinuationDecision || autoloop.last_continuation_decision || autoloop.lastContinuationDecision, last_continuation_dispatch: explicit.last_continuation_dispatch || explicit.lastContinuationDispatch || autoloop.last_continuation_dispatch || autoloop.lastContinuationDispatch, history: history, latest_history: plainObject(explicit.latest_history || explicit.latestHistory || history[history.length - 1]), cost: explicit.cost || autoloop.cost, recorded_at: explicit.recorded_at || explicit.recordedAt || autoloop.updated_at || autoloop.updatedAt || autoloop.last_iteration_at || autoloop.lastIterationAt });
+    }
+    var latestHistory = plainObject(history[history.length - 1]);
+    var noProgressStreak = Math.max(0, Number(autoloop.no_progress_streak || autoloop.noProgressStreak || 0) || 0);
+    var lastProgressSignal = booleanFlag((_q = (_p = (_o = autoloop.last_progress_signal) !== null && _o !== void 0 ? _o : autoloop.lastProgressSignal) !== null && _p !== void 0 ? _p : latestHistory.progress_signal) !== null && _q !== void 0 ? _q : latestHistory.progressSignal);
+    var latestEvidenceChanged = booleanFlag((_t = (_s = (_r = autoloop.last_evidence_changed) !== null && _r !== void 0 ? _r : autoloop.lastEvidenceChanged) !== null && _s !== void 0 ? _s : latestHistory.evidence_changed) !== null && _t !== void 0 ? _t : latestHistory.evidenceChanged);
+    var lastError = cleanText(autoloop.last_error || autoloop.lastError || latestHistory.error, 2000);
+    var noProgressError = /no[-_\s]?progress|no new diff|no new .*evidence|without progress|retry blocked|same failure/i.test(lastError);
+    if (noProgressStreak <= 0
+        && lastProgressSignal !== false
+        && latestEvidenceChanged !== false
+        && !noProgressError) {
+        return {};
+    }
+    return {
+        source: 'support_autoloop_no_progress',
+        status: cleanText(autoloop.status, 120),
+        run_id: autoloop.run_id || autoloop.runId,
+        handoff_required: autoloop.handoff_required === true || autoloop.handoffRequired === true,
+        no_progress_streak: noProgressStreak,
+        last_progress_signal: lastProgressSignal,
+        last_progress_reasons: autoloop.last_progress_reasons || autoloop.lastProgressReasons || latestHistory.progress_reasons || latestHistory.progressReasons,
+        last_evidence_changed: latestEvidenceChanged,
+        last_evidence_reasons: autoloop.last_evidence_reasons || autoloop.lastEvidenceReasons || latestHistory.evidence_reasons || latestHistory.evidenceReasons,
+        last_strict_gate_reason: autoloop.last_strict_gate_reason || autoloop.lastStrictGateReason || latestHistory.strict_gate_reason || latestHistory.strictGateReason,
+        last_error: lastError,
+        last_continuation_decision: autoloop.last_continuation_decision || autoloop.lastContinuationDecision || latestHistory.continuation_decision || latestHistory.continuationDecision,
+        last_continuation_dispatch: autoloop.last_continuation_dispatch || autoloop.lastContinuationDispatch,
+        history: history,
+        latest_history: latestHistory,
+        cost: autoloop.cost,
+        recorded_at: autoloop.updated_at || autoloop.updatedAt || autoloop.last_iteration_at || autoloop.lastIterationAt
+    };
+}
+function supportHumanDecisionRequestObject(ticket, job, evidence) {
+    var ticketAutomation = plainObject(ticket.automation);
+    var ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
+    var runnerConsole = plainObject(ticketAutomation.runner_console || ticketAutomation.runnerConsole);
+    var autonomousDecision = supportAutonomyDecisionObject(ticket, job, evidence);
+    var recovery = plainObject(autonomousDecision.managerRecovery || autonomousDecision.manager_recovery);
+    var autoloopApprovalBlock = supportAutoloopApprovalBlockObject(ticket, job, evidence);
+    return evidenceObject(job.supportHumanDecisionRequest, job.support_human_decision_request, job.humanDecisionRequest, job.human_decision_request, evidence.supportHumanDecisionRequest, evidence.support_human_decision_request, evidence.humanDecisionRequest, evidence.human_decision_request, autonomousDecision.humanDecisionRequest, autonomousDecision.human_decision_request, recovery.humanDecisionRequest, recovery.human_decision_request, ticket.supportHumanDecisionRequest, ticket.support_human_decision_request, ticket.humanDecisionRequest, ticket.human_decision_request, runnerConsole.last_human_decision_request, runnerConsole.lastHumanDecisionRequest, runnerConsole.human_decision_request, runnerConsole.humanDecisionRequest, ticketManager.last_human_decision_request, ticketManager.lastHumanDecisionRequest, ticketManager.human_decision_request, ticketManager.humanDecisionRequest, autoloopApprovalBlock.human_decision_request, autoloopApprovalBlock.humanDecisionRequest);
+}
+function supportPostApprovalAutostartObject(ticket, job, evidence) {
+    var ticketAutomation = plainObject(ticket.automation);
+    var ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
+    var runnerConsole = plainObject(ticketAutomation.runner_console || ticketAutomation.runnerConsole);
+    var autonomousDecision = supportAutonomyDecisionObject(ticket, job, evidence);
+    var autonomyApproval = supportAutonomyApprovalObject(ticket, job, evidence);
+    var contract = evidenceObject(job.supportPostApprovalAutostartContract, job.support_post_approval_autostart_contract, job.postApprovalAutostartContract, job.post_approval_autostart_contract, evidence.supportPostApprovalAutostartContract, evidence.support_post_approval_autostart_contract, evidence.postApprovalAutostartContract, evidence.post_approval_autostart_contract, autonomousDecision.postApprovalAutostartContract, autonomousDecision.post_approval_autostart_contract, autonomyApproval.postApprovalAutostartContract, autonomyApproval.post_approval_autostart_contract, ticket.supportPostApprovalAutostartContract, ticket.support_post_approval_autostart_contract, ticket.postApprovalAutostartContract, ticket.post_approval_autostart_contract, runnerConsole.last_post_approval_autostart_contract, runnerConsole.lastPostApprovalAutostartContract, runnerConsole.post_approval_autostart_contract, runnerConsole.postApprovalAutostartContract, ticketManager.last_post_approval_autostart_contract, ticketManager.lastPostApprovalAutostartContract, ticketManager.post_approval_autostart_contract, ticketManager.postApprovalAutostartContract);
+    var record = evidenceObject(job.supportPostApprovalAutostart, job.support_post_approval_autostart, job.postApprovalAutostart, job.post_approval_autostart, evidence.supportPostApprovalAutostart, evidence.support_post_approval_autostart, evidence.postApprovalAutostart, evidence.post_approval_autostart, autonomousDecision.postApprovalAutostart, autonomousDecision.post_approval_autostart, autonomyApproval.postApprovalAutostart, autonomyApproval.post_approval_autostart, ticket.supportPostApprovalAutostart, ticket.support_post_approval_autostart, ticket.postApprovalAutostart, ticket.post_approval_autostart, runnerConsole.last_post_approval_autostart, runnerConsole.lastPostApprovalAutostart, runnerConsole.post_approval_autostart, runnerConsole.postApprovalAutostart, ticketManager.last_post_approval_autostart, ticketManager.lastPostApprovalAutostart, ticketManager.post_approval_autostart, ticketManager.postApprovalAutostart);
+    if (!Object.keys(contract).length && !Object.keys(record).length) {
+        return {};
+    }
+    return {
+        source: 'support_post_approval_autostart',
+        contract: contract,
+        record: record,
+        status: record.status || contract.status,
+        next_action: record.next_action || record.nextAction,
+        recorded_at: record.recorded_at || record.recordedAt || contract.recorded_at || contract.recordedAt
+    };
+}
+function supportPostApprovalResumeAttemptObject(ticket, job, evidence) {
+    var ticketAutomation = plainObject(ticket.automation);
+    var ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
+    var runnerConsole = plainObject(ticketAutomation.runner_console || ticketAutomation.runnerConsole);
+    var record = evidenceObject(job.supportPostApprovalResumeAttempt, job.support_post_approval_resume_attempt, job.postApprovalResumeAttempt, job.post_approval_resume_attempt, evidence.supportPostApprovalResumeAttempt, evidence.support_post_approval_resume_attempt, evidence.postApprovalResumeAttempt, evidence.post_approval_resume_attempt, ticket.supportPostApprovalResumeAttempt, ticket.support_post_approval_resume_attempt, ticket.postApprovalResumeAttempt, ticket.post_approval_resume_attempt, runnerConsole.last_post_approval_resume_attempt, runnerConsole.lastPostApprovalResumeAttempt, ticketManager.last_post_approval_resume_attempt, ticketManager.lastPostApprovalResumeAttempt);
+    if (!Object.keys(record).length) {
+        return {};
+    }
+    return {
+        source: 'support_post_approval_resume_attempt',
+        record: record,
+        status: record.status,
+        next_action: record.next_action || record.nextAction,
+        recorded_at: record.recorded_at || record.recordedAt
+    };
+}
+function supportIntakeRevisionContractObject(ticket, job, evidence) {
+    var ticketAutomation = plainObject(ticket.automation);
+    var ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
+    var runnerConsole = plainObject(ticketAutomation.runner_console || ticketAutomation.runnerConsole);
+    return evidenceObject(job.supportIntakeRevisionContract, job.support_intake_revision_contract, job.intakeRevisionContract, job.intake_revision_contract, evidence.supportIntakeRevisionContract, evidence.support_intake_revision_contract, evidence.intakeRevisionContract, evidence.intake_revision_contract, ticket.supportIntakeRevisionContract, ticket.support_intake_revision_contract, ticket.intakeRevisionContract, ticket.intake_revision_contract, runnerConsole.last_intake_revision_contract, runnerConsole.lastIntakeRevisionContract, runnerConsole.intake_revision_contract, runnerConsole.intakeRevisionContract, ticketManager.last_intake_revision_contract, ticketManager.lastIntakeRevisionContract, ticketManager.intake_revision_contract, ticketManager.intakeRevisionContract);
+}
+function supportManagerContinuationObject(ticket, job, evidence) {
+    var ticketAutomation = plainObject(ticket.automation);
+    var ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
+    var runnerConsole = plainObject(ticketAutomation.runner_console || ticketAutomation.runnerConsole);
+    var autonomousDecision = supportAutonomyDecisionObject(ticket, job, evidence);
+    var recovery = plainObject(autonomousDecision.managerRecovery || autonomousDecision.manager_recovery);
+    var directive = plainObject(recovery.directive);
+    var continuationContract = evidenceObject(job.supportManagerContinuationContract, job.support_manager_continuation_contract, job.continuationContract, job.continuation_contract, evidence.supportManagerContinuationContract, evidence.support_manager_continuation_contract, evidence.continuationContract, evidence.continuation_contract, autonomousDecision.continuationContract, autonomousDecision.continuation_contract, recovery.continuationContract, recovery.continuation_contract, directive.continuationContract, directive.continuation_contract, ticketManager.last_continuation_contract, ticketManager.lastContinuationContract, runnerConsole.last_continuation_contract, runnerConsole.lastContinuationContract);
+    var operatorGuidanceResponse = evidenceObject(job.operatorGuidanceResponse, job.operator_guidance_response, job.supportOperatorGuidanceResponse, job.support_operator_guidance_response, evidence.operatorGuidanceResponse, evidence.operator_guidance_response, recovery.operatorGuidanceResponse, recovery.operator_guidance_response, ticketManager.last_operator_guidance_response, ticketManager.lastOperatorGuidanceResponse, runnerConsole.last_operator_guidance_response, runnerConsole.lastOperatorGuidanceResponse);
+    var resumeUnblockContract = evidenceObject(continuationContract.resume_unblock_contract, continuationContract.resumeUnblockContract, operatorGuidanceResponse.resume_unblock_contract, operatorGuidanceResponse.resumeUnblockContract, recovery.resume_unblock_contract, recovery.resumeUnblockContract);
+    var resumeUnblockResponse = evidenceObject(operatorGuidanceResponse.resume_unblock_response, operatorGuidanceResponse.resumeUnblockResponse, recovery.resume_unblock_response, recovery.resumeUnblockResponse);
+    var resumeDispatch = evidenceObject(job.operatorGuidanceResumeDispatch, job.operator_guidance_resume_dispatch, evidence.operatorGuidanceResumeDispatch, evidence.operator_guidance_resume_dispatch, recovery.operatorGuidanceResumeDispatch, recovery.operator_guidance_resume_dispatch, ticketManager.last_operator_guidance_resume_dispatch, ticketManager.lastOperatorGuidanceResumeDispatch, runnerConsole.last_operator_guidance_resume_dispatch, runnerConsole.lastOperatorGuidanceResumeDispatch);
+    if (!Object.keys(continuationContract).length && !Object.keys(operatorGuidanceResponse).length && !Object.keys(resumeUnblockContract).length && !Object.keys(resumeDispatch).length) {
+        return {};
+    }
+    return {
+        source: 'support_manager_continuation',
+        continuation_contract: continuationContract,
+        operator_guidance_response: operatorGuidanceResponse,
+        resume_unblock_contract: resumeUnblockContract,
+        resume_unblock_response: resumeUnblockResponse,
+        resume_dispatch: resumeDispatch,
+        manager_status: cleanText(ticketManager.status || runnerConsole.manager_status || runnerConsole.managerStatus, 120),
+        recorded_at: operatorGuidanceResponse.recorded_at || operatorGuidanceResponse.recordedAt || resumeDispatch.created_at || resumeDispatch.createdAt || continuationContract.recorded_at || continuationContract.recordedAt
+    };
+}
+function supportApprovalExplicitlyApprovesOverLimit(approval) {
+    return approval.approve_over_max_hours === true
+        || approval.approveOverMaxHours === true
+        || approval.approve_over_six_hours === true
+        || approval.approveOverSixHours === true
+        || approval.over_limit_approved === true
+        || approval.overLimitApproved === true
+        || approval.over_max_auto_hours_approved === true
+        || approval.overMaxAutoHoursApproved === true
+        || approval.operator_approved_over_limit === true
+        || approval.operatorApprovedOverLimit === true;
+}
+function sameSupportApprovalFileSet(left, right) {
+    var normalizedLeft = Array.from(new Set(left.map(function (entry) { return entry.trim(); }).filter(Boolean))).sort();
+    var normalizedRight = Array.from(new Set(right.map(function (entry) { return entry.trim(); }).filter(Boolean))).sort();
+    return normalizedLeft.length === normalizedRight.length
+        && normalizedLeft.every(function (entry, index) { return entry === normalizedRight[index]; });
+}
+function supportApprovalOwnerFilesDiffer(approval) {
+    var currentOwnerFiles = cleanStringList(approval.current_owner_files
+        || approval.currentOwnerFiles
+        || approval.owner_files
+        || approval.ownerFiles, 80, 500);
+    var approvedOwnerFiles = cleanStringList(approval.approved_owner_files
+        || approval.approvedOwnerFiles, 80, 500);
+    if (!currentOwnerFiles.length || !approvedOwnerFiles.length) {
+        return false;
+    }
+    return !sameSupportApprovalFileSet(currentOwnerFiles, approvedOwnerFiles);
+}
+function supportAutonomyApprovalGate(approval, now) {
+    var _a, _b;
+    if (!approval || !Object.keys(approval).length) {
+        return undefined;
+    }
+    var approved = approval.approved === true;
+    var statusText = cleanText(approval.status, 120).toLowerCase();
+    var decisionKind = cleanText(approval.decision_kind || approval.decisionKind || approval.approval_kind || approval.approvalKind, 120);
+    var approvalAction = cleanText(approval.approval_action || approval.approvalAction, 120);
+    var blockers = cleanStringList(approval.blockers, 40, 500);
+    var estimatedHours = numberValue((_a = approval.estimated_hours) !== null && _a !== void 0 ? _a : approval.estimatedHours);
+    var maxAutoHours = numberValue((_b = approval.max_auto_hours_without_approval) !== null && _b !== void 0 ? _b : approval.maxAutoHoursWithoutApproval) || 6;
+    var overLimitExplicitlyApproved = supportApprovalExplicitlyApprovesOverLimit(approval);
+    var bugNotBug = cleanText(approval.bug_not_bug || approval.bugNotBug, 80);
+    var bugNotBugKnown = approval.bug_not_bug_known === true
+        || approval.bugNotBugKnown === true
+        || bugNotBug === 'bug'
+        || bugNotBug === 'not_bug'
+        || bugNotBug === 'not bug';
+    var bugNotBugApproved = approval.bug_not_bug_classification_approved === true || approval.bugNotBugClassificationApproved === true;
+    var approvedOwnerFileSetChanged = supportApprovalOwnerFilesDiffer(approval);
+    var ownerFiles = cleanStringList(approval.owner_files || approval.ownerFiles, 60, 500);
+    var approvedOwnerFiles = cleanStringList(approval.approved_owner_files || approval.approvedOwnerFiles, 60, 500);
+    var currentOwnerFiles = cleanStringList(approval.current_owner_files || approval.currentOwnerFiles || approval.owner_files || approval.ownerFiles, 60, 500);
+    var approvedOwnerFileSet = new Set(approvedOwnerFiles);
+    var currentOwnerFileSet = new Set(currentOwnerFiles);
+    var computedOwnerFilesAdded = currentOwnerFiles.filter(function (entry) { return !approvedOwnerFileSet.has(entry); });
+    var computedOwnerFilesRemoved = approvedOwnerFiles.filter(function (entry) { return !currentOwnerFileSet.has(entry); });
+    var ownerFilesChangedSinceApproval = approval.owner_files_changed_since_approval === true
+        || approval.ownerFilesChangedSinceApproval === true
+        || approvedOwnerFileSetChanged
+        || computedOwnerFilesAdded.length > 0
+        || computedOwnerFilesRemoved.length > 0;
+    var scopeFingerprint = cleanText(approval.scope_fingerprint || approval.scopeFingerprint, 180);
+    var previousScopeFingerprint = cleanText(approval.previous_scope_fingerprint || approval.previousScopeFingerprint, 180);
+    var scopeChangedSinceApproval = approval.scope_changed_since_approval === true
+        || approval.scopeChangedSinceApproval === true
+        || (!!scopeFingerprint && !!previousScopeFingerprint && scopeFingerprint !== previousScopeFingerprint);
+    var diagnosisScopeFingerprint = cleanText(approval.diagnosis_scope_fingerprint || approval.diagnosisScopeFingerprint, 180);
+    var previousDiagnosisScopeFingerprint = cleanText(approval.previous_diagnosis_scope_fingerprint || approval.previousDiagnosisScopeFingerprint, 180);
+    var diagnosisScopeChangedSinceApproval = approval.diagnosis_scope_changed_since_approval === true
+        || approval.diagnosisScopeChangedSinceApproval === true
+        || (!!diagnosisScopeFingerprint && !!previousDiagnosisScopeFingerprint && diagnosisScopeFingerprint !== previousDiagnosisScopeFingerprint);
+    var boundedAutopilotApproval = approval.after_approval_autopilot_until_a_grade === true
+        || approval.afterApprovalAutopilotUntilAGrade === true
+        || approval.autopilot_after_approval_until_a_grade === true
+        || approval.le_six_hour_scope_can_autofix_after_approval === true
+        || approval.leSixHourScopeCanAutofixAfterApproval === true
+        || estimatedHours !== undefined
+        || !!bugNotBug
+        || cleanStringList(approval.owner_files || approval.ownerFiles, 20, 500).length > 0;
+    if (approval.requires_over_limit_approval === true || approval.requiresOverLimitApproval === true) {
+        blockers.push('Estimated work is over the automatic hour ceiling and requires operator approval.');
+    }
+    if (approval.requires_scope_reapproval === true || approval.requiresScopeReapproval === true || scopeChangedSinceApproval) {
+        blockers.push('The approved support scope changed and requires on-the-fly reapproval.');
+    }
+    if (approval.requires_owner_file_reapproval === true || approval.requiresOwnerFileReapproval === true) {
+        blockers.push('The owner-file set changed after approval and requires reapproval.');
+    }
+    if (approval.requires_intake_reapproval === true || approval.requiresIntakeReapproval === true) {
+        blockers.push('The support intake/classification changed after approval and requires reapproval.');
+    }
+    if (approval.requires_diagnosis_scope_reapproval === true || approval.requiresDiagnosisScopeReapproval === true || diagnosisScopeChangedSinceApproval) {
+        blockers.push('The accepted diagnosis/proof scope changed after approval and requires reapproval.');
+    }
+    if (approval.requires_classification_approval === true || approval.requiresClassificationApproval === true) {
+        blockers.push('Bug/not-bug classification must be approved before product-code repair.');
+    }
+    if (approval.requires_estimate_hours === true || approval.requiresEstimateHours === true) {
+        blockers.push('Estimated hours must be recorded before product-code repair.');
+    }
+    if (approved && boundedAutopilotApproval && bugNotBugKnown !== true) {
+        blockers.push('Bug/not-bug classification must be set before approved support autopilot can repair product code.');
+    }
+    if (approved && boundedAutopilotApproval && bugNotBugApproved !== true) {
+        blockers.push('Bug/not-bug classification must be approved before approved support autopilot can repair product code.');
+    }
+    if (approved && boundedAutopilotApproval && estimatedHours === undefined) {
+        blockers.push('Estimated hours must be recorded before approved support autopilot can repair product code.');
+    }
+    if (approved && estimatedHours !== undefined && estimatedHours > maxAutoHours && overLimitExplicitlyApproved !== true) {
+        blockers.push("Estimated work is ".concat(estimatedHours, " hours, above the ").concat(maxAutoHours, "-hour autonomy ceiling, and needs explicit over-limit operator approval."));
+    }
+    if (approved && approvedOwnerFileSetChanged) {
+        blockers.push('Current owner files differ from approved owner files and require on-the-fly reapproval.');
+    }
+    var uniqueBlockers = Array.from(new Set(blockers));
+    var autopilotCompletionContract = plainObject(approval.autopilot_completion_contract || approval.autopilotCompletionContract);
+    var status = approved && uniqueBlockers.length === 0 ? 'pass' : 'blocked';
+    var reason = approved
+        ? 'Support autonomy is approved for bounded product-code repair until A-grade QA/business proof is reached.'
+        : cleanText(uniqueBlockers.join(' ') || approval.reason || approval.approval_question || approval.approvalQuestion || statusText || 'Support autonomy approval is required before product-code repair.', 1200);
+    return {
+        key: 'support_autonomy_approval',
+        label: 'Support autonomy approval',
+        status: status,
+        reason: status === 'pass' ? reason : cleanText(uniqueBlockers.join(' ') || reason, 1200),
+        evidenceRefs: cleanStringList(__spreadArray(__spreadArray(__spreadArray([], __read(asArray(approval.required_completion_evidence || approval.requiredCompletionEvidence)), false), __read(asArray(approval.owner_files || approval.ownerFiles)), false), __read(asArray(approval.approved_owner_files || approval.approvedOwnerFiles)), false), 60, 500),
+        recordedAt: isoNow(now || approval.approved_at || approval.approvedAt || approval.created_at || approval.createdAt || approval.recorded_at || approval.recordedAt),
+        metadata: {
+            contractId: cleanText(approval.contract_id || approval.contractId, 180),
+            status: statusText,
+            approved: approved,
+            approvedAt: cleanText(approval.approved_at || approval.approvedAt, 80),
+            approvedBy: cleanText(approval.approved_by || approval.approvedBy, 160),
+            decisionKind: decisionKind,
+            approvalAction: approvalAction,
+            approvalLabel: cleanText(approval.approval_label || approval.approvalLabel, 160),
+            preferredChoiceId: cleanText(approval.preferred_choice_id || approval.preferredChoiceId, 120),
+            canApproveFromConsole: approval.can_approve_from_console !== false && approval.canApproveFromConsole !== false,
+            estimatedHours: estimatedHours,
+            estimatedHoursKnown: estimatedHours !== undefined,
+            maxAutoHoursWithoutApproval: maxAutoHours,
+            overMaxAutoHours: approval.over_max_auto_hours === true || approval.overMaxAutoHours === true,
+            approveOverMaxHours: approval.approve_over_max_hours === true || approval.approveOverMaxHours === true,
+            approveOverSixHours: approval.approve_over_six_hours === true || approval.approveOverSixHours === true,
+            explicitOverLimitApproval: overLimitExplicitlyApproved,
+            bugNotBug: bugNotBug,
+            bugNotBugKnown: bugNotBugKnown,
+            bugNotBugClassificationApproved: bugNotBugApproved,
+            requiresOverLimitApproval: approval.requires_over_limit_approval === true || approval.requiresOverLimitApproval === true,
+            requiresScopeReapproval: approval.requires_scope_reapproval === true || approval.requiresScopeReapproval === true,
+            requiresOwnerFileReapproval: approval.requires_owner_file_reapproval === true || approval.requiresOwnerFileReapproval === true,
+            requiresIntakeReapproval: approval.requires_intake_reapproval === true || approval.requiresIntakeReapproval === true,
+            requiresDiagnosisScopeReapproval: approval.requires_diagnosis_scope_reapproval === true || approval.requiresDiagnosisScopeReapproval === true,
+            requiresClassificationApproval: approval.requires_classification_approval === true || approval.requiresClassificationApproval === true,
+            requiresEstimateHours: approval.requires_estimate_hours === true || approval.requiresEstimateHours === true,
+            changeApprovalMode: cleanText(approval.change_approval_mode || approval.changeApprovalMode, 120),
+            overSixHourRequiresExplicitOperatorApproval: approval.over_six_hour_requires_explicit_operator_approval === true || approval.overSixHourRequiresExplicitOperatorApproval === true,
+            leSixHourScopeCanAutofixAfterApproval: approval.le_six_hour_scope_can_autofix_after_approval === true || approval.leSixHourScopeCanAutofixAfterApproval === true,
+            afterApprovalAutopilotUntilAGrade: approval.after_approval_autopilot_until_a_grade === true || approval.afterApprovalAutopilotUntilAGrade === true || approval.autopilot_after_approval_until_a_grade === true,
+            targetGrade: cleanText(approval.target_grade || approval.targetGrade || 'A', 20),
+            autopilotCompletionStatus: cleanText(autopilotCompletionContract.status, 120),
+            terminalTarget: cleanText(autopilotCompletionContract.required_terminal_state || autopilotCompletionContract.requiredTerminalState, 800),
+            stopOrParkConditions: cleanStringList(autopilotCompletionContract.stop_or_park_conditions || autopilotCompletionContract.stopOrParkConditions, 20, 500),
+            qaScreenshotsRequired: approval.qa_screenshots_required === true || approval.qaScreenshotsRequired === true,
+            beforeActionAfterBusinessProofRequired: approval.before_action_after_business_proof_required === true || approval.beforeActionAfterBusinessProofRequired === true,
+            aiqaBusinessAssertionRequired: approval.aiqa_business_assertion_required === true || approval.aiqaBusinessAssertionRequired === true,
+            scopeFingerprint: scopeFingerprint,
+            previousScopeFingerprint: previousScopeFingerprint,
+            scopeChangedSinceApproval: scopeChangedSinceApproval,
+            ownerFilesChangedSinceApproval: ownerFilesChangedSinceApproval,
+            ownerFileFingerprint: cleanText(approval.owner_file_fingerprint || approval.ownerFileFingerprint, 180),
+            approvedOwnerFileFingerprint: cleanText(approval.approved_owner_file_fingerprint || approval.approvedOwnerFileFingerprint, 180),
+            ownerFilesAddedSinceApproval: cleanStringList(approval.owner_files_added_since_approval || approval.ownerFilesAddedSinceApproval, 40, 500).length
+                ? cleanStringList(approval.owner_files_added_since_approval || approval.ownerFilesAddedSinceApproval, 40, 500)
+                : computedOwnerFilesAdded,
+            ownerFilesRemovedSinceApproval: cleanStringList(approval.owner_files_removed_since_approval || approval.ownerFilesRemovedSinceApproval, 40, 500).length
+                ? cleanStringList(approval.owner_files_removed_since_approval || approval.ownerFilesRemovedSinceApproval, 40, 500)
+                : computedOwnerFilesRemoved,
+            diagnosisScopeFingerprint: diagnosisScopeFingerprint,
+            previousDiagnosisScopeFingerprint: previousDiagnosisScopeFingerprint,
+            diagnosisScopeIncluded: approval.diagnosis_scope_included === true || approval.diagnosisScopeIncluded === true || !!diagnosisScopeFingerprint,
+            diagnosisScopeValid: approval.diagnosis_scope_valid === true || approval.diagnosisScopeValid === true,
+            diagnosisScopeChangedSinceApproval: diagnosisScopeChangedSinceApproval,
+            diagnosisScopeFields: cleanStringList(approval.diagnosis_scope_fields || approval.diagnosisScopeFields, 40, 160),
+            diagnosisScopeBlockers: cleanStringList(approval.diagnosis_scope_blockers || approval.diagnosisScopeBlockers, 40, 500),
+            approvedOwnerFileSetChanged: approvedOwnerFileSetChanged,
+            boundedAutopilotApproval: boundedAutopilotApproval,
+            autopilotApprovalBoundaryValid: status === 'pass',
+            ownerFiles: ownerFiles,
+            approvedOwnerFiles: approvedOwnerFiles,
+            currentOwnerFiles: currentOwnerFiles,
+            requiredCompletionEvidence: cleanStringList(approval.required_completion_evidence || approval.requiredCompletionEvidence, 30, 500),
+            forbiddenWithoutReapproval: cleanStringList(approval.forbidden_without_reapproval || approval.forbiddenWithoutReapproval, 30, 500),
+            blockers: uniqueBlockers
+        }
+    };
+}
+function supportProductRepairDispatchGuardGate(guard, now) {
+    if (!guard || !Object.keys(guard).length) {
+        return undefined;
+    }
+    var statusText = cleanText(guard.status, 120).toLowerCase();
+    var allowed = guard.allowed === true || statusText === 'allowed';
+    var blockers = cleanStringList(guard.blockers, 40, 500);
+    if (guard.requires_owner_file_reapproval === true || guard.requiresOwnerFileReapproval === true) {
+        blockers.push('Product repair dispatch is blocked until owner-file scope is reapproved.');
+    }
+    if (guard.requires_scope_reapproval === true || guard.requiresScopeReapproval === true) {
+        blockers.push('Product repair dispatch is blocked until changed support scope is reapproved.');
+    }
+    if (guard.requires_over_limit_approval === true || guard.requiresOverLimitApproval === true) {
+        blockers.push('Product repair dispatch is blocked until over-limit autonomy is approved.');
+    }
+    if (guard.requires_diagnosis_scope_reapproval === true || guard.requiresDiagnosisScopeReapproval === true) {
+        blockers.push('Product repair dispatch is blocked until changed diagnosis scope is reapproved.');
+    }
+    var continuationContract = plainObject(guard.continuation_contract
+        || guard.continuationContract
+        || guard.autopilot_completion_contract
+        || guard.autopilotCompletionContract);
+    var status = allowed ? 'pass' : 'blocked';
+    return {
+        key: 'support_product_repair_dispatch_guard',
+        label: 'Support product-repair dispatch guard',
+        status: status,
+        reason: allowed
+            ? cleanText(guard.reason || 'Approved support autonomy allows owner-scoped product-code repair.', 1200)
+            : cleanText(blockers.join(' ') || guard.reason || 'Support product-code repair dispatch is blocked until autonomy approval is current.', 1200),
+        evidenceRefs: cleanStringList(__spreadArray(__spreadArray(__spreadArray([], __read(asArray(guard.owner_files || guard.ownerFiles)), false), __read(asArray(guard.approved_owner_files || guard.approvedOwnerFiles)), false), __read(asArray(guard.required_completion_evidence || guard.requiredCompletionEvidence)), false), 60, 500),
+        recordedAt: isoNow(now || guard.recorded_at || guard.recordedAt || guard.created_at || guard.createdAt),
+        metadata: {
+            guard: cleanText(guard.guard, 160),
+            status: statusText,
+            allowed: allowed,
+            action: cleanText(guard.action, 160),
+            editsProductCode: guard.edits_product_code === true || guard.editsProductCode === true,
+            canEditProductCode: guard.can_edit_product_code === true || guard.canEditProductCode === true,
+            autoContinueAfterApproval: guard.auto_continue_after_approval === true || guard.autoContinueAfterApproval === true,
+            nextAction: cleanText(guard.next_action || guard.nextAction, 160),
+            approvalContractId: cleanText(guard.approval_contract_id || guard.approvalContractId, 180),
+            continuationContractStatus: cleanText(continuationContract.status, 120),
+            continuationContractMode: cleanText(continuationContract.mode, 160),
+            terminalTarget: cleanText(guard.terminal_target
+                || guard.terminalTarget
+                || continuationContract.required_terminal_state
+                || continuationContract.requiredTerminalState, 800),
+            nextProofPhases: cleanStringList(guard.next_proof_phases || guard.nextProofPhases, 20, 240),
+            allowedAutoActions: cleanStringList(guard.allowed_auto_actions || guard.allowedAutoActions, 20, 240),
+            forbiddenActions: cleanStringList(guard.forbidden_actions || guard.forbiddenActions, 30, 500),
+            scopeFingerprint: cleanText(guard.scope_fingerprint || guard.scopeFingerprint, 180),
+            ownerFiles: cleanStringList(guard.owner_files || guard.ownerFiles, 60, 500),
+            approvedOwnerFiles: cleanStringList(guard.approved_owner_files || guard.approvedOwnerFiles, 60, 500),
+            currentOwnerFiles: cleanStringList(guard.current_owner_files || guard.currentOwnerFiles, 60, 500),
+            ownerFileFingerprint: cleanText(guard.owner_file_fingerprint || guard.ownerFileFingerprint, 180),
+            approvedOwnerFileFingerprint: cleanText(guard.approved_owner_file_fingerprint || guard.approvedOwnerFileFingerprint, 180),
+            ownerFilesChangedSinceApproval: guard.owner_files_changed_since_approval === true || guard.ownerFilesChangedSinceApproval === true,
+            ownerFilesAddedSinceApproval: cleanStringList(guard.owner_files_added_since_approval || guard.ownerFilesAddedSinceApproval, 40, 500),
+            ownerFilesRemovedSinceApproval: cleanStringList(guard.owner_files_removed_since_approval || guard.ownerFilesRemovedSinceApproval, 40, 500),
+            requiresOwnerFileReapproval: guard.requires_owner_file_reapproval === true || guard.requiresOwnerFileReapproval === true,
+            requiresScopeReapproval: guard.requires_scope_reapproval === true || guard.requiresScopeReapproval === true,
+            requiresOverLimitApproval: guard.requires_over_limit_approval === true || guard.requiresOverLimitApproval === true,
+            requiresDiagnosisScopeReapproval: guard.requires_diagnosis_scope_reapproval === true || guard.requiresDiagnosisScopeReapproval === true,
+            requiredCompletionEvidence: cleanStringList(guard.required_completion_evidence || guard.requiredCompletionEvidence, 30, 500),
+            blockers: Array.from(new Set(blockers))
+        }
+    };
+}
+function supportAutoloopApprovalBlockGate(block, now) {
+    var _a, _b, _c, _d, _e, _f;
+    if (!block || !Object.keys(block).length) {
+        return undefined;
+    }
+    var statusText = cleanText(block.status, 160).toLowerCase();
+    var action = cleanText(block.action || block.next_action || block.nextAction, 160);
+    var nextAction = cleanText(block.next_action || block.nextAction || action, 160);
+    var decisionKind = cleanText(block.decision_kind || block.decisionKind, 160);
+    var humanDecisionRequest = plainObject(block.human_decision_request || block.humanDecisionRequest);
+    var productRepairDispatchGuard = plainObject(block.product_repair_dispatch_guard || block.productRepairDispatchGuard);
+    var approvalContractId = cleanText(block.approval_contract_id || block.approvalContractId, 180);
+    var blockers = cleanStringList(block.blockers, 40, 500);
+    if (block.requires_over_limit_approval === true || block.requiresOverLimitApproval === true) {
+        blockers.push('Autoloop is parked until explicit over-limit approval is recorded.');
+    }
+    if (block.requires_scope_reapproval === true || block.requiresScopeReapproval === true) {
+        blockers.push('Autoloop is parked until the revised support scope is approved.');
+    }
+    if (block.requires_owner_file_reapproval === true || block.requiresOwnerFileReapproval === true) {
+        blockers.push('Autoloop is parked until the changed owner-file set is reapproved.');
+    }
+    if (block.requires_diagnosis_scope_reapproval === true || block.requiresDiagnosisScopeReapproval === true) {
+        blockers.push('Autoloop is parked until the changed diagnosis/proof scope is reapproved.');
+    }
+    if (block.requires_repair_intent_reapproval === true || block.requiresRepairIntentReapproval === true) {
+        blockers.push('Autoloop is parked until the changed planned implementation intent is reapproved.');
+    }
+    if (block.requires_repair_intent === true || block.requiresRepairIntent === true) {
+        blockers.push('Autoloop is parked until planned implementation intent is defined.');
+    }
+    if (block.requires_classification_approval === true || block.requiresClassificationApproval === true) {
+        blockers.push('Autoloop is parked until bug/not-bug classification is approved.');
+    }
+    if (block.requires_estimate_hours === true || block.requiresEstimateHours === true) {
+        blockers.push('Autoloop is parked until estimated hours are recorded.');
+    }
+    if (block.requires_elapsed_reapproval === true || block.requiresElapsedReapproval === true) {
+        blockers.push('Autoloop is parked because elapsed runtime exceeded the approved wall-clock boundary.');
+    }
+    var uniqueBlockers = Array.from(new Set(blockers));
+    var resolved = /resolved|approved|complete|completed|dismissed/.test(statusText);
+    var blocked = !resolved && (/blocked|approval|required|waiting|pending|parked/.test(statusText) || !!nextAction || uniqueBlockers.length > 0);
+    var gateStatus = blocked ? 'blocked' : 'warn';
+    return {
+        key: 'support_autoloop_approval_block',
+        label: 'Support autoloop approval block',
+        status: gateStatus,
+        reason: cleanText(block.reason
+            || uniqueBlockers.join(' ')
+            || (blocked ? 'Support autoloop is parked until a specific approval or scope revision is recorded.' : 'Support autoloop approval block was recorded.'), 1200),
+        evidenceRefs: cleanStringList(__spreadArray(__spreadArray(__spreadArray([], __read(asArray(block.required_completion_evidence || block.requiredCompletionEvidence)), false), __read(asArray(productRepairDispatchGuard.owner_files || productRepairDispatchGuard.ownerFiles)), false), __read(asArray(productRepairDispatchGuard.approved_owner_files || productRepairDispatchGuard.approvedOwnerFiles)), false), 60, 500),
+        recordedAt: isoNow(now || block.created_at || block.createdAt || block.recorded_at || block.recordedAt),
+        metadata: {
+            recordId: cleanText(block.record_id || block.recordId, 180),
+            status: statusText,
+            action: action,
+            nextAction: nextAction,
+            approvalContractId: approvalContractId,
+            scopeFingerprint: cleanText(block.scope_fingerprint || block.scopeFingerprint, 180),
+            diagnosisScopeFingerprint: cleanText(block.diagnosis_scope_fingerprint || block.diagnosisScopeFingerprint, 180),
+            repairIntentScopeFingerprint: cleanText(block.repair_intent_scope_fingerprint || block.repairIntentScopeFingerprint, 180),
+            decisionKind: decisionKind,
+            requiresOverLimitApproval: block.requires_over_limit_approval === true || block.requiresOverLimitApproval === true,
+            requiresScopeReapproval: block.requires_scope_reapproval === true || block.requiresScopeReapproval === true,
+            requiresOwnerFileReapproval: block.requires_owner_file_reapproval === true || block.requiresOwnerFileReapproval === true,
+            requiresDiagnosisScopeReapproval: block.requires_diagnosis_scope_reapproval === true || block.requiresDiagnosisScopeReapproval === true,
+            requiresRepairIntentReapproval: block.requires_repair_intent_reapproval === true || block.requiresRepairIntentReapproval === true,
+            requiresRepairIntent: block.requires_repair_intent === true || block.requiresRepairIntent === true,
+            requiresClassificationApproval: block.requires_classification_approval === true || block.requiresClassificationApproval === true,
+            requiresEstimateHours: block.requires_estimate_hours === true || block.requiresEstimateHours === true,
+            requiresElapsedReapproval: block.requires_elapsed_reapproval === true || block.requiresElapsedReapproval === true,
+            elapsedRuntimeMs: numberValue((_a = block.elapsed_runtime_ms) !== null && _a !== void 0 ? _a : block.elapsedRuntimeMs),
+            elapsedRuntimeHours: numberValue((_b = block.elapsed_runtime_hours) !== null && _b !== void 0 ? _b : block.elapsedRuntimeHours),
+            maxApprovedRuntimeMs: numberValue((_c = block.max_approved_runtime_ms) !== null && _c !== void 0 ? _c : block.maxApprovedRuntimeMs),
+            maxApprovedRuntimeHours: numberValue((_d = block.max_approved_runtime_hours) !== null && _d !== void 0 ? _d : block.maxApprovedRuntimeHours),
+            maxWallClockMs: numberValue((_e = block.max_wall_clock_ms) !== null && _e !== void 0 ? _e : block.maxWallClockMs),
+            maxWallClockHours: numberValue((_f = block.max_wall_clock_hours) !== null && _f !== void 0 ? _f : block.maxWallClockHours),
+            onTheFlyScopeChangeApprovalRequired: block.on_the_fly_scope_change_approval_required === true || block.onTheFlyScopeChangeApprovalRequired === true,
+            targetGrade: cleanText(block.target_grade || block.targetGrade || 'A', 20),
+            requiredTerminalState: cleanText(block.required_terminal_state || block.requiredTerminalState, 800),
+            humanDecisionRequestId: cleanText(humanDecisionRequest.request_id || humanDecisionRequest.requestId, 180),
+            humanDecisionPreferredChoiceId: cleanText(humanDecisionRequest.preferred_choice_id || humanDecisionRequest.preferredChoiceId, 160),
+            humanDecisionApprovalAction: cleanText(humanDecisionRequest.approval_action || humanDecisionRequest.approvalAction, 160),
+            productRepairDispatchGuardStatus: cleanText(productRepairDispatchGuard.status, 120),
+            productRepairDispatchNextAction: cleanText(productRepairDispatchGuard.next_action || productRepairDispatchGuard.nextAction, 160),
+            blockers: uniqueBlockers
+        }
+    };
+}
+function supportAutoloopNoProgressGate(record, now) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    if (!record || !Object.keys(record).length) {
+        return undefined;
+    }
+    var history = asArray(record.history)
+        .map(function (entry) { return plainObject(entry); })
+        .filter(function (entry) { return Object.keys(entry).length > 0; })
+        .slice(-12);
+    var latestHistory = plainObject(record.latest_history || record.latestHistory || history[history.length - 1]);
+    var statusText = cleanText(record.status || latestHistory.status, 120).toLowerCase();
+    var noProgressStreak = Math.max(0, Number((_d = (_c = (_b = (_a = record.no_progress_streak) !== null && _a !== void 0 ? _a : record.noProgressStreak) !== null && _b !== void 0 ? _b : latestHistory.no_progress_streak) !== null && _c !== void 0 ? _c : latestHistory.noProgressStreak) !== null && _d !== void 0 ? _d : 0) || 0);
+    var lastProgressSignal = booleanFlag((_g = (_f = (_e = record.last_progress_signal) !== null && _e !== void 0 ? _e : record.lastProgressSignal) !== null && _f !== void 0 ? _f : latestHistory.progress_signal) !== null && _g !== void 0 ? _g : latestHistory.progressSignal);
+    var evidenceChanged = booleanFlag((_m = (_l = (_k = (_j = (_h = record.last_evidence_changed) !== null && _h !== void 0 ? _h : record.lastEvidenceChanged) !== null && _j !== void 0 ? _j : record.evidence_changed) !== null && _k !== void 0 ? _k : record.evidenceChanged) !== null && _l !== void 0 ? _l : latestHistory.evidence_changed) !== null && _m !== void 0 ? _m : latestHistory.evidenceChanged);
+    var handoffRequired = record.handoff_required === true || record.handoffRequired === true;
+    var lastError = cleanText(record.last_error || record.lastError || latestHistory.error, 2000);
+    var continuationDecision = plainObject(record.last_continuation_decision || record.lastContinuationDecision || latestHistory.continuation_decision || latestHistory.continuationDecision);
+    var continuationDispatch = plainObject(record.last_continuation_dispatch || record.lastContinuationDispatch || latestHistory.continuation_dispatch || latestHistory.continuationDispatch);
+    var continuationAction = cleanText(continuationDecision.action || continuationDispatch.action, 160);
+    var noProgressError = /no[-_\s]?progress|no new diff|no new .*evidence|without progress|retry blocked|same failure/i.test(lastError);
+    var stoppedOrParked = handoffRequired
+        || /stopped|stop|park|parked|handoff|blocked/.test(statusText)
+        || /park|handoff|blocked|manual/.test(continuationAction);
+    var hasNoProgressEvidence = noProgressStreak > 0
+        || lastProgressSignal === false
+        || evidenceChanged === false
+        || noProgressError;
+    if (!hasNoProgressEvidence) {
+        return undefined;
+    }
+    var blocked = stoppedOrParked && hasNoProgressEvidence;
+    var strictGateReason = cleanText(record.last_strict_gate_reason || record.lastStrictGateReason || latestHistory.strict_gate_reason || latestHistory.strictGateReason, 500);
+    var diffFingerprint = cleanText(record.diff_fingerprint || record.diffFingerprint || latestHistory.diff_fingerprint || latestHistory.diffFingerprint, 180);
+    var failingCheckFingerprint = cleanText(record.failing_check_fingerprint || record.failingCheckFingerprint || latestHistory.failing_check_fingerprint || latestHistory.failingCheckFingerprint, 180);
+    var progressReasons = cleanStringList(record.last_progress_reasons || record.lastProgressReasons || latestHistory.progress_reasons || latestHistory.progressReasons, 20, 240);
+    var evidenceReasons = cleanStringList(record.last_evidence_reasons || record.lastEvidenceReasons || latestHistory.evidence_reasons || latestHistory.evidenceReasons, 20, 240);
+    var blockers = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read((noProgressStreak > 0 ? ["no_progress_streak=".concat(noProgressStreak)] : [])), false), __read((lastProgressSignal === false ? ['last_progress_signal=false'] : [])), false), __read((evidenceChanged === false ? ['evidence_changed=false'] : [])), false), __read((strictGateReason ? ["strict_gate=".concat(strictGateReason)] : [])), false), __read((lastError ? ["last_error=".concat(lastError)] : [])), false);
+    return {
+        key: 'support_autoloop_no_progress',
+        label: 'Support autoloop no-progress guard',
+        status: blocked ? 'blocked' : 'warn',
+        reason: cleanText(record.reason
+            || (blocked
+                ? 'Support autoloop parked because no new diff/check/PR evidence was recorded before another repair loop.'
+                : 'Support autoloop recorded no-progress evidence; require new material proof before another broad repair loop.'), 1200),
+        evidenceRefs: cleanStringList(__spreadArray(__spreadArray(__spreadArray([], __read(progressReasons), false), __read(evidenceReasons), false), [
+            diffFingerprint ? "diff_fingerprint=".concat(diffFingerprint) : '',
+            failingCheckFingerprint ? "failing_check_fingerprint=".concat(failingCheckFingerprint) : '',
+            strictGateReason ? "strict_gate=".concat(strictGateReason) : '',
+            continuationAction ? "continuation_action=".concat(continuationAction) : ''
+        ], false), 60, 500),
+        recordedAt: isoNow(now || record.recorded_at || record.recordedAt || latestHistory.finished_at || latestHistory.finishedAt),
+        metadata: {
+            runId: cleanText(record.run_id || record.runId || latestHistory.run_id || latestHistory.runId, 180),
+            status: statusText,
+            noProgressStreak: noProgressStreak,
+            lastProgressSignal: lastProgressSignal,
+            evidenceChanged: evidenceChanged,
+            handoffRequired: handoffRequired,
+            lastError: lastError,
+            strictGateReason: strictGateReason,
+            diffFingerprint: diffFingerprint,
+            failingCheckFingerprint: failingCheckFingerprint,
+            continuationAction: continuationAction,
+            continuationReason: cleanText(continuationDecision.reason || continuationDispatch.reason, 1000),
+            continuationStatus: cleanText(continuationDispatch.status || continuationDecision.status, 120),
+            progressReasons: progressReasons,
+            evidenceReasons: evidenceReasons,
+            requiresNewEvidence: true,
+            productRepairAllowed: false,
+            nextAction: 'collect_new_evidence_or_revise_diagnosis',
+            requiredEvidence: [
+                'new diff/check/PR evidence, changed failing-check fingerprint, or a revised SupportDiagnosisGate with fresh proof',
+                'AIQaBusinessAssertion before/action/after proof when the ticket issue is fixed'
+            ],
+            forbiddenActions: [
+                'Do not start another product-code/model repair loop until new evidence changes the blocker fingerprint.',
+                'Do not treat route-load proof or scorecard-only proof as accepted support completion.'
+            ],
+            blockers: blockers
+        }
+    };
+}
+function supportHumanDecisionRequestGate(request, now) {
+    if (!request || !Object.keys(request).length) {
+        return undefined;
+    }
+    var statusText = cleanText(request.status, 120).toLowerCase();
+    var required = request.required === true || /required|open|pending|waiting/.test(statusText);
+    var resolved = /resolved|answered|approved|dismissed|complete/.test(statusText);
+    var evidence = plainObject(request.evidence);
+    var choices = asArray(request.choices);
+    var gateStatus = required && !resolved ? 'blocked' : 'warn';
+    return {
+        key: 'support_human_decision_request',
+        label: 'Support human decision request',
+        status: gateStatus,
+        reason: cleanText(request.reason || request.question || (gateStatus === 'blocked' ? 'Support run is waiting on an operator decision.' : 'Support human decision request was recorded.'), 1200),
+        evidenceRefs: cleanStringList(__spreadArray(__spreadArray(__spreadArray([], __read(asArray(evidence.required_artifacts || evidence.requiredArtifacts)), false), __read(asArray(evidence.recent_artifact_paths || evidence.recentArtifactPaths)), false), __read(asArray(evidence.changed_files || evidence.changedFiles)), false), 60, 500),
+        recordedAt: isoNow(now || request.created_at || request.createdAt || request.recorded_at || request.recordedAt),
+        metadata: {
+            requestId: cleanText(request.request_id || request.requestId, 180),
+            required: required,
+            status: statusText,
+            decisionKind: cleanText(request.decision_kind || request.decisionKind, 120),
+            approvalAction: cleanText(request.approval_action || request.approvalAction, 120),
+            canApproveFromConsole: request.can_approve_from_console === true || request.canApproveFromConsole === true,
+            preferredChoiceId: cleanText(request.preferred_choice_id || request.preferredChoiceId, 120),
+            choiceCount: choices.length,
+            choices: choices.slice(0, 6).map(function (choice) { return ({
+                choiceId: cleanText(choice.choice_id || choice.choiceId, 120),
+                action: cleanText(choice.action, 120),
+                label: cleanText(choice.label, 160),
+                safety: cleanText(choice.safety, 80),
+                disabled: choice.disabled === true
+            }); }).filter(function (choice) { return choice.choiceId || choice.action; }),
+            failureClass: cleanText(evidence.failure_class || evidence.failureClass, 120),
+            blockerFingerprint: cleanText(evidence.blocker_fingerprint || evidence.blockerFingerprint, 180),
+            evidenceHash: cleanText(evidence.evidence_hash || evidence.evidenceHash, 180),
+            dispatchAction: cleanText(evidence.dispatch_action || evidence.dispatchAction, 120),
+            requiresOverLimitApproval: evidence.requires_over_limit_approval === true || evidence.requiresOverLimitApproval === true,
+            requiresScopeReapproval: evidence.requires_scope_reapproval === true || evidence.requiresScopeReapproval === true,
+            requiresIntakeReapproval: evidence.requires_intake_reapproval === true || evidence.requiresIntakeReapproval === true,
+            requiresDiagnosisScopeReapproval: evidence.requires_diagnosis_scope_reapproval === true || evidence.requiresDiagnosisScopeReapproval === true,
+            requiresClassificationApproval: evidence.requires_classification_approval === true || evidence.requiresClassificationApproval === true,
+            requiresEstimateHours: evidence.requires_estimate_hours === true || evidence.requiresEstimateHours === true
+        }
+    };
+}
+function supportPostApprovalAutostartGate(packet, now) {
+    if (!packet || !Object.keys(packet).length) {
+        return undefined;
+    }
+    var contract = plainObject(packet.contract || packet.post_approval_autostart_contract || packet.postApprovalAutostartContract);
+    var record = plainObject(packet.record || packet.post_approval_autostart || packet.postApprovalAutostart);
+    if (!Object.keys(contract).length && !Object.keys(record).length) {
+        return undefined;
+    }
+    var result = plainObject(record.result);
+    var statusText = cleanText(record.status || packet.status || contract.status, 120).toLowerCase();
+    var contractStatus = cleanText(contract.status, 120).toLowerCase();
+    var resultStatus = cleanText(record.result_status || record.resultStatus || result.status, 120).toLowerCase();
+    var nextAction = cleanText(record.next_action || record.nextAction || packet.next_action || packet.nextAction, 160);
+    var error = cleanText(record.error || result.error, 1000);
+    var runId = cleanText(record.run_id || record.runId || result.run_id || result.runId, 180);
+    var resumeContract = plainObject(record.resume_contract || record.resumeContract || record.post_approval_resume_contract || record.postApprovalResumeContract);
+    var failureClass = cleanText(record.failure_class || record.failureClass, 120);
+    var blockerFingerprint = cleanText(record.blocker_fingerprint || record.blockerFingerprint, 180);
+    var blockerReason = cleanText(record.blocker_reason || record.blockerReason, 1200);
+    var scopeFingerprint = cleanText(record.scope_fingerprint
+        || record.scopeFingerprint
+        || contract.scope_fingerprint
+        || contract.scopeFingerprint
+        || resumeContract.scope_fingerprint
+        || resumeContract.scopeFingerprint, 180);
+    var approvalBoundaryValid = record.approval_boundary_valid === true
+        || record.approvalBoundaryValid === true;
+    var canRetryWithoutReapproval = record.can_retry_without_reapproval === true
+        || record.canRetryWithoutReapproval === true;
+    var safeRetryAction = cleanText(record.safe_retry_action || record.safeRetryAction || resumeContract.action, 160);
+    var blockers = cleanStringList(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(asArray(contract.blockers)), false), __read(asArray(record.blockers)), false), __read(asArray(result.blockers)), false), [
+        blockerReason,
+        error,
+        contractStatus === 'ready' && !Object.keys(record).length ? 'Autostart contract is ready but no dispatch result was recorded.' : ''
+    ], false), 40, 500);
+    var started = /^(started|already_running|running)$/.test(statusText)
+        || /^(started|already_running|running)$/.test(resultStatus)
+        || record.can_continue_without_codex_monitor === true
+        || record.canContinueWithoutCodexMonitor === true;
+    var skipped = statusText === 'skipped' || contractStatus === 'skipped';
+    var blocked = !started && (/blocked|failed|fail|error/.test(statusText)
+        || /blocked|failed|fail|error|busy/.test(resultStatus)
+        || nextAction === 'resolve_autostart_blocker'
+        || !!error
+        || (contractStatus === 'ready' && !Object.keys(record).length));
+    var gateStatus = started
+        ? 'pass'
+        : blocked
+            ? 'blocked'
+            : skipped
+                ? 'warn'
+                : 'warn';
+    var options = plainObject(contract.options);
+    var reason = started
+        ? 'Approved support autonomy autostart dispatched the auto-improve loop; no parallel Codex monitor is required.'
+        : blocked
+            ? cleanText(blockers.join(' ') || contract.reason || result.message || 'Approved support autonomy did not autostart and needs a concrete blocker resolved.', 1200)
+            : skipped
+                ? cleanText(contract.reason || 'Approved support autonomy autostart was skipped by request; manual start is required when ready.', 1200)
+                : cleanText(contract.reason || result.message || 'Approved support autonomy autostart result is recorded but not dispatch-ready.', 1200);
+    return {
+        key: 'support_post_approval_autostart',
+        label: 'Support post-approval autostart',
+        status: gateStatus,
+        reason: reason,
+        evidenceRefs: cleanStringList(__spreadArray(__spreadArray(__spreadArray([], __read(asArray(contract.required_terminal_evidence || contract.requiredTerminalEvidence)), false), __read(asArray(record.artifact_paths || record.artifactPaths)), false), __read(asArray(result.artifact_paths || result.artifactPaths)), false), 60, 500),
+        recordedAt: isoNow(now || record.recorded_at || record.recordedAt || contract.recorded_at || contract.recordedAt),
+        metadata: {
+            source: cleanText(packet.source, 120),
+            status: statusText || contractStatus,
+            contractStatus: contractStatus,
+            resultStatus: resultStatus,
+            failureClass: failureClass,
+            blockerFingerprint: blockerFingerprint,
+            blockerReason: blockerReason,
+            approvalBoundaryValid: approvalBoundaryValid,
+            canRetryWithoutReapproval: canRetryWithoutReapproval,
+            safeRetryAction: safeRetryAction,
+            resumeContract: resumeContract,
+            postApprovalResumeContract: resumeContract,
+            started: started,
+            skipped: skipped,
+            blocked: blocked,
+            nextAction: nextAction,
+            runId: runId,
+            activeTicketId: cleanText(result.active_ticket_id || result.activeTicketId, 180),
+            activeRunId: cleanText(result.active_run_id || result.activeRunId, 180),
+            error: error,
+            contractId: cleanText(contract.contract_id || contract.contractId || record.contract_id || record.contractId, 180),
+            recordId: cleanText(record.record_id || record.recordId, 180),
+            approvalContractId: cleanText(contract.approval_contract_id || contract.approvalContractId || record.approval_contract_id || record.approvalContractId, 180),
+            scopeFingerprint: scopeFingerprint,
+            method: cleanText(record.method || contract.method, 180),
+            autoStartEnabled: contract.auto_start_enabled === true || contract.autoStartEnabled === true || record.auto_start_enabled === true || record.autoStartEnabled === true,
+            canContinueWithoutCodexMonitor: record.can_continue_without_codex_monitor === true || record.canContinueWithoutCodexMonitor === true,
+            blocksManualCodexMonitoring: record.blocks_manual_codex_monitoring === true || record.blocksManualCodexMonitoring === true,
+            terminalTarget: cleanText(contract.terminal_target || contract.terminalTarget, 800),
+            targetGrade: cleanText(contract.target_grade || contract.targetGrade, 20),
+            maxIterations: Number(options.max_iterations || options.maxIterations || 0),
+            iterationTimeoutMs: Number(options.iteration_timeout_ms || options.iterationTimeoutMs || 0),
+            autoCreatePr: options.auto_create_pr === true || options.autoCreatePr === true,
+            forceNewJob: options.force_new_job === true || options.forceNewJob === true,
+            forceRestart: options.force_restart === true || options.forceRestart === true,
+            budgetSoftUsd: Number(options.budget_soft_usd || options.budgetSoftUsd || 0),
+            budgetHardUsd: Number(options.budget_hard_usd || options.budgetHardUsd || 0),
+            executionTier: cleanText(options.execution_tier || options.executionTier, 120),
+            requiredTerminalEvidence: cleanStringList(contract.required_terminal_evidence || contract.requiredTerminalEvidence, 30, 500),
+            allowedAutoActions: cleanStringList(contract.allowed_auto_actions || contract.allowedAutoActions, 30, 240),
+            forbiddenWithoutReapproval: cleanStringList(contract.forbidden_without_reapproval || contract.forbiddenWithoutReapproval, 30, 500),
+            blockers: blockers
+        }
+    };
+}
+function supportPostApprovalResumeAttemptGate(packet, now) {
+    if (!packet || !Object.keys(packet).length) {
+        return undefined;
+    }
+    var record = plainObject(packet.record || packet.post_approval_resume_attempt || packet.postApprovalResumeAttempt);
+    if (!Object.keys(record).length) {
+        return undefined;
+    }
+    var result = plainObject(record.result);
+    var resumeContract = plainObject(record.resume_contract || record.resumeContract || record.post_approval_resume_contract || record.postApprovalResumeContract);
+    var startGuard = plainObject(record.start_guard || record.startGuard || result.autoloop_start_guard || result.autoloopStartGuard);
+    var statusText = cleanText(record.status || packet.status || result.status, 120).toLowerCase();
+    var resultStatus = cleanText(record.result_status || record.resultStatus || result.status, 120).toLowerCase();
+    var nextAction = cleanText(record.next_action || record.nextAction || packet.next_action || packet.nextAction, 160);
+    var failureClass = cleanText(record.failure_class || record.failureClass, 120);
+    var blockerFingerprint = cleanText(record.blocker_fingerprint || record.blockerFingerprint, 180);
+    var blockerReason = cleanText(record.blocker_reason || record.blockerReason, 1200);
+    var runId = cleanText(record.run_id || record.runId || result.run_id || result.runId, 180);
+    var error = cleanText(record.error || result.error, 1000);
+    var started = /^(started|already_running|running)$/.test(statusText)
+        || /^(started|already_running|running)$/.test(resultStatus)
+        || record.can_continue_without_codex_monitor === true
+        || record.canContinueWithoutCodexMonitor === true;
+    var blocked = !started && (/blocked|failed|fail|error|busy/.test(statusText)
+        || /blocked|failed|fail|error|busy/.test(resultStatus)
+        || !!failureClass
+        || !!blockerReason
+        || !!error
+        || startGuard.allowed === false);
+    var gateStatus = started
+        ? 'pass'
+        : blocked
+            ? 'blocked'
+            : 'warn';
+    var blockers = cleanStringList(__spreadArray(__spreadArray([], __read(asArray(record.blockers)), false), [
+        blockerReason,
+        error,
+        startGuard.reason,
+        result.reason
+    ], false), 40, 500);
+    var reason = started
+        ? 'Approved support auto-improve loop resume started under the recorded approval/scope contract.'
+        : blocked
+            ? cleanText(blockers.join(' ') || 'Approved support auto-improve loop resume did not start and needs a fresh blocker review before another retry.', 1200)
+            : 'Approved support auto-improve loop resume attempt was recorded but has no terminal start result.';
+    return {
+        key: 'support_post_approval_resume_attempt',
+        label: 'Support post-approval resume attempt',
+        status: gateStatus,
+        reason: reason,
+        evidenceRefs: cleanStringList(__spreadArray(__spreadArray([], __read(asArray(record.artifact_paths || record.artifactPaths)), false), __read(asArray(result.artifact_paths || result.artifactPaths)), false), 60, 500),
+        recordedAt: isoNow(now || record.recorded_at || record.recordedAt),
+        metadata: {
+            source: cleanText(packet.source, 120),
+            status: statusText,
+            resultStatus: resultStatus,
+            failureClass: failureClass,
+            blockerFingerprint: blockerFingerprint,
+            blockerReason: blockerReason,
+            started: started,
+            blocked: blocked,
+            nextAction: nextAction,
+            runId: runId,
+            activeTicketId: cleanText(record.active_ticket_id || record.activeTicketId || result.active_ticket_id || result.activeTicketId, 180),
+            activeRunId: cleanText(record.active_run_id || record.activeRunId || result.active_run_id || result.activeRunId, 180),
+            activeJobId: cleanText(record.active_job_id || record.activeJobId || result.active_job_id || result.activeJobId, 180),
+            error: error,
+            attemptId: cleanText(record.attempt_id || record.attemptId, 180),
+            contractId: cleanText(record.contract_id || record.contractId || resumeContract.contract_id || resumeContract.contractId, 180),
+            approvalContractId: cleanText(record.approval_contract_id || record.approvalContractId || resumeContract.approval_contract_id || resumeContract.approvalContractId, 180),
+            scopeFingerprint: cleanText(record.scope_fingerprint || record.scopeFingerprint || resumeContract.scope_fingerprint || resumeContract.scopeFingerprint, 180),
+            resumeContract: resumeContract,
+            postApprovalResumeContract: resumeContract,
+            startGuard: startGuard,
+            startGuardStatus: cleanText(record.start_guard_status || record.startGuardStatus || startGuard.status, 120),
+            canContinueWithoutCodexMonitor: record.can_continue_without_codex_monitor === true || record.canContinueWithoutCodexMonitor === true,
+            productRepairAllowed: record.product_repair_allowed === true || record.productRepairAllowed === true,
+            canSendCustomerReply: record.can_send_customer_reply === true || record.canSendCustomerReply === true,
+            blockers: blockers
+        }
+    };
+}
+function supportIntakeRevisionContractGate(contract, now) {
+    if (!contract || !Object.keys(contract).length) {
+        return undefined;
+    }
+    var statusText = cleanText(contract.status, 120).toLowerCase();
+    var changedFields = asArray(contract.changed_fields || contract.changedFields)
+        .map(function (entry) { return ({
+        field: cleanText(entry.field, 120),
+        previous: cleanText(entry.previous, 500),
+        next: cleanText(entry.next, 500)
+    }); })
+        .filter(function (entry) { return entry.field; });
+    var changedFieldNames = cleanStringList(contract.changed_field_names || contract.changedFieldNames, 40, 120).length
+        ? cleanStringList(contract.changed_field_names || contract.changedFieldNames, 40, 120)
+        : changedFields.map(function (entry) { return entry.field; });
+    var requiresReapproval = contract.requires_reapproval === true
+        || contract.requiresReapproval === true
+        || /approval_required|reapproval_required|waiting_for_operator/.test(statusText);
+    var blocksProductRepair = contract.blocks_product_repair === true
+        || contract.blocksProductRepair === true
+        || requiresReapproval;
+    var blocksAutoRetry = contract.blocks_auto_retry === true
+        || contract.blocksAutoRetry === true
+        || requiresReapproval;
+    var gateStatus = blocksProductRepair
+        ? 'blocked'
+        : changedFieldNames.length
+            ? 'warn'
+            : 'pass';
+    var reason = gateStatus === 'blocked'
+        ? cleanText(contract.reason || 'Support intake/classification changed after approval; product repair is parked until the revised scope is approved.', 1200)
+        : changedFieldNames.length
+            ? cleanText(contract.reason || 'Support intake/classification edit was recorded without requiring reapproval.', 1200)
+            : cleanText(contract.reason || 'Support intake revision contract is recorded.', 1200);
+    return {
+        key: 'support_intake_revision_contract',
+        label: 'Support intake revision contract',
+        status: gateStatus,
+        reason: reason,
+        evidenceRefs: cleanStringList(__spreadArray(__spreadArray([], __read(changedFieldNames), false), [
+            contract.previous_autonomy_contract_id || contract.previousAutonomyContractId,
+            contract.previous_scope_fingerprint || contract.previousScopeFingerprint,
+            contract.next_scope_fingerprint || contract.nextScopeFingerprint
+        ], false), 80, 500),
+        recordedAt: isoNow(now || contract.updated_at || contract.updatedAt || contract.recorded_at || contract.recordedAt),
+        metadata: {
+            contractId: cleanText(contract.contract_id || contract.contractId, 180),
+            status: statusText,
+            requiresReapproval: requiresReapproval,
+            blocksProductRepair: blocksProductRepair,
+            blocksAutoRetry: blocksAutoRetry,
+            requiredOperatorAction: cleanText(contract.required_operator_action || contract.requiredOperatorAction, 160),
+            previousAutonomyContractId: cleanText(contract.previous_autonomy_contract_id || contract.previousAutonomyContractId, 180),
+            previousScopeFingerprint: cleanText(contract.previous_scope_fingerprint || contract.previousScopeFingerprint, 180),
+            nextScopeFingerprint: cleanText(contract.next_scope_fingerprint || contract.nextScopeFingerprint, 180),
+            intakeScopeFingerprint: cleanText(contract.intake_scope_fingerprint || contract.intakeScopeFingerprint, 180),
+            changedFieldNames: changedFieldNames,
+            changedFields: changedFields,
+            approvalImpactingEditFields: cleanStringList(contract.approval_impacting_edit_fields || contract.approvalImpactingEditFields, 40, 120),
+            updatedBy: cleanText(contract.updated_by || contract.updatedBy, 160),
+            blockers: cleanStringList(contract.blockers, 40, 500)
+        }
+    };
+}
+function supportManagerContinuationGate(packet, now) {
+    var _a, _b, _c;
+    if (!packet || !Object.keys(packet).length) {
+        return undefined;
+    }
+    var continuationContract = plainObject(packet.continuation_contract || packet.continuationContract);
+    var operatorGuidanceResponse = plainObject(packet.operator_guidance_response || packet.operatorGuidanceResponse);
+    var resumeUnblockContract = plainObject(packet.resume_unblock_contract || packet.resumeUnblockContract);
+    var resumeUnblockResponse = plainObject(packet.resume_unblock_response || packet.resumeUnblockResponse);
+    var resumeDispatch = plainObject(packet.resume_dispatch || packet.resumeDispatch);
+    var responseStatus = cleanText(operatorGuidanceResponse.status, 120).toLowerCase();
+    var dispatchStatus = cleanText(resumeDispatch.status || ((_a = resumeDispatch.result) === null || _a === void 0 ? void 0 : _a.status), 120).toLowerCase();
+    var continuationStatus = cleanText(continuationContract.status, 120).toLowerCase();
+    var operatorAccepted = operatorGuidanceResponse.accepted === true || responseStatus === 'accepted' || responseStatus === 'consumed';
+    var operatorConsumed = operatorGuidanceResponse.consumed === true || responseStatus === 'consumed' || !!cleanText(operatorGuidanceResponse.consumed_at || operatorGuidanceResponse.consumedAt, 120);
+    var unblockContractPresent = Object.keys(resumeUnblockContract).length > 0;
+    var dispatchQueued = /queued|scheduled|started|running|complete|completed|success|succeeded/.test(dispatchStatus);
+    var canRunWithoutCodexMonitor = operatorGuidanceResponse.can_run_without_codex_monitor === true
+        || operatorGuidanceResponse.canRunWithoutCodexMonitor === true
+        || continuationContract.can_run_without_codex_monitor === true
+        || continuationContract.canRunWithoutCodexMonitor === true;
+    var action = cleanText(resumeUnblockContract.action
+        || operatorGuidanceResponse.submit_action
+        || operatorGuidanceResponse.submitAction
+        || operatorGuidanceResponse.requested_action
+        || operatorGuidanceResponse.requestedAction
+        || continuationContract.action
+        || continuationContract.next_action
+        || continuationContract.nextAction, 180);
+    var blockers = cleanStringList(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(asArray(packet.blockers)), false), __read(asArray(continuationContract.blockers)), false), __read(asArray(operatorGuidanceResponse.blockers)), false), __read(asArray(resumeUnblockContract.blockers)), false), [
+        Object.keys(operatorGuidanceResponse).length && !operatorAccepted ? 'Operator guidance response is not accepted.' : '',
+        operatorAccepted && !unblockContractPresent ? 'Accepted operator guidance is missing a resume_unblock_contract.' : '',
+        dispatchStatus && /fail|failed|error|rejected|blocked/.test(dispatchStatus) ? 'Operator guidance resume dispatch failed or is blocked.' : ''
+    ], false), 40, 500);
+    var status = blockers.length
+        ? 'blocked'
+        : dispatchQueued || (operatorAccepted && unblockContractPresent)
+            ? 'pass'
+            : 'warn';
+    var artifactPaths = cleanStringList(__spreadArray(__spreadArray(__spreadArray([], __read(asArray(resumeUnblockResponse.artifact_paths || resumeUnblockResponse.artifactPaths)), false), __read(asArray(operatorGuidanceResponse.artifact_paths || operatorGuidanceResponse.artifactPaths)), false), __read(asArray(continuationContract.artifact_paths || continuationContract.artifactPaths)), false), 60, 500);
+    var requiredStateTransition = cleanText(resumeUnblockContract.required_state_transition
+        || resumeUnblockContract.requiredStateTransition
+        || continuationContract.required_state_transition
+        || continuationContract.requiredStateTransition
+        || continuationContract.expected_state_transition
+        || continuationContract.expectedStateTransition, 1000);
+    return {
+        key: 'support_manager_continuation',
+        label: 'Support manager continuation',
+        status: status,
+        reason: status === 'pass'
+            ? 'Support manager has a structured continuation/unblock path that can resume without a parallel Codex monitor.'
+            : cleanText(blockers.join(' ') || continuationContract.reason || operatorGuidanceResponse.reason || 'Support manager continuation state is recorded but not yet dispatch-ready.', 1200),
+        evidenceRefs: artifactPaths,
+        recordedAt: isoNow(now || packet.recorded_at || packet.recordedAt),
+        metadata: {
+            source: cleanText(packet.source, 160),
+            managerStatus: cleanText(packet.manager_status || packet.managerStatus, 120),
+            continuationContractId: cleanText(continuationContract.contract_id || continuationContract.contractId, 180),
+            continuationStatus: continuationStatus,
+            action: action,
+            requiredStateTransition: requiredStateTransition,
+            operatorGuidanceResponseId: cleanText(operatorGuidanceResponse.response_id || operatorGuidanceResponse.responseId, 180),
+            operatorGuidanceId: cleanText(operatorGuidanceResponse.guidance_id || operatorGuidanceResponse.guidanceId, 180),
+            operatorGuidanceAccepted: operatorAccepted,
+            operatorGuidanceConsumed: operatorConsumed,
+            responseStatus: responseStatus,
+            resumeUnblockContractId: cleanText(resumeUnblockContract.contract_id || resumeUnblockContract.contractId, 180),
+            resumeUnblockAction: cleanText(resumeUnblockContract.action, 180),
+            resumeDispatchStatus: dispatchStatus,
+            resumeDispatchJobId: cleanText(resumeDispatch.job_id || resumeDispatch.jobId || ((_b = resumeDispatch.result) === null || _b === void 0 ? void 0 : _b.job_id) || ((_c = resumeDispatch.result) === null || _c === void 0 ? void 0 : _c.jobId), 180),
+            canRunWithoutCodexMonitor: canRunWithoutCodexMonitor,
+            safeToAutoRunAfterInput: operatorGuidanceResponse.safe_to_autorun_after_input === true || operatorGuidanceResponse.safeToAutorunAfterInput === true,
+            blocksProductRepairUntilChangedEvidence: resumeUnblockContract.blocks_product_repair_until_changed_evidence === true || resumeUnblockContract.blocksProductRepairUntilChangedEvidence === true,
+            proofRequiredBeforeContinuation: resumeUnblockContract.proof_required_before_continuation === true || resumeUnblockContract.proofRequiredBeforeContinuation === true,
+            allowedAfterInput: cleanStringList(resumeUnblockContract.allowed_after_input || resumeUnblockContract.allowedAfterInput, 20, 240),
+            materialEvidenceClaimed: resumeUnblockResponse.material_evidence_claimed === true || resumeUnblockResponse.materialEvidenceClaimed === true,
+            materialEvidenceSignals: cleanStringList(resumeUnblockResponse.material_evidence_signals || resumeUnblockResponse.materialEvidenceSignals, 20, 240),
+            artifactPaths: artifactPaths,
+            blockers: blockers
+        }
+    };
+}
+function supportPrReadinessContractObject(ticket, job, evidence) {
+    var ticketAutomation = plainObject(ticket.automation);
+    var ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
+    var runnerConsole = plainObject(ticketAutomation.runner_console || ticketAutomation.runnerConsole);
+    var autonomousDecision = supportAutonomyDecisionObject(ticket, job, evidence);
+    var recovery = plainObject(autonomousDecision.managerRecovery || autonomousDecision.manager_recovery);
+    return evidenceObject(job.supportPrReadinessContract, job.support_pr_readiness_contract, job.prReadinessContract, job.pr_readiness_contract, evidence.supportPrReadinessContract, evidence.support_pr_readiness_contract, evidence.prReadinessContract, evidence.pr_readiness_contract, autonomousDecision.prReadinessContract, autonomousDecision.pr_readiness_contract, recovery.prReadinessContract, recovery.pr_readiness_contract, ticket.supportPrReadinessContract, ticket.support_pr_readiness_contract, ticket.prReadinessContract, ticket.pr_readiness_contract, runnerConsole.last_pr_readiness_contract, runnerConsole.lastPrReadinessContract, runnerConsole.pr_readiness_contract, runnerConsole.prReadinessContract, ticketManager.last_pr_readiness_contract, ticketManager.lastPrReadinessContract, ticketManager.pr_readiness_contract, ticketManager.prReadinessContract);
+}
+function supportPrReadinessContractGate(contract, now) {
+    var _a;
+    if (!contract || !Object.keys(contract).length) {
+        return undefined;
+    }
+    var statusText = cleanText(contract.status, 120).toLowerCase();
+    var ready = contract.ready === true || statusText === 'ready';
+    var blockers = cleanStringList(contract.blockers, 50, 500);
+    var businessProofArtifacts = cleanStringList(contract.business_proof_artifacts || contract.businessProofArtifacts, 80, 500);
+    var modifiedFiles = cleanStringList(contract.modified_files || contract.modifiedFiles, 120, 500);
+    var pullRequestUrl = cleanText(contract.pull_request_url || contract.pullRequestUrl, 500);
+    var status = ready ? 'pass' : 'blocked';
+    return {
+        key: 'support_pr_readiness_contract',
+        label: 'Support PR readiness contract',
+        status: status,
+        reason: ready
+            ? cleanText(contract.reason || 'Business proof is ready and PR packaging can run without merge/release/customer send.', 1200)
+            : cleanText(blockers.join(' ') || contract.reason || 'PR creation is blocked until support business proof and PR readiness evidence pass.', 1200),
+        evidenceRefs: cleanStringList(__spreadArray(__spreadArray([], __read(businessProofArtifacts), false), __read(modifiedFiles), false), 120, 500),
+        recordedAt: isoNow(now || contract.created_at || contract.createdAt || contract.recorded_at || contract.recordedAt),
+        metadata: {
+            contractId: cleanText(contract.contract_id || contract.contractId, 180),
+            status: statusText,
+            ready: ready,
+            action: cleanText(contract.action, 120),
+            dispatchAction: cleanText(contract.dispatch_action || contract.dispatchAction, 120),
+            method: cleanText(contract.method, 180),
+            businessProofReady: contract.business_proof_ready === true || contract.businessProofReady === true,
+            diagnosisValid: contract.diagnosis_valid === true || contract.diagnosisValid === true,
+            jobPhase: cleanText(contract.job_phase || contract.jobPhase, 120),
+            jobId: cleanText(contract.job_id || contract.jobId, 180),
+            pullRequestUrl: pullRequestUrl,
+            pullRequestStatus: cleanText(contract.pull_request_status || contract.pullRequestStatus, 120),
+            prFailureStatus: cleanText(contract.pr_failure_status || contract.prFailureStatus, 120),
+            confidenceBlocksPr: contract.confidence_blocks_pr === true || contract.confidenceBlocksPr === true,
+            passedBusinessAssertionCount: numberValue((_a = contract.passed_business_assertion_count) !== null && _a !== void 0 ? _a : contract.passedBusinessAssertionCount) || 0,
+            businessProofArtifacts: businessProofArtifacts,
+            modifiedFiles: modifiedFiles,
+            requiredEvidence: cleanStringList(contract.required_evidence || contract.requiredEvidence, 40, 500),
+            forbiddenActions: cleanStringList(contract.forbidden_actions || contract.forbiddenActions, 40, 500),
+            nextActionAfterPr: cleanText(contract.next_action_after_pr || contract.nextActionAfterPr, 160),
+            targetGrade: cleanText(contract.target_grade || contract.targetGrade || 'A', 20),
+            mergeBlockedUntilHumanApproval: contract.merge_blocked_until_human_approval === true || contract.mergeBlockedUntilHumanApproval === true,
+            customerReplyBlockedUntilReleaseGate: contract.customer_reply_blocked_until_release_gate === true || contract.customerReplyBlockedUntilReleaseGate === true,
+            releaseBlockedUntilPrReview: contract.release_blocked_until_pr_review === true || contract.releaseBlockedUntilPrReview === true,
+            blockers: blockers
+        }
+    };
+}
+function supportPrReviewContractObject(ticket, job, evidence) {
+    var ticketAutomation = plainObject(ticket.automation);
+    var ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
+    var runnerConsole = plainObject(ticketAutomation.runner_console || ticketAutomation.runnerConsole);
+    var autonomousDecision = supportAutonomyDecisionObject(ticket, job, evidence);
+    var recovery = plainObject(autonomousDecision.managerRecovery || autonomousDecision.manager_recovery);
+    var autopilotProgress = plainObject(autonomousDecision.autopilot_completion_progress || autonomousDecision.autopilotCompletionProgress);
+    return evidenceObject(job.supportPrReviewContract, job.support_pr_review_contract, job.prReviewContract, job.pr_review_contract, evidence.supportPrReviewContract, evidence.support_pr_review_contract, evidence.prReviewContract, evidence.pr_review_contract, autonomousDecision.prReviewContract, autonomousDecision.pr_review_contract, recovery.prReviewContract, recovery.pr_review_contract, autopilotProgress.prReviewContract, autopilotProgress.pr_review_contract, ticket.supportPrReviewContract, ticket.support_pr_review_contract, ticket.prReviewContract, ticket.pr_review_contract, runnerConsole.last_pr_review_contract, runnerConsole.lastPrReviewContract, runnerConsole.pr_review_contract, runnerConsole.prReviewContract, ticketManager.last_pr_review_contract, ticketManager.lastPrReviewContract, ticketManager.pr_review_contract, ticketManager.prReviewContract);
+}
+function supportGradeMeetsA(value) {
+    return /^(A\+|A|A-)$/i.test(cleanText(value, 20));
+}
+function supportPrReviewContractGate(contract, now) {
+    if (!contract || !Object.keys(contract).length) {
+        return undefined;
+    }
+    var grades = plainObject(contract.grades);
+    var executionGrade = cleanText(contract.execution_grade || contract.executionGrade || grades.execution || grades.execution_grade || grades.executionGrade, 20).toUpperCase();
+    var artifactsGrade = cleanText(contract.artifacts_grade || contract.artifactsGrade || grades.artifacts || grades.artifacts_grade || grades.artifactsGrade, 20).toUpperCase();
+    var pullRequestGrade = cleanText(contract.pull_request_grade || contract.pullRequestGrade || grades.pull_request || grades.pullRequest || grades.pr || grades.pr_grade, 20).toUpperCase();
+    var strictGatePassed = contract.strict_gate_passed === true
+        || contract.strictGatePassed === true
+        || contract.passes_strict_gate === true
+        || contract.passesStrictGate === true;
+    var statusText = cleanText(contract.status, 120).toLowerCase();
+    var ready = contract.ready === true
+        || strictGatePassed === true
+        || (statusText === 'passed' && supportGradeMeetsA(executionGrade) && supportGradeMeetsA(artifactsGrade) && supportGradeMeetsA(pullRequestGrade));
+    var blockers = cleanStringList(contract.blockers, 50, 500);
+    var evidenceRefs = cleanStringList(contract.evidence_refs || contract.evidenceRefs || contract.artifacts || contract.artifact_paths || contract.artifactPaths, 100, 500);
+    var continuationContract = plainObject(contract.continuation_contract || contract.continuationContract);
+    var status = ready ? 'pass' : 'blocked';
+    return {
+        key: 'support_pr_review_contract',
+        label: 'Support A-grade PR review',
+        status: status,
+        reason: ready
+            ? cleanText(contract.reason || "Strict A-grade PR review passed (execution=".concat(executionGrade || '-', ", artifacts=").concat(artifactsGrade || '-', ", pull_request=").concat(pullRequestGrade || '-', ")."), 1200)
+            : cleanText(blockers.join(' ') || contract.reason || 'A-grade PR review is blocked until strict execution, artifact, pull_request, AIQa, before/action/after, and screenshot/trace evidence pass.', 1200),
+        evidenceRefs: evidenceRefs,
+        recordedAt: isoNow(now || contract.created_at || contract.createdAt || contract.recorded_at || contract.recordedAt),
+        metadata: {
+            contractId: cleanText(contract.contract_id || contract.contractId, 180),
+            status: statusText,
+            ready: ready,
+            strictGatePassed: strictGatePassed,
+            strictGateReason: cleanText(contract.strict_gate_reason || contract.strictGateReason || contract.reason, 500),
+            executionGrade: executionGrade,
+            artifactsGrade: artifactsGrade,
+            pullRequestGrade: pullRequestGrade,
+            targetGrade: cleanText(contract.target_grade || contract.targetGrade || 'A', 20),
+            pullRequestUrl: cleanText(contract.pull_request_url || contract.pullRequestUrl, 500),
+            pullRequestStatus: cleanText(contract.pull_request_status || contract.pullRequestStatus, 120),
+            failureClass: cleanText(contract.failure_class || contract.failureClass || continuationContract.failure_class || continuationContract.failureClass, 120),
+            blockerFingerprint: cleanText(contract.blocker_fingerprint || contract.blockerFingerprint || continuationContract.blocker_fingerprint || continuationContract.blockerFingerprint, 180),
+            evidenceHash: cleanText(contract.evidence_hash || contract.evidenceHash || continuationContract.evidence_hash || continuationContract.evidenceHash, 180),
+            continuationContract: Object.keys(continuationContract).length ? {
+                contractId: cleanText(continuationContract.contract_id || continuationContract.contractId, 180),
+                status: cleanText(continuationContract.status, 120),
+                action: cleanText(continuationContract.action, 160),
+                failureClass: cleanText(continuationContract.failure_class || continuationContract.failureClass, 120),
+                blockerFingerprint: cleanText(continuationContract.blocker_fingerprint || continuationContract.blockerFingerprint, 180),
+                evidenceHash: cleanText(continuationContract.evidence_hash || continuationContract.evidenceHash, 180),
+                reason: cleanText(continuationContract.reason, 1000),
+                requiredEvidence: cleanStringList(continuationContract.required_evidence || continuationContract.requiredEvidence, 40, 500),
+                resetEvidenceRequired: cleanStringList(continuationContract.reset_evidence_required || continuationContract.resetEvidenceRequired, 40, 500),
+                stopConditions: cleanStringList(continuationContract.stop_conditions || continuationContract.stopConditions, 40, 500),
+                canRunWithoutCodexMonitor: continuationContract.can_run_without_codex_monitor === true || continuationContract.canRunWithoutCodexMonitor === true,
+                productRepairAllowed: continuationContract.product_repair_allowed === true || continuationContract.productRepairAllowed === true,
+                releaseCustomerSideEffectsAllowed: continuationContract.release_customer_side_effects_allowed === true || continuationContract.releaseCustomerSideEffectsAllowed === true
+            } : undefined,
+            requiredEvidence: cleanStringList(contract.required_evidence || contract.requiredEvidence, 40, 500),
+            forbiddenActions: cleanStringList(contract.forbidden_actions || contract.forbiddenActions, 40, 500),
+            nextAction: cleanText(contract.next_action || contract.nextAction, 160),
+            blockers: blockers,
+            evidenceRefs: evidenceRefs
+        }
+    };
+}
+function supportPrCreationResultObject(ticket, job, evidence) {
+    var ticketAutomation = plainObject(ticket.automation);
+    var codex = plainObject(ticketAutomation.codex);
+    var release = plainObject(ticketAutomation.release);
+    var pushMaster = plainObject(release.push_master || release.pushMaster);
+    var qaValidation = plainObject(ticketAutomation.qa_validation || ticketAutomation.qaValidation);
+    var prReadinessContract = supportPrReadinessContractObject(ticket, job, evidence);
+    var pullRequestUrl = cleanText(evidence.pullRequestUrl
+        || evidence.pull_request_url
+        || job.pullRequestUrl
+        || job.pull_request_url
+        || prReadinessContract.pull_request_url
+        || prReadinessContract.pullRequestUrl
+        || codex.pull_request_url
+        || codex.pullRequestUrl
+        || pushMaster.pull_request_url
+        || pushMaster.pullRequestUrl
+        || qaValidation.pull_request_url
+        || qaValidation.pullRequestUrl, 500);
+    var pullRequestStatus = cleanText(evidence.pullRequestStatus
+        || evidence.pull_request_status
+        || job.pullRequestStatus
+        || job.pull_request_status
+        || prReadinessContract.pull_request_status
+        || prReadinessContract.pullRequestStatus
+        || codex.pull_request_status
+        || codex.pullRequestStatus, 120);
+    var prFailureStatus = cleanText(evidence.prFailureStatus
+        || evidence.pr_failure_status
+        || prReadinessContract.pr_failure_status
+        || prReadinessContract.prFailureStatus, 120);
+    var error = cleanText(evidence.pullRequestError
+        || evidence.pull_request_error
+        || job.pullRequestError
+        || job.pull_request_error
+        || codex.error
+        || pushMaster.notes, 1200);
+    var status = cleanText(evidence.prCreationStatus
+        || evidence.pr_creation_status
+        || evidence.status
+        || codex.status
+        || pullRequestStatus
+        || prFailureStatus
+        || (pullRequestUrl ? 'created' : ''), 120);
+    if (!pullRequestUrl && !pullRequestStatus && !prFailureStatus && !error && !status) {
+        return {};
+    }
+    return {
+        source: 'support_pr_creation_result',
+        status: status,
+        pull_request_url: pullRequestUrl,
+        pull_request_status: pullRequestStatus,
+        pr_failure_status: prFailureStatus,
+        error: error,
+        job_id: cleanText(job._id || job.id || job.jobId || prReadinessContract.job_id || prReadinessContract.jobId || codex.job_id || codex.jobId, 180),
+        method: cleanText(prReadinessContract.method || evidence.method || 'createSupportTicketCodexPullRequestManual', 180),
+        pr_readiness_contract_id: cleanText(prReadinessContract.contract_id || prReadinessContract.contractId, 180),
+        release_push_master_status: cleanText(pushMaster.status, 120),
+        release_push_master_notes: cleanText(pushMaster.notes, 1000),
+        modified_files: cleanStringList(evidence.modifiedFiles
+            || evidence.modified_files
+            || job.modifiedFiles
+            || job.modified_files
+            || codex.modified_files
+            || codex.modifiedFiles
+            || prReadinessContract.modified_files
+            || prReadinessContract.modifiedFiles, 120, 500),
+        business_proof_ready: prReadinessContract.business_proof_ready === true || prReadinessContract.businessProofReady === true,
+        diagnosis_valid: prReadinessContract.diagnosis_valid === true || prReadinessContract.diagnosisValid === true,
+        merge_blocked_until_human_approval: prReadinessContract.merge_blocked_until_human_approval === true || prReadinessContract.mergeBlockedUntilHumanApproval === true,
+        customer_reply_blocked_until_release_gate: prReadinessContract.customer_reply_blocked_until_release_gate === true || prReadinessContract.customerReplyBlockedUntilReleaseGate === true,
+        release_blocked_until_pr_review: prReadinessContract.release_blocked_until_pr_review === true || prReadinessContract.releaseBlockedUntilPrReview === true
+    };
+}
+function supportPrCreationResultGate(result, now) {
+    if (!result || !Object.keys(result).length) {
+        return undefined;
+    }
+    var statusText = cleanText(result.status, 120).toLowerCase();
+    var pullRequestStatus = cleanText(result.pull_request_status || result.pullRequestStatus, 120).toLowerCase();
+    var prFailureStatus = cleanText(result.pr_failure_status || result.prFailureStatus, 120).toLowerCase();
+    var pullRequestUrl = cleanText(result.pull_request_url || result.pullRequestUrl, 500);
+    var error = cleanText(result.error || result.message || result.reason, 1200);
+    var blocked = /blocked|manual|pending_manual|dependency|release_safety/.test(statusText)
+        || /blocked|manual|pending_manual|dependency|release_safety/.test(pullRequestStatus)
+        || !!prFailureStatus;
+    var failed = /fail|failed|error/.test(statusText)
+        || /fail|failed|error/.test(pullRequestStatus)
+        || /fail|failed|error/.test(prFailureStatus);
+    var created = !!pullRequestUrl && !blocked && !failed;
+    var status = created
+        ? 'pass'
+        : failed
+            ? 'fail'
+            : blocked
+                ? 'blocked'
+                : 'warn';
+    var reason = created
+        ? "Support PR was created: ".concat(pullRequestUrl)
+        : failed
+            ? cleanText(error || 'Support PR creation failed.', 1200)
+            : blocked
+                ? cleanText(error || result.release_push_master_notes || 'Support PR creation is blocked pending manual/platform repair.', 1200)
+                : 'Support PR creation has non-terminal or incomplete status.';
+    return {
+        key: 'support_pr_creation_result',
+        label: 'Support PR creation result',
+        status: status,
+        reason: reason,
+        evidenceRefs: cleanStringList(__spreadArray([
+            pullRequestUrl
+        ], __read(asArray(result.modified_files || result.modifiedFiles)), false), 120, 500),
+        recordedAt: isoNow(now || result.created_at || result.createdAt || result.updated_at || result.updatedAt),
+        metadata: {
+            status: statusText,
+            pullRequestUrl: pullRequestUrl,
+            pullRequestStatus: pullRequestStatus,
+            prFailureStatus: prFailureStatus,
+            error: error,
+            jobId: cleanText(result.job_id || result.jobId, 180),
+            method: cleanText(result.method, 180),
+            prReadinessContractId: cleanText(result.pr_readiness_contract_id || result.prReadinessContractId, 180),
+            releasePushMasterStatus: cleanText(result.release_push_master_status || result.releasePushMasterStatus, 120),
+            releasePushMasterNotes: cleanText(result.release_push_master_notes || result.releasePushMasterNotes, 1000),
+            modifiedFiles: cleanStringList(result.modified_files || result.modifiedFiles, 120, 500),
+            businessProofReady: result.business_proof_ready === true || result.businessProofReady === true,
+            diagnosisValid: result.diagnosis_valid === true || result.diagnosisValid === true,
+            mergeBlockedUntilHumanApproval: result.merge_blocked_until_human_approval === true || result.mergeBlockedUntilHumanApproval === true,
+            customerReplyBlockedUntilReleaseGate: result.customer_reply_blocked_until_release_gate === true || result.customerReplyBlockedUntilReleaseGate === true,
+            releaseBlockedUntilPrReview: result.release_blocked_until_pr_review === true || result.releaseBlockedUntilPrReview === true,
+            nextAction: created
+                ? 'review_a_grade_pr_and_release_gate'
+                : failed || blocked
+                    ? 'repair_pr_creation_blocker'
+                    : 'check_pr_creation_status'
+        }
+    };
+}
+function supportArtifactListHasScreenshotOrTrace(paths) {
+    return paths.some(function (artifact) { return /\.(?:png|jpe?g|webp|gif|mp4|webm|zip)$/i.test(artifact)
+        || /\b(?:trace|video|screenshot|screen-capture|playwright-report|test-results)\b/i.test(artifact); });
+}
+function supportStatusIn(value, statuses) {
+    var normalized = cleanText(value, 120).toLowerCase();
+    return !!normalized && statuses.includes(normalized);
+}
+function sameSupportEvidenceRef(left, right) {
+    var normalizedLeft = cleanText(left, 500).toLowerCase();
+    var normalizedRight = cleanText(right, 500).toLowerCase();
+    return !!normalizedLeft && !!normalizedRight && normalizedLeft === normalizedRight;
+}
+function supportEvidenceRefMatchesCurrent(current, candidate) {
+    var normalizedCandidate = cleanText(candidate, 500);
+    return !normalizedCandidate || sameSupportEvidenceRef(current, normalizedCandidate);
+}
+function supportEvidenceRefPresent(candidate) {
+    return !!cleanText(candidate, 500);
+}
+function supportReleaseCustomerAcceptanceObject(ticket, job, evidence, prReadinessContract) {
+    var ticketAutomation = plainObject(ticket.automation);
+    var jobAutomation = plainObject(job.automation);
+    var evidenceRelease = plainObject(evidence.release || evidence.releaseEvidence || evidence.release_evidence);
+    var release = __assign(__assign(__assign({}, plainObject(ticketAutomation.release)), plainObject(jobAutomation.release)), evidenceRelease);
+    var pushMaster = plainObject(release.push_master || release.pushMaster);
+    var deployProduction = plainObject(release.deploy_production || release.deployProduction || release.production);
+    var hotfixEvidenceState = plainObject(release.hotfix_evidence || release.hotfixEvidence);
+    var currentHotfix = plainObject(hotfixEvidenceState.current);
+    var hotfixEvidence = plainObject(hotfixEvidenceState.normalized
+        || currentHotfix.evidence
+        || currentHotfix.normalized
+        || hotfixEvidenceState.current_evidence
+        || hotfixEvidenceState.currentEvidence);
+    var customerReplyPolicy = plainObject(ticketAutomation.customer_reply_policy
+        || ticketAutomation.customerReplyPolicy
+        || job.customerReplyPolicy
+        || job.customer_reply_policy
+        || evidence.customerReplyPolicy
+        || evidence.customer_reply_policy);
+    var lastSendGuard = plainObject(customerReplyPolicy.last_send_guard || customerReplyPolicy.lastSendGuard);
+    var lastManualSend = plainObject(customerReplyPolicy.last_manual_send || customerReplyPolicy.lastManualSend);
+    var proofBackedSendContract = plainObject(customerReplyPolicy.last_proof_backed_send_contract || customerReplyPolicy.lastProofBackedSendContract);
+    var customerReplyReadiness = plainObject(evidence.customerReplyReadiness
+        || evidence.customer_reply_readiness
+        || customerReplyPolicy.readinessContract
+        || customerReplyPolicy.readiness_contract
+        || job.customerReplyReadiness
+        || job.customer_reply_readiness);
+    var pullRequestUrl = cleanText(prReadinessContract.pull_request_url
+        || prReadinessContract.pullRequestUrl
+        || evidence.pull_request_url
+        || evidence.pullRequestUrl
+        || job.pullRequestUrl
+        || job.pull_request_url, 500);
+    var releasePullRequestUrl = cleanText(pushMaster.pull_request_url
+        || pushMaster.pullRequestUrl
+        || release.pull_request_url
+        || release.pullRequestUrl, 500);
+    var deployPullRequestUrl = cleanText(deployProduction.last_deploy_pull_request_url
+        || deployProduction.lastDeployPullRequestUrl
+        || deployProduction.pull_request_url
+        || deployProduction.pullRequestUrl, 500);
+    var replyPullRequestUrl = cleanText(proofBackedSendContract.pull_request_url
+        || proofBackedSendContract.pullRequestUrl
+        || proofBackedSendContract.pr_url
+        || proofBackedSendContract.prUrl
+        || lastManualSend.pull_request_url
+        || lastManualSend.pullRequestUrl
+        || lastManualSend.pr_url
+        || lastManualSend.prUrl
+        || lastSendGuard.pull_request_url
+        || lastSendGuard.pullRequestUrl
+        || lastSendGuard.pr_url
+        || lastSendGuard.prUrl
+        || customerReplyReadiness.pull_request_url
+        || customerReplyReadiness.pullRequestUrl
+        || customerReplyReadiness.pr_url
+        || customerReplyReadiness.prUrl, 500);
+    var prReady = prReadinessContract.ready === true || cleanText(prReadinessContract.status, 120).toLowerCase() === 'ready';
+    var requiresFinalAcceptance = prReady && !!pullRequestUrl;
+    if (!requiresFinalAcceptance) {
+        return {};
+    }
+    var pushMasterStatus = cleanText(pushMaster.status, 120).toLowerCase();
+    var deployProductionStatus = cleanText(deployProduction.status, 120).toLowerCase();
+    var hotfixReleaseGateStatus = cleanText(hotfixEvidence.releaseGateStatus
+        || hotfixEvidence.release_gate_status
+        || hotfixEvidenceState.releaseGateStatus
+        || hotfixEvidenceState.release_gate_status
+        || hotfixEvidenceState.status, 120).toLowerCase();
+    var pushMasterComplete = supportStatusIn(pushMasterStatus, ['completed', 'complete', 'merged', 'success', 'succeeded']);
+    var productionDeployComplete = supportStatusIn(deployProductionStatus, ['completed', 'complete', 'deployed', 'success', 'succeeded', 'not_required', 'skipped']);
+    var productionDeployNotRequired = deployProduction.deploy_not_required === true
+        || deployProduction.deployNotRequired === true
+        || deployProduction.not_required === true
+        || deployProduction.notRequired === true;
+    var hotfixReleaseGatePassed = supportStatusIn(hotfixReleaseGateStatus, ['pass', 'passed', 'success', 'succeeded', 'completed', 'complete']);
+    var releasePrMatchesCurrent = supportEvidenceRefMatchesCurrent(pullRequestUrl, releasePullRequestUrl);
+    var deployPrMatchesCurrent = supportEvidenceRefMatchesCurrent(pullRequestUrl, deployPullRequestUrl);
+    var replyPrReferencePresent = supportEvidenceRefPresent(replyPullRequestUrl);
+    var replyPrMatchesCurrent = replyPrReferencePresent && sameSupportEvidenceRef(pullRequestUrl, replyPullRequestUrl);
+    var releaseReady = (pushMasterComplete || hotfixReleaseGatePassed)
+        && (productionDeployComplete || productionDeployNotRequired || hotfixReleaseGatePassed)
+        && releasePrMatchesCurrent
+        && deployPrMatchesCurrent;
+    var proofBackedSendStatus = cleanText(proofBackedSendContract.status || lastManualSend.status, 120).toLowerCase();
+    var proofBackedSendRecorded = supportStatusIn(proofBackedSendStatus, ['sent_after_manual_approval', 'sent', 'sent_after_review', 'completed', 'complete'])
+        && (proofBackedSendContract.proof_backed === true || proofBackedSendContract.proofBacked === true || lastManualSend.proof_backed === true || lastManualSend.proofBacked === true);
+    var sendGuardReady = (lastSendGuard.allowed === true || lastSendGuard.manual_send_after_review_allowed === true || lastSendGuard.manualSendAfterReviewAllowed === true)
+        && supportStatusIn(lastSendGuard.status, ['ready_for_manual_send', 'ready', 'pass', 'passed']);
+    var readinessStatus = cleanText(customerReplyReadiness.status, 120).toLowerCase();
+    var replyDraftReady = readinessStatus === 'draft_ready'
+        && (customerReplyReadiness.canDraftCustomerReply === true || customerReplyReadiness.can_draft_customer_reply === true)
+        && customerReplyReadiness.canSendCustomerReply !== true
+        && customerReplyReadiness.can_send_customer_reply !== true
+        && (customerReplyReadiness.proofBacked === true || customerReplyReadiness.proof_backed === true)
+        && (customerReplyReadiness.businessProofReady === true || customerReplyReadiness.business_proof_ready === true)
+        && (customerReplyReadiness.releaseReady === true || customerReplyReadiness.release_ready === true || releaseReady)
+        && (customerReplyReadiness.diagnosisReady === true || customerReplyReadiness.diagnosis_ready === true);
+    var customerReplyReady = (proofBackedSendRecorded || sendGuardReady || replyDraftReady) && replyPrMatchesCurrent;
+    var staleEvidenceBlockers = [
+        releasePrMatchesCurrent ? '' : 'Push-to-master evidence belongs to a different PR than the proof-backed support run.',
+        deployPrMatchesCurrent ? '' : 'Production deploy evidence belongs to a different PR than the proof-backed support run.',
+        replyPrReferencePresent ? '' : 'Proof-backed customer reply evidence is missing the current PR reference.',
+        replyPrReferencePresent && !replyPrMatchesCurrent ? 'Proof-backed customer reply evidence belongs to a different PR than the proof-backed support run.' : ''
+    ].filter(Boolean);
+    return {
+        source: 'support_release_customer_acceptance',
+        required: true,
+        pull_request_url: pullRequestUrl,
+        release_pull_request_url: releasePullRequestUrl,
+        deploy_pull_request_url: deployPullRequestUrl,
+        reply_pull_request_url: replyPullRequestUrl,
+        pr_ready: prReady,
+        push_master_status: pushMasterStatus,
+        deploy_production_status: deployProductionStatus,
+        hotfix_release_gate_status: hotfixReleaseGateStatus,
+        release_pr_matches_current: releasePrMatchesCurrent,
+        deploy_pr_matches_current: deployPrMatchesCurrent,
+        reply_pr_reference_present: replyPrReferencePresent,
+        reply_pr_matches_current: replyPrMatchesCurrent,
+        stale_evidence_blockers: staleEvidenceBlockers,
+        push_master_complete: pushMasterComplete,
+        production_deploy_complete: productionDeployComplete,
+        production_deploy_not_required: productionDeployNotRequired,
+        hotfix_release_gate_passed: hotfixReleaseGatePassed,
+        release_ready: releaseReady,
+        customer_reply_ready: customerReplyReady,
+        customer_reply_readiness_status: readinessStatus,
+        proof_backed_send_status: proofBackedSendStatus,
+        proof_backed_send_recorded: proofBackedSendRecorded,
+        send_guard_ready: sendGuardReady,
+        reply_draft_ready: replyDraftReady,
+        customer_reply_requires_human_approval: customerReplyReadiness.requiresHumanApproval !== false && customerReplyReadiness.requires_human_approval !== false,
+        next_action: releaseReady
+            ? (customerReplyReady ? 'no_action_required' : 'draft_or_review_proof_backed_customer_reply')
+            : 'review_a_grade_pr_and_release_gate',
+        evidence_refs: cleanStringList(__spreadArray(__spreadArray([
+            pullRequestUrl,
+            pushMaster.pull_request_url || pushMaster.pullRequestUrl,
+            deployProduction.last_deploy_pull_request_url || deployProduction.lastDeployPullRequestUrl
+        ], __read(asArray(customerReplyReadiness.evidenceRefs || customerReplyReadiness.evidence_refs)), false), __read(asArray(proofBackedSendContract.evidence_refs || proofBackedSendContract.evidenceRefs)), false), 80, 500)
+    };
+}
+function supportReleaseCustomerAcceptanceGate(contract, now) {
+    if (!contract || !Object.keys(contract).length) {
+        return undefined;
+    }
+    var releaseReady = contract.release_ready === true || contract.releaseReady === true;
+    var customerReplyReady = contract.customer_reply_ready === true || contract.customerReplyReady === true;
+    var blockers = __spreadArray([
+        releaseReady ? '' : 'Release/hotfix evidence is not ready after A-grade support PR proof.',
+        customerReplyReady ? '' : 'Proof-backed customer reply is not sent or draft-ready for human review.'
+    ], __read(cleanStringList(contract.stale_evidence_blockers || contract.staleEvidenceBlockers, 10, 500)), false).filter(Boolean);
+    var status = blockers.length ? 'blocked' : 'pass';
+    return {
+        key: 'support_release_customer_acceptance',
+        label: 'Support release/customer acceptance',
+        status: status,
+        reason: status === 'pass'
+            ? 'A-grade PR proof, release/hotfix evidence, and proof-backed customer reply readiness are complete.'
+            : blockers.join(' '),
+        evidenceRefs: cleanStringList(contract.evidence_refs || contract.evidenceRefs, 80, 500),
+        recordedAt: isoNow(now || contract.recorded_at || contract.recordedAt),
+        metadata: {
+            required: contract.required === true,
+            pullRequestUrl: cleanText(contract.pull_request_url || contract.pullRequestUrl, 500),
+            releasePullRequestUrl: cleanText(contract.release_pull_request_url || contract.releasePullRequestUrl, 500),
+            deployPullRequestUrl: cleanText(contract.deploy_pull_request_url || contract.deployPullRequestUrl, 500),
+            replyPullRequestUrl: cleanText(contract.reply_pull_request_url || contract.replyPullRequestUrl, 500),
+            prReady: contract.pr_ready === true || contract.prReady === true,
+            pushMasterStatus: cleanText(contract.push_master_status || contract.pushMasterStatus, 120),
+            deployProductionStatus: cleanText(contract.deploy_production_status || contract.deployProductionStatus, 120),
+            hotfixReleaseGateStatus: cleanText(contract.hotfix_release_gate_status || contract.hotfixReleaseGateStatus, 120),
+            releasePrMatchesCurrent: contract.release_pr_matches_current === true || contract.releasePrMatchesCurrent === true,
+            deployPrMatchesCurrent: contract.deploy_pr_matches_current === true || contract.deployPrMatchesCurrent === true,
+            replyPrReferencePresent: contract.reply_pr_reference_present === true || contract.replyPrReferencePresent === true,
+            replyPrMatchesCurrent: contract.reply_pr_matches_current === true || contract.replyPrMatchesCurrent === true,
+            pushMasterComplete: contract.push_master_complete === true || contract.pushMasterComplete === true,
+            productionDeployComplete: contract.production_deploy_complete === true || contract.productionDeployComplete === true,
+            productionDeployNotRequired: contract.production_deploy_not_required === true || contract.productionDeployNotRequired === true,
+            hotfixReleaseGatePassed: contract.hotfix_release_gate_passed === true || contract.hotfixReleaseGatePassed === true,
+            releaseReady: releaseReady,
+            customerReplyReady: customerReplyReady,
+            customerReplyReadinessStatus: cleanText(contract.customer_reply_readiness_status || contract.customerReplyReadinessStatus, 120),
+            proofBackedSendStatus: cleanText(contract.proof_backed_send_status || contract.proofBackedSendStatus, 120),
+            proofBackedSendRecorded: contract.proof_backed_send_recorded === true || contract.proofBackedSendRecorded === true,
+            sendGuardReady: contract.send_guard_ready === true || contract.sendGuardReady === true,
+            replyDraftReady: contract.reply_draft_ready === true || contract.replyDraftReady === true,
+            customerReplyRequiresHumanApproval: contract.customer_reply_requires_human_approval !== false && contract.customerReplyRequiresHumanApproval !== false,
+            nextAction: cleanText(contract.next_action || contract.nextAction, 160),
+            blockers: blockers
+        }
+    };
+}
+function supportAutopilotCompletionContractGate(approval, prReadinessContract, prReviewContract, now) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (!approval || !Object.keys(approval).length) {
+        return undefined;
+    }
+    var completionContract = plainObject(approval.autopilot_completion_contract || approval.autopilotCompletionContract);
+    var requiresCompletion = approval.after_approval_autopilot_until_a_grade === true
+        || approval.afterApprovalAutopilotUntilAGrade === true
+        || approval.autopilot_after_approval_until_a_grade === true
+        || Object.keys(completionContract).length > 0;
+    if (!requiresCompletion) {
+        return undefined;
+    }
+    var prReady = prReadinessContract.ready === true || cleanText(prReadinessContract.status, 120).toLowerCase() === 'ready';
+    var businessProofReady = prReadinessContract.business_proof_ready === true || prReadinessContract.businessProofReady === true;
+    var pullRequestUrl = cleanText(prReadinessContract.pull_request_url || prReadinessContract.pullRequestUrl, 500);
+    var prReviewGate = supportPrReviewContractGate(prReviewContract, now);
+    var prReviewReady = (prReviewGate === null || prReviewGate === void 0 ? void 0 : prReviewGate.status) === 'pass';
+    var businessProofArtifacts = cleanStringList(prReadinessContract.business_proof_artifacts || prReadinessContract.businessProofArtifacts, 80, 500);
+    var modifiedFiles = cleanStringList(prReadinessContract.modified_files || prReadinessContract.modifiedFiles, 120, 500);
+    var requiredCompletionEvidence = cleanStringList(approval.required_completion_evidence
+        || approval.requiredCompletionEvidence
+        || completionContract.required_evidence
+        || completionContract.requiredEvidence, 50, 500);
+    var missing = [];
+    if (businessProofReady !== true) {
+        missing.push('AIQaBusinessAssertion before/action/after business proof is not ready.');
+    }
+    if (approval.qa_screenshots_required === true || approval.qaScreenshotsRequired === true) {
+        if (!supportArtifactListHasScreenshotOrTrace(businessProofArtifacts)) {
+            missing.push('QA screenshot or trace artifact is missing.');
+        }
+    }
+    if (!modifiedFiles.length) {
+        missing.push('Changed-file or diff evidence is missing.');
+    }
+    if (!prReady) {
+        missing.push('PR readiness contract is not ready.');
+    }
+    if (prReady && !pullRequestUrl) {
+        missing.push('A-grade PR has not been created yet.');
+    }
+    if (prReady && pullRequestUrl && !prReviewReady) {
+        missing.push('A-grade execution/artifacts/pull_request review has not passed yet.');
+    }
+    var nextAction = businessProofReady !== true
+        ? 'run_business_proof_qa'
+        : prReady && !pullRequestUrl
+            ? 'create_pr'
+            : prReady && pullRequestUrl && !prReviewReady
+                ? 'run_a_grade_pr_review'
+                : !prReady
+                    ? 'continue_owner_scoped_repair'
+                    : 'review_a_grade_pr_and_release_gate';
+    var status = missing.length ? 'blocked' : 'pass';
+    return {
+        key: 'support_autopilot_completion_contract',
+        label: 'Support approved-autopilot completion',
+        status: status,
+        reason: missing.length
+            ? missing.join(' ')
+            : 'Approved support autopilot reached A-grade PR proof; merge, release, deploy, and customer reply remain separately gated.',
+        evidenceRefs: cleanStringList(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(businessProofArtifacts), false), __read(modifiedFiles), false), [
+            pullRequestUrl
+        ], false), __read(((prReviewGate === null || prReviewGate === void 0 ? void 0 : prReviewGate.evidenceRefs) || [])), false), __read(requiredCompletionEvidence), false), 140, 500),
+        recordedAt: isoNow(now || prReadinessContract.created_at || prReadinessContract.createdAt || approval.approved_at || approval.approvedAt),
+        metadata: {
+            mode: cleanText(completionContract.mode || 'approved_scope_to_a_grade_pr', 160),
+            status: status === 'pass' ? 'complete' : 'incomplete',
+            approved: approval.approved === true,
+            contractId: cleanText(approval.contract_id || approval.contractId, 180),
+            prReadinessContractId: cleanText(prReadinessContract.contract_id || prReadinessContract.contractId, 180),
+            prReviewContractId: cleanText((_a = prReviewGate === null || prReviewGate === void 0 ? void 0 : prReviewGate.metadata) === null || _a === void 0 ? void 0 : _a.contractId, 180),
+            nextAction: nextAction,
+            targetGrade: cleanText(approval.target_grade || approval.targetGrade || prReadinessContract.target_grade || prReadinessContract.targetGrade || 'A', 20),
+            businessProofReady: businessProofReady,
+            prReady: prReady,
+            pullRequestUrl: pullRequestUrl,
+            pullRequestStatus: cleanText(prReadinessContract.pull_request_status || prReadinessContract.pullRequestStatus, 120),
+            prReviewReady: prReviewReady,
+            prReviewStatus: cleanText((_b = prReviewGate === null || prReviewGate === void 0 ? void 0 : prReviewGate.metadata) === null || _b === void 0 ? void 0 : _b.status, 120),
+            prReviewStrictGatePassed: ((_c = prReviewGate === null || prReviewGate === void 0 ? void 0 : prReviewGate.metadata) === null || _c === void 0 ? void 0 : _c.strictGatePassed) === true,
+            prReviewStrictGateReason: cleanText((_d = prReviewGate === null || prReviewGate === void 0 ? void 0 : prReviewGate.metadata) === null || _d === void 0 ? void 0 : _d.strictGateReason, 500),
+            prReviewExecutionGrade: cleanText((_e = prReviewGate === null || prReviewGate === void 0 ? void 0 : prReviewGate.metadata) === null || _e === void 0 ? void 0 : _e.executionGrade, 20),
+            prReviewArtifactsGrade: cleanText((_f = prReviewGate === null || prReviewGate === void 0 ? void 0 : prReviewGate.metadata) === null || _f === void 0 ? void 0 : _f.artifactsGrade, 20),
+            prReviewPullRequestGrade: cleanText((_g = prReviewGate === null || prReviewGate === void 0 ? void 0 : prReviewGate.metadata) === null || _g === void 0 ? void 0 : _g.pullRequestGrade, 20),
+            qaScreenshotsRequired: approval.qa_screenshots_required === true || approval.qaScreenshotsRequired === true,
+            beforeActionAfterBusinessProofRequired: approval.before_action_after_business_proof_required === true || approval.beforeActionAfterBusinessProofRequired === true,
+            aiqaBusinessAssertionRequired: approval.aiqa_business_assertion_required === true || approval.aiqaBusinessAssertionRequired === true,
+            hasScreenshotOrTrace: supportArtifactListHasScreenshotOrTrace(businessProofArtifacts),
+            businessProofArtifacts: businessProofArtifacts,
+            modifiedFiles: modifiedFiles,
+            requiredCompletionEvidence: requiredCompletionEvidence,
+            missingCompletionEvidence: missing,
+            forbiddenActions: cleanStringList(completionContract.forbidden_actions || completionContract.forbiddenActions, 30, 500),
+            mergeBlockedUntilHumanApproval: prReadinessContract.merge_blocked_until_human_approval === true || prReadinessContract.mergeBlockedUntilHumanApproval === true,
+            customerReplyBlockedUntilReleaseGate: prReadinessContract.customer_reply_blocked_until_release_gate === true || prReadinessContract.customerReplyBlockedUntilReleaseGate === true,
+            releaseBlockedUntilPrReview: prReadinessContract.release_blocked_until_pr_review === true || prReadinessContract.releaseBlockedUntilPrReview === true
+        }
+    };
+}
 function supportNextActionContractObject(ticket, job, evidence) {
     var ticketAutomation = plainObject(ticket.automation);
     var ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
@@ -2129,7 +3824,7 @@ function supportNextActionContractRequired(ticket, job, evidence) {
         || !!ticketManager.last_watchdog_decision;
 }
 function supportNextActionContractMetadata(contract) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2;
     var decisionBasis = plainObject(contract.decisionBasis || contract.decision_basis);
     var costRisk = plainObject(contract.costRisk || contract.cost_risk);
     var source = {
@@ -2158,91 +3853,333 @@ function supportNextActionContractMetadata(contract) {
             estimatedUsd: numberValue((_h = (_g = (_f = costRisk.estimatedUsd) !== null && _f !== void 0 ? _f : costRisk.estimated_usd) !== null && _g !== void 0 ? _g : contract.estimatedUsd) !== null && _h !== void 0 ? _h : contract.estimated_usd),
             reason: cleanText(costRisk.reason, 800)
         },
-        diagnosisValid: booleanFlag((_j = decisionBasis.diagnosisValid) !== null && _j !== void 0 ? _j : decisionBasis.diagnosis_valid),
-        ownerFilesReady: booleanFlag((_k = decisionBasis.ownerFilesReady) !== null && _k !== void 0 ? _k : decisionBasis.owner_files_ready),
-        proofPlanReady: booleanFlag((_l = decisionBasis.proofPlanReady) !== null && _l !== void 0 ? _l : decisionBasis.proof_plan_ready),
-        businessProofReady: booleanFlag((_m = decisionBasis.businessProofReady) !== null && _m !== void 0 ? _m : decisionBasis.business_proof_ready),
-        evidenceFreshnessStatus: cleanText(decisionBasis.evidenceFreshnessStatus || decisionBasis.evidence_freshness_status, 120),
-        evidenceStrength: cleanText(decisionBasis.evidenceStrength || decisionBasis.evidence_strength, 120),
-        failureClass: cleanText(decisionBasis.failureClass || decisionBasis.failure_class, 120),
-        blockerFingerprint: cleanText(decisionBasis.blockerFingerprint || decisionBasis.blocker_fingerprint, 200),
-        evidenceHash: cleanText(decisionBasis.evidenceHash || decisionBasis.evidence_hash, 200),
-        sameFailureCount: numberValue((_o = decisionBasis.sameFailureCount) !== null && _o !== void 0 ? _o : decisionBasis.same_failure_count),
-        preflightReady: booleanFlag((_p = decisionBasis.preflightReady) !== null && _p !== void 0 ? _p : decisionBasis.preflight_ready),
-        preflightStatus: cleanText(decisionBasis.preflightStatus || decisionBasis.preflight_status, 120),
-        preflightFailureClass: cleanText(decisionBasis.preflightFailureClass || decisionBasis.preflight_failure_class, 120),
-        preflightEvidenceHash: cleanText(decisionBasis.preflightEvidenceHash || decisionBasis.preflight_evidence_hash, 200),
-        hotfixCommitRequired: booleanFlag((_s = (_r = (_q = decisionBasis.hotfixCommitRequired) !== null && _q !== void 0 ? _q : decisionBasis.hotfix_commit_required) !== null && _r !== void 0 ? _r : contract.hotfixCommitRequired) !== null && _s !== void 0 ? _s : contract.hotfix_commit_required),
-        liveHotfixBlockedUntilCommit: booleanFlag((_v = (_u = (_t = decisionBasis.liveHotfixBlockedUntilCommit) !== null && _t !== void 0 ? _t : decisionBasis.live_hotfix_blocked_until_commit) !== null && _u !== void 0 ? _u : contract.liveHotfixBlockedUntilCommit) !== null && _v !== void 0 ? _v : contract.live_hotfix_blocked_until_commit)
+        diagnosisValid: booleanFlag((_j = decisionBasis.diagnosisValid) !== null && _j !== void 0 ? _j : decisionBasis.diagnosis_valid),
+        ownerFilesReady: booleanFlag((_k = decisionBasis.ownerFilesReady) !== null && _k !== void 0 ? _k : decisionBasis.owner_files_ready),
+        proofPlanReady: booleanFlag((_l = decisionBasis.proofPlanReady) !== null && _l !== void 0 ? _l : decisionBasis.proof_plan_ready),
+        proofMatrixReady: booleanFlag((_m = decisionBasis.proofMatrixReady) !== null && _m !== void 0 ? _m : decisionBasis.proof_matrix_ready),
+        proofMatrixId: cleanText(decisionBasis.proofMatrixId || decisionBasis.proof_matrix_id, 200),
+        ownerScopedRepairContractReady: booleanFlag((_o = decisionBasis.ownerScopedRepairContractReady) !== null && _o !== void 0 ? _o : decisionBasis.owner_scoped_repair_contract_ready),
+        ownerScopedRepairContractId: cleanText(decisionBasis.ownerScopedRepairContractId || decisionBasis.owner_scoped_repair_contract_id, 200),
+        businessProofReady: booleanFlag((_p = decisionBasis.businessProofReady) !== null && _p !== void 0 ? _p : decisionBasis.business_proof_ready),
+        evidenceFreshnessStatus: cleanText(decisionBasis.evidenceFreshnessStatus || decisionBasis.evidence_freshness_status, 120),
+        evidenceStrength: cleanText(decisionBasis.evidenceStrength || decisionBasis.evidence_strength, 120),
+        failureClass: cleanText(decisionBasis.failureClass || decisionBasis.failure_class, 120),
+        blockerFingerprint: cleanText(decisionBasis.blockerFingerprint || decisionBasis.blocker_fingerprint, 200),
+        evidenceHash: cleanText(decisionBasis.evidenceHash || decisionBasis.evidence_hash, 200),
+        sameFailureCount: numberValue((_q = decisionBasis.sameFailureCount) !== null && _q !== void 0 ? _q : decisionBasis.same_failure_count),
+        preflightReady: booleanFlag((_r = decisionBasis.preflightReady) !== null && _r !== void 0 ? _r : decisionBasis.preflight_ready),
+        preflightStatus: cleanText(decisionBasis.preflightStatus || decisionBasis.preflight_status, 120),
+        preflightFailureClass: cleanText(decisionBasis.preflightFailureClass || decisionBasis.preflight_failure_class, 120),
+        preflightEvidenceHash: cleanText(decisionBasis.preflightEvidenceHash || decisionBasis.preflight_evidence_hash, 200),
+        hotfixCommitRequired: booleanFlag((_u = (_t = (_s = decisionBasis.hotfixCommitRequired) !== null && _s !== void 0 ? _s : decisionBasis.hotfix_commit_required) !== null && _t !== void 0 ? _t : contract.hotfixCommitRequired) !== null && _u !== void 0 ? _u : contract.hotfix_commit_required),
+        liveHotfixBlockedUntilCommit: booleanFlag((_x = (_w = (_v = decisionBasis.liveHotfixBlockedUntilCommit) !== null && _v !== void 0 ? _v : decisionBasis.live_hotfix_blocked_until_commit) !== null && _w !== void 0 ? _w : contract.liveHotfixBlockedUntilCommit) !== null && _x !== void 0 ? _x : contract.live_hotfix_blocked_until_commit),
+        evidenceProbeContractReady: booleanFlag((_y = decisionBasis.evidenceProbeContractReady) !== null && _y !== void 0 ? _y : decisionBasis.evidence_probe_contract_ready),
+        evidenceProbeContractId: cleanText(decisionBasis.evidenceProbeContractId || decisionBasis.evidence_probe_contract_id, 200),
+        autonomyMode: cleanText(decisionBasis.autonomyMode || decisionBasis.autonomy_mode, 120),
+        autonomyCanAutoDispatch: booleanFlag((_z = decisionBasis.autonomyCanAutoDispatch) !== null && _z !== void 0 ? _z : decisionBasis.autonomy_can_auto_dispatch),
+        autonomyReason: cleanText(decisionBasis.autonomyReason || decisionBasis.autonomy_reason, 1000),
+        autonomyExpectedValueScore: numberValue((_0 = decisionBasis.autonomyExpectedValueScore) !== null && _0 !== void 0 ? _0 : decisionBasis.autonomy_expected_value_score),
+        autonomyExpectedValuePositive: booleanFlag((_1 = decisionBasis.autonomyExpectedValuePositive) !== null && _1 !== void 0 ? _1 : decisionBasis.autonomy_expected_value_positive),
+        autonomyProjectedSpendUsd: numberValue((_2 = decisionBasis.autonomyProjectedSpendUsd) !== null && _2 !== void 0 ? _2 : decisionBasis.autonomy_projected_spend_usd)
+    };
+    return source;
+}
+function supportNextActionContractGate(contract, now, required) {
+    if (required === void 0) { required = false; }
+    if (!contract || !Object.keys(contract).length) {
+        if (!required) {
+            return undefined;
+        }
+        var blocker = 'Support V5 run is missing a validated next-action contract, so the manager cannot prove one safe primary action without external Codex monitoring.';
+        return {
+            key: 'support_next_action_contract',
+            label: 'Support next-action contract',
+            status: 'blocked',
+            reason: blocker,
+            evidenceRefs: [],
+            recordedAt: isoNow(now),
+            metadata: {
+                required: true,
+                missingContract: true,
+                safeToAutoRun: false,
+                canRunWithoutCodexMonitor: false,
+                codexFallbackRequired: true,
+                codexFallbackReason: 'missing_support_next_action_contract',
+                blockers: [blocker],
+                missingSafetyFlags: ['safeToAutoRun', 'canRunWithoutCodexMonitor', 'codexFallbackRequired']
+            }
+        };
+    }
+    var metadata = supportNextActionContractMetadata(contract);
+    var blockers = cleanStringList(metadata.blockers, 40, 500);
+    if (metadata.safeToAutoRun === false) {
+        blockers.push('Next action contract marks the action unsafe for autonomous run.');
+    }
+    if (metadata.canRunWithoutCodexMonitor === false) {
+        blockers.push('Next action requires Codex fallback/monitoring instead of manager-only execution.');
+    }
+    if (metadata.codexFallbackRequired === true) {
+        blockers.push(metadata.codexFallbackReason || 'Next action contract requires Codex fallback.');
+    }
+    if (metadata.requiresHumanApproval === true) {
+        blockers.push('Next action contract requires human approval.');
+    }
+    if (metadata.liveHotfixBlockedUntilCommit === true) {
+        blockers.push('Live hotfix is blocked until the manager records and pushes the GitHub commit proof.');
+    }
+    var missingSafetyFlags = [
+        metadata.safeToAutoRun === undefined ? 'safeToAutoRun' : '',
+        metadata.canRunWithoutCodexMonitor === undefined ? 'canRunWithoutCodexMonitor' : '',
+        metadata.codexFallbackRequired === undefined ? 'codexFallbackRequired' : ''
+    ].filter(Boolean);
+    var status = blockers.length
+        ? 'blocked'
+        : missingSafetyFlags.length
+            ? 'warn'
+            : 'pass';
+    var actionLabel = metadata.label || metadata.action || metadata.primaryCommand || 'support next action';
+    return {
+        key: 'support_next_action_contract',
+        label: 'Support next-action contract',
+        status: status,
+        reason: blockers.length
+            ? blockers.join(' ')
+            : missingSafetyFlags.length
+                ? "Support next-action contract is present for ".concat(actionLabel, ", but missing explicit safety flags: ").concat(missingSafetyFlags.join(', '), ".")
+                : "Support next-action contract allows ".concat(actionLabel, " without Codex monitoring."),
+        evidenceRefs: cleanStringList(__spreadArray(__spreadArray(__spreadArray([], __read(metadata.successEvidence), false), __read(metadata.preconditions), false), __read(metadata.stopConditions), false), 40, 500),
+        recordedAt: isoNow(now || contract.createdAt || contract.created_at || contract.recordedAt || contract.recorded_at),
+        metadata: __assign(__assign({}, metadata), { blockers: blockers, missingSafetyFlags: missingSafetyFlags })
+    };
+}
+function supportEvidenceProbeContractObject(ticket, job, evidence) {
+    var ticketAutomation = plainObject(ticket.automation);
+    var ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
+    var autonomousDecision = plainObject(job.supportV5AutonomousDecision
+        || job.support_v5_autonomous_decision
+        || evidence.supportV5AutonomousDecision
+        || evidence.support_v5_autonomous_decision
+        || ticket.supportV5AutonomousDecision
+        || ticket.support_v5_autonomous_decision);
+    return evidenceObject(autonomousDecision.evidenceProbeContract, autonomousDecision.evidence_probe_contract, job.supportV5EvidenceProbeContract, job.support_v5_evidence_probe_contract, job.evidenceProbeContract, job.evidence_probe_contract, evidence.supportV5EvidenceProbeContract, evidence.support_v5_evidence_probe_contract, evidence.evidenceProbeContract, evidence.evidence_probe_contract, ticket.supportV5EvidenceProbeContract, ticket.support_v5_evidence_probe_contract, ticket.evidenceProbeContract, ticket.evidence_probe_contract, ticketManager.evidenceProbeContract, ticketManager.evidence_probe_contract);
+}
+function supportEvidenceProbeContractMetadata(contract) {
+    var _a, _b, _c, _d;
+    var validation = (0, support_runner_v5_1.validateResolveIOSupportEvidenceProbeContract)(contract);
+    var normalized = plainObject(validation.normalized);
+    return {
+        contractId: cleanText(normalized.contractId || contract.contractId || contract.contract_id, 200),
+        status: cleanText(normalized.status || contract.status, 120),
+        probeType: cleanText(normalized.probeType || contract.probeType || contract.probe_type, 120),
+        evidenceOnly: normalized.evidenceOnly === true || contract.evidenceOnly === true || contract.evidence_only === true,
+        productRepairAllowed: normalized.productRepairAllowed === true || contract.productRepairAllowed === true || contract.product_repair_allowed === true,
+        canRunWithoutCodexMonitor: normalized.canRunWithoutCodexMonitor === true || contract.canRunWithoutCodexMonitor === true || contract.can_run_without_codex_monitor === true,
+        issueClass: cleanText(normalized.issueClass || contract.issueClass || contract.issue_class, 120),
+        planId: cleanText(normalized.planId || contract.planId || contract.plan_id, 200),
+        activeRoute: cleanText(normalized.activeRoute || contract.activeRoute || contract.active_route, 500),
+        actionUnderTest: cleanText(normalized.actionUnderTest || contract.actionUnderTest || contract.action_under_test, 1000),
+        expectedBusinessProof: cleanText(normalized.expectedBusinessProof || contract.expectedBusinessProof || contract.expected_business_proof, 1400),
+        startingFailureClass: cleanText(normalized.startingFailureClass || contract.startingFailureClass || contract.starting_failure_class, 120),
+        startingBlockerFingerprint: cleanText(normalized.startingBlockerFingerprint || contract.startingBlockerFingerprint || contract.starting_blocker_fingerprint, 200),
+        startingEvidenceHash: cleanText(normalized.startingEvidenceHash || contract.startingEvidenceHash || contract.starting_evidence_hash, 200),
+        sameFailureCount: numberValue((_b = (_a = normalized.sameFailureCount) !== null && _a !== void 0 ? _a : contract.sameFailureCount) !== null && _b !== void 0 ? _b : contract.same_failure_count),
+        pingPongCount: numberValue((_d = (_c = normalized.pingPongCount) !== null && _c !== void 0 ? _c : contract.pingPongCount) !== null && _d !== void 0 ? _d : contract.ping_pong_count),
+        requiredNewSignals: cleanStringList(normalized.requiredNewSignals || contract.requiredNewSignals || contract.required_new_signals, 30, 500),
+        requiredArtifacts: cleanStringList(normalized.requiredArtifacts || contract.requiredArtifacts || contract.required_artifacts, 30, 500),
+        acceptableEvidence: cleanStringList(normalized.acceptableEvidence || contract.acceptableEvidence || contract.acceptable_evidence, 30, 500),
+        nextCommands: cleanStringList(normalized.nextCommands || contract.nextCommands || contract.next_commands, 20, 300),
+        forbiddenActions: cleanStringList(normalized.forbiddenActions || contract.forbiddenActions || contract.forbidden_actions, 20, 500),
+        blockers: validation.blockers,
+        validationValid: validation.valid,
+        validationStatus: validation.status
+    };
+}
+function supportEvidenceProbeContractGate(contract, now, required) {
+    if (required === void 0) { required = false; }
+    if (!contract || !Object.keys(contract).length) {
+        if (!required) {
+            return undefined;
+        }
+        var blocker = 'Support repeated-failure recovery is missing an evidence probe contract, so the manager cannot prove bounded evidence-only recovery.';
+        return {
+            key: 'support_evidence_probe_contract',
+            label: 'Support evidence probe contract',
+            status: 'blocked',
+            reason: blocker,
+            evidenceRefs: [],
+            recordedAt: isoNow(now),
+            metadata: {
+                required: true,
+                missingContract: true,
+                evidenceOnly: false,
+                productRepairAllowed: false,
+                canRunWithoutCodexMonitor: false,
+                blockers: [blocker]
+            }
+        };
+    }
+    var metadata = supportEvidenceProbeContractMetadata(contract);
+    var blockers = cleanStringList(metadata.blockers, 40, 500);
+    if (metadata.evidenceOnly !== true) {
+        blockers.push('Evidence probe contract must be evidence-only.');
+    }
+    if (metadata.productRepairAllowed === true) {
+        blockers.push('Evidence probe contract must not allow product repair.');
+    }
+    if (metadata.canRunWithoutCodexMonitor !== true) {
+        blockers.push('Evidence probe contract is not ready for manager-only execution.');
+    }
+    var status = blockers.length ? 'blocked' : 'pass';
+    return {
+        key: 'support_evidence_probe_contract',
+        label: 'Support evidence probe contract',
+        status: status,
+        reason: blockers.length
+            ? blockers.join(' ')
+            : "Support evidence probe contract allows bounded ".concat(metadata.probeType || 'evidence', " collection without product-code repair."),
+        evidenceRefs: cleanStringList(__spreadArray(__spreadArray(__spreadArray([], __read(metadata.requiredNewSignals), false), __read(metadata.requiredArtifacts), false), __read(metadata.acceptableEvidence), false), 40, 500),
+        recordedAt: isoNow(now || contract.createdAt || contract.created_at || contract.recordedAt || contract.recorded_at),
+        metadata: __assign(__assign({}, metadata), { blockers: blockers })
+    };
+}
+function supportManagerExecutionPacketObject(ticket, job, evidence, nextActionContract) {
+    var ticketAutomation = plainObject(ticket.automation);
+    var ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
+    var autonomousDecision = plainObject(job.supportV5AutonomousDecision
+        || job.support_v5_autonomous_decision
+        || evidence.supportV5AutonomousDecision
+        || evidence.support_v5_autonomous_decision
+        || ticket.supportV5AutonomousDecision
+        || ticket.support_v5_autonomous_decision);
+    var explicitPacket = evidenceObject(autonomousDecision.managerExecutionPacket, autonomousDecision.manager_execution_packet, job.supportV5ManagerExecutionPacket, job.support_v5_manager_execution_packet, job.managerExecutionPacket, job.manager_execution_packet, evidence.supportV5ManagerExecutionPacket, evidence.support_v5_manager_execution_packet, evidence.managerExecutionPacket, evidence.manager_execution_packet, ticket.supportV5ManagerExecutionPacket, ticket.support_v5_manager_execution_packet, ticket.managerExecutionPacket, ticket.manager_execution_packet, ticketManager.managerExecutionPacket, ticketManager.manager_execution_packet);
+    if (Object.keys(explicitPacket).length) {
+        return explicitPacket;
+    }
+    if (nextActionContract && Object.keys(nextActionContract).length) {
+        try {
+            return (0, support_runner_v5_1.buildResolveIOSupportManagerExecutionPacket)(nextActionContract);
+        }
+        catch (_a) {
+            return {};
+        }
+    }
+    return {};
+}
+function supportManagerExecutionPacketMetadata(packet) {
+    var _a, _b, _c, _d, _e, _f;
+    var validation = plainObject(packet.validation);
+    var validationBlockers = cleanStringList(validation.blockers, 40, 500);
+    var directBlockers = cleanStringList(packet.blockers, 40, 500);
+    var proofReset = plainObject(packet.proofResetContract || packet.proof_reset_contract);
+    return {
+        packetId: cleanText(packet.packetId || packet.packet_id, 200),
+        status: cleanText(packet.status, 120),
+        action: cleanText(packet.action, 160),
+        label: cleanText(packet.label, 300),
+        primaryCommand: cleanText(packet.primaryCommand || packet.primary_command, 240),
+        lane: cleanText(packet.lane, 120),
+        stepType: cleanText(packet.stepType || packet.step_type, 120),
+        executeNow: booleanFlag((_a = packet.executeNow) !== null && _a !== void 0 ? _a : packet.execute_now),
+        canRunWithoutCodexMonitor: booleanFlag((_b = packet.canRunWithoutCodexMonitor) !== null && _b !== void 0 ? _b : packet.can_run_without_codex_monitor),
+        codexFallbackRequired: booleanFlag((_c = packet.codexFallbackRequired) !== null && _c !== void 0 ? _c : packet.codex_fallback_required),
+        retryScope: cleanText(packet.retryScope || packet.retry_scope, 120),
+        maxAttemptsBeforeFreshEvidence: numberValue((_d = packet.maxAttemptsBeforeFreshEvidence) !== null && _d !== void 0 ? _d : packet.max_attempts_before_fresh_evidence),
+        costRisk: cleanText(packet.costRisk || packet.cost_risk, 120),
+        proofRequiredBeforeContinuation: cleanStringList(packet.proofRequiredBeforeContinuation || packet.proof_required_before_continuation, 40, 500),
+        expectedStateTransition: cleanText(packet.expectedStateTransition || packet.expected_state_transition, 1000),
+        stopConditions: cleanStringList(packet.stopConditions || packet.stop_conditions, 40, 500),
+        forbiddenActions: cleanStringList(packet.forbiddenActions || packet.forbidden_actions, 40, 500),
+        ownerFiles: cleanStringList(packet.ownerFiles || packet.owner_files, 40, 500),
+        nextCommands: cleanStringList(packet.nextCommands || packet.next_commands, 40, 500),
+        proofResetContract: Object.keys(proofReset).length ? {
+            contractId: cleanText(proofReset.contractId || proofReset.contract_id, 200),
+            status: cleanText(proofReset.status, 120),
+            action: cleanText(proofReset.action, 160),
+            retryScope: cleanText(proofReset.retryScope || proofReset.retry_scope, 120),
+            maxAttemptsBeforeFreshEvidence: numberValue((_e = proofReset.maxAttemptsBeforeFreshEvidence) !== null && _e !== void 0 ? _e : proofReset.max_attempts_before_fresh_evidence),
+            startingFailureClass: cleanText(proofReset.startingFailureClass || proofReset.starting_failure_class, 120),
+            startingBlockerFingerprint: cleanText(proofReset.startingBlockerFingerprint || proofReset.starting_blocker_fingerprint, 200),
+            startingEvidenceHash: cleanText(proofReset.startingEvidenceHash || proofReset.starting_evidence_hash, 200),
+            requiredResetEvidence: cleanStringList(proofReset.requiredResetEvidence || proofReset.required_reset_evidence, 40, 500),
+            proofRequiredBeforeContinuation: cleanStringList(proofReset.proofRequiredBeforeContinuation || proofReset.proof_required_before_continuation, 40, 500),
+            stopConditions: cleanStringList(proofReset.stopConditions || proofReset.stop_conditions, 40, 500),
+            canRunWithoutCodexMonitor: booleanFlag((_f = proofReset.canRunWithoutCodexMonitor) !== null && _f !== void 0 ? _f : proofReset.can_run_without_codex_monitor),
+            sourceNextActionContractId: cleanText(proofReset.sourceNextActionContractId || proofReset.source_next_action_contract_id, 200),
+            createdAt: cleanText(proofReset.createdAt || proofReset.created_at, 120)
+        } : undefined,
+        blockers: Array.from(new Set(__spreadArray(__spreadArray([], __read(directBlockers), false), __read(validationBlockers), false))).slice(0, 40),
+        validation: {
+            valid: booleanFlag(validation.valid),
+            status: cleanText(validation.status, 120),
+            blockers: validationBlockers,
+            warnings: cleanStringList(validation.warnings, 40, 500)
+        },
+        createdAt: cleanText(packet.createdAt || packet.created_at, 120)
     };
-    return source;
 }
-function supportNextActionContractGate(contract, now, required) {
+function supportManagerExecutionPacketGate(packet, now, required) {
     if (required === void 0) { required = false; }
-    if (!contract || !Object.keys(contract).length) {
+    if (!packet || !Object.keys(packet).length) {
         if (!required) {
             return undefined;
         }
-        var blocker = 'Support V5 run is missing a validated next-action contract, so the manager cannot prove one safe primary action without external Codex monitoring.';
+        var blocker = 'Support V5 run is missing a manager execution packet, so the console cannot prove the next action can execute without side Codex monitoring.';
         return {
-            key: 'support_next_action_contract',
-            label: 'Support next-action contract',
+            key: 'support_manager_execution_packet',
+            label: 'Support manager execution packet',
             status: 'blocked',
             reason: blocker,
             evidenceRefs: [],
             recordedAt: isoNow(now),
             metadata: {
                 required: true,
-                missingContract: true,
-                safeToAutoRun: false,
+                missingPacket: true,
+                executeNow: false,
                 canRunWithoutCodexMonitor: false,
                 codexFallbackRequired: true,
-                codexFallbackReason: 'missing_support_next_action_contract',
                 blockers: [blocker],
-                missingSafetyFlags: ['safeToAutoRun', 'canRunWithoutCodexMonitor', 'codexFallbackRequired']
+                validation: {
+                    valid: false,
+                    status: 'blocked',
+                    blockers: [blocker],
+                    warnings: []
+                }
             }
         };
     }
-    var metadata = supportNextActionContractMetadata(contract);
+    var metadata = supportManagerExecutionPacketMetadata(packet);
     var blockers = cleanStringList(metadata.blockers, 40, 500);
-    if (metadata.safeToAutoRun === false) {
-        blockers.push('Next action contract marks the action unsafe for autonomous run.');
-    }
-    if (metadata.canRunWithoutCodexMonitor === false) {
-        blockers.push('Next action requires Codex fallback/monitoring instead of manager-only execution.');
+    if (metadata.validation.valid !== true) {
+        blockers.push('Manager execution packet is missing validated next-action contract proof.');
     }
     if (metadata.codexFallbackRequired === true) {
-        blockers.push(metadata.codexFallbackReason || 'Next action contract requires Codex fallback.');
-    }
-    if (metadata.requiresHumanApproval === true) {
-        blockers.push('Next action contract requires human approval.');
+        blockers.push('Manager execution packet still requires Codex fallback.');
     }
-    if (metadata.liveHotfixBlockedUntilCommit === true) {
-        blockers.push('Live hotfix is blocked until the manager records and pushes the GitHub commit proof.');
+    if (metadata.canRunWithoutCodexMonitor === false) {
+        blockers.push('Manager execution packet does not prove Codex-monitor independence.');
     }
-    var missingSafetyFlags = [
-        metadata.safeToAutoRun === undefined ? 'safeToAutoRun' : '',
-        metadata.canRunWithoutCodexMonitor === undefined ? 'canRunWithoutCodexMonitor' : '',
-        metadata.codexFallbackRequired === undefined ? 'codexFallbackRequired' : ''
-    ].filter(Boolean);
     var status = blockers.length
         ? 'blocked'
-        : missingSafetyFlags.length
-            ? 'warn'
-            : 'pass';
-    var actionLabel = metadata.label || metadata.action || metadata.primaryCommand || 'support next action';
+        : metadata.status === 'auto_ready' && metadata.executeNow === true
+            ? 'pass'
+            : metadata.status === 'manual_required'
+                ? 'warn'
+                : 'blocked';
+    var actionLabel = metadata.label || metadata.action || metadata.primaryCommand || 'support manager action';
     return {
-        key: 'support_next_action_contract',
-        label: 'Support next-action contract',
+        key: 'support_manager_execution_packet',
+        label: 'Support manager execution packet',
         status: status,
-        reason: blockers.length
-            ? blockers.join(' ')
-            : missingSafetyFlags.length
-                ? "Support next-action contract is present for ".concat(actionLabel, ", but missing explicit safety flags: ").concat(missingSafetyFlags.join(', '), ".")
-                : "Support next-action contract allows ".concat(actionLabel, " without Codex monitoring."),
-        evidenceRefs: cleanStringList(__spreadArray(__spreadArray(__spreadArray([], __read(metadata.successEvidence), false), __read(metadata.preconditions), false), __read(metadata.stopConditions), false), 40, 500),
-        recordedAt: isoNow(now || contract.createdAt || contract.created_at || contract.recordedAt || contract.recorded_at),
-        metadata: __assign(__assign({}, metadata), { blockers: blockers, missingSafetyFlags: missingSafetyFlags })
+        reason: status === 'pass'
+            ? "Support manager execution packet allows ".concat(actionLabel, " without side Codex monitoring.")
+            : status === 'warn'
+                ? "Support manager execution packet for ".concat(actionLabel, " requires a human decision before execution.")
+                : (blockers.join(' ') || "Support manager execution packet for ".concat(actionLabel, " is not auto-ready.")),
+        evidenceRefs: cleanStringList(__spreadArray(__spreadArray(__spreadArray([], __read(metadata.proofRequiredBeforeContinuation), false), [
+            metadata.expectedStateTransition
+        ], false), __read(metadata.stopConditions), false), 40, 500),
+        recordedAt: isoNow(now || metadata.createdAt),
+        metadata: __assign(__assign({}, metadata), { blockers: blockers })
     };
 }
 function supportDiagnosisEvidencePackObject(ticket, job, evidence) {
@@ -2266,6 +4203,59 @@ function supportSimilarFixHintsObject(ticket, job, evidence) {
     var ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
     return evidenceObject(job.supportRootCauseSimilarFixHints, job.support_root_cause_similar_fix_hints, job.similarFixHints, job.similar_fix_hints, evidence.supportRootCauseSimilarFixHints, evidence.support_root_cause_similar_fix_hints, evidence.similarFixHints, evidence.similar_fix_hints, ticket.supportRootCauseSimilarFixHints, ticket.support_root_cause_similar_fix_hints, ticketManager.rootCauseSimilarFixHints, ticketManager.root_cause_similar_fix_hints);
 }
+function supportSimilarFixHintContractObject(ticket, job, evidence) {
+    var ticketAutomation = plainObject(ticket.automation);
+    var ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
+    return evidenceObject(job.supportRootCauseSimilarFixHintContract, job.support_root_cause_similar_fix_hint_contract, job.similarFixHintContract, job.similar_fix_hint_contract, evidence.supportRootCauseSimilarFixHintContract, evidence.support_root_cause_similar_fix_hint_contract, evidence.similarFixHintContract, evidence.similar_fix_hint_contract, ticket.supportRootCauseSimilarFixHintContract, ticket.support_root_cause_similar_fix_hint_contract, ticketManager.rootCauseSimilarFixHintContract, ticketManager.root_cause_similar_fix_hint_contract);
+}
+function supportSimilarFixHintContractGate(contract, now) {
+    var _a, _b, _c;
+    if (!contract || !Object.keys(contract).length) {
+        return undefined;
+    }
+    var usagePolicy = plainObject(contract.usage_policy || contract.usagePolicy);
+    var rankedHints = asArray(contract.ranked_hints || contract.rankedHints);
+    var ownerFileHints = cleanStringList(contract.owner_file_hints || contract.ownerFileHints, 30, 500);
+    var similarHintsAreNotProof = usagePolicy.similar_hints_are_not_proof === true || usagePolicy.similarHintsAreNotProof === true;
+    var ownerFilesRequireCurrentEvidence = usagePolicy.owner_files_require_current_ticket_evidence === true
+        || usagePolicy.ownerFilesRequireCurrentTicketEvidence === true;
+    var acceptedHypothesisCurrent = usagePolicy.accepted_hypothesis_must_be_current_ticket_specific === true
+        || usagePolicy.acceptedHypothesisMustBeCurrentTicketSpecific === true;
+    var requiredModelActions = cleanStringList(contract.required_model_actions || contract.requiredModelActions, 20, 500);
+    var blockers = [
+        !similarHintsAreNotProof ? 'Similar-fix hints must be advisory only and cannot be proof.' : '',
+        !ownerFilesRequireCurrentEvidence ? 'Owner-file hints from similar fixes require current-ticket evidence before use.' : '',
+        !acceptedHypothesisCurrent ? 'Accepted hypothesis must remain current-ticket specific.' : '',
+        !requiredModelActions.length ? 'Similar-fix hint contract must include required model actions.' : ''
+    ].filter(Boolean);
+    var status = blockers.length ? 'warn' : 'pass';
+    return {
+        key: 'support_similar_fix_hint_contract',
+        label: 'Support similar-fix hint contract',
+        status: status,
+        reason: blockers.join('; ') || 'Similar accepted fixes are available as advisory hints only; fresh SupportDiagnosisGate evidence is still required.',
+        evidenceRefs: cleanStringList(__spreadArray(__spreadArray(__spreadArray([], __read(ownerFileHints), false), __read(rankedHints.flatMap(function (hint) { return cleanStringList((hint || {}).owner_files || (hint || {}).ownerFiles, 8, 500); })), false), __read(rankedHints.map(function (hint) { return (hint || {}).commit_sha || (hint || {}).commitSha; })), false), 60, 500),
+        recordedAt: isoNow(now || contract.created_at || contract.createdAt),
+        metadata: {
+            contractId: cleanText(contract.contract_id || contract.contractId, 200),
+            version: cleanText(contract.version, 120),
+            status: cleanText(contract.status, 120),
+            source: cleanText(contract.source, 160),
+            candidateCount: numberValue((_a = contract.candidate_count) !== null && _a !== void 0 ? _a : contract.candidateCount),
+            hintCount: numberValue((_c = (_b = contract.hint_count) !== null && _b !== void 0 ? _b : contract.hintCount) !== null && _c !== void 0 ? _c : rankedHints.length),
+            rankedHintCount: rankedHints.length,
+            ownerFileHints: ownerFileHints,
+            similarHintsAreNotProof: similarHintsAreNotProof,
+            ownerFilesRequireCurrentEvidence: ownerFilesRequireCurrentEvidence,
+            acceptedHypothesisCurrent: acceptedHypothesisCurrent,
+            mustRecordRejectedHintsOrAlternatives: usagePolicy.must_record_rejected_hints_or_alternatives === true
+                || usagePolicy.mustRecordRejectedHintsOrAlternatives === true,
+            advisoryOnly: similarHintsAreNotProof && ownerFilesRequireCurrentEvidence && acceptedHypothesisCurrent,
+            requiredModelActions: requiredModelActions,
+            blockers: blockers
+        }
+    };
+}
 function supportDiagnosisEvidencePackGate(pack, now) {
     if (!pack || !Object.keys(pack).length) {
         return undefined;
@@ -2309,6 +4299,132 @@ function supportDiagnosisEvidencePackGate(pack, now) {
         }
     };
 }
+function supportDiagnosisProofMatrixGate(matrixSource, now, required) {
+    if (required === void 0) { required = false; }
+    if (!matrixSource || !Object.keys(matrixSource).length) {
+        if (!required) {
+            return undefined;
+        }
+        return {
+            key: 'support_diagnosis_proof_matrix',
+            label: 'Support diagnosis proof matrix',
+            status: 'blocked',
+            reason: 'Support diagnosis proof matrix is required before owner-scoped product repair.',
+            evidenceRefs: [],
+            recordedAt: isoNow(now),
+            metadata: {
+                status: 'missing',
+                blockers: ['Support diagnosis proof matrix is missing.']
+            }
+        };
+    }
+    var statusText = cleanText(matrixSource.status, 120);
+    var blockers = cleanStringList(matrixSource.blockers, 40, 500);
+    var ownerFileCoverage = asArray(matrixSource.ownerFileCoverage || matrixSource.owner_file_coverage);
+    var uncoveredOwnerFiles = ownerFileCoverage
+        .filter(function (entry) { return entry.covered !== true; })
+        .map(function (entry) { return cleanText(entry.ownerFile || entry.owner_file, 500); })
+        .filter(Boolean);
+    var reproductionEvidence = asArray(matrixSource.reproductionEvidence || matrixSource.reproduction_evidence);
+    var rootCauseEvidence = asArray(matrixSource.rootCauseEvidence || matrixSource.root_cause_evidence);
+    var businessProofArtifacts = cleanStringList(matrixSource.businessProofArtifacts || matrixSource.business_proof_artifacts, 30, 500);
+    var gateStatus = statusText === 'ready' && !blockers.length && !uncoveredOwnerFiles.length
+        ? 'pass'
+        : required
+            ? 'blocked'
+            : 'warn';
+    return {
+        key: 'support_diagnosis_proof_matrix',
+        label: 'Support diagnosis proof matrix',
+        status: gateStatus,
+        reason: gateStatus === 'pass'
+            ? 'Support diagnosis proof matrix ties reproduction, root-cause evidence, owner files, and business proof artifacts together.'
+            : (blockers.join('; ') || (uncoveredOwnerFiles.length ? "Owner files lack proof matrix coverage: ".concat(uncoveredOwnerFiles.join(', ')) : 'Support diagnosis proof matrix is incomplete.')),
+        evidenceRefs: cleanStringList(__spreadArray(__spreadArray(__spreadArray([], __read(reproductionEvidence.map(function (entry) { return entry.artifactPath || entry.artifact_path || entry.evidenceId || entry.evidence_id; })), false), __read(rootCauseEvidence.map(function (entry) { return entry.artifactPath || entry.artifact_path || entry.evidenceId || entry.evidence_id; })), false), __read(businessProofArtifacts), false), 60, 500),
+        recordedAt: isoNow(now || matrixSource.generatedAt || matrixSource.generated_at),
+        metadata: {
+            matrixId: cleanText(matrixSource.matrixId || matrixSource.matrix_id, 180),
+            status: statusText,
+            issueClass: cleanText(matrixSource.issueClass || matrixSource.issue_class, 120),
+            ownerFiles: cleanStringList(matrixSource.ownerFiles || matrixSource.owner_files, 40, 500),
+            ownerFileCoverage: ownerFileCoverage.map(function (entry) { return ({
+                ownerFile: cleanText(entry.ownerFile || entry.owner_file, 500),
+                covered: entry.covered === true,
+                evidenceIds: cleanStringList(entry.evidenceIds || entry.evidence_ids, 20, 180),
+                failingPathFields: cleanStringList(entry.failingPathFields || entry.failing_path_fields, 10, 120)
+            }); }),
+            uncoveredOwnerFiles: uncoveredOwnerFiles,
+            reproductionEvidenceCount: reproductionEvidence.length,
+            rootCauseEvidenceCount: rootCauseEvidence.length,
+            businessProofArtifacts: businessProofArtifacts,
+            blockers: blockers
+        }
+    };
+}
+function supportOwnerScopedRepairContractGate(contract, now, required) {
+    if (required === void 0) { required = false; }
+    if (!contract || !Object.keys(contract).length) {
+        if (!required) {
+            return undefined;
+        }
+        return {
+            key: 'support_owner_scoped_repair_contract',
+            label: 'Support owner-scoped repair contract',
+            status: 'blocked',
+            reason: 'Owner-scoped repair contract is required before product-code repair.',
+            evidenceRefs: [],
+            recordedAt: isoNow(now),
+            metadata: {
+                status: 'missing',
+                blockers: ['Support owner-scoped repair contract is missing.']
+            }
+        };
+    }
+    var statusText = cleanText(contract.status, 120);
+    var blockers = cleanStringList(contract.blockers, 40, 500);
+    var patchUnits = asArray(contract.patchUnits || contract.patch_units);
+    var outsideOwnerFiles = cleanStringList(contract.outsideOwnerFiles || contract.outside_owner_files, 40, 500);
+    var gateStatus = statusText === 'ready' && !blockers.length && !outsideOwnerFiles.length && contract.sourceEditsAllowed !== false
+        ? 'pass'
+        : required
+            ? 'blocked'
+            : 'warn';
+    var requiredEvidenceAfterRepair = cleanStringList(contract.requiredEvidenceAfterRepair || contract.required_evidence_after_repair, 30, 500);
+    return {
+        key: 'support_owner_scoped_repair_contract',
+        label: 'Support owner-scoped repair contract',
+        status: gateStatus,
+        reason: gateStatus === 'pass'
+            ? 'Owner-scoped repair contract allows product-code edits only inside diagnosed owner files and requires compile plus business proof handoff.'
+            : (blockers.join('; ') || (outsideOwnerFiles.length ? "Repair contract has out-of-scope files: ".concat(outsideOwnerFiles.join(', ')) : 'Owner-scoped repair contract is not ready.')),
+        evidenceRefs: cleanStringList(__spreadArray([
+            contract.proofMatrixId || contract.proof_matrix_id
+        ], __read(requiredEvidenceAfterRepair), false), 40, 500),
+        recordedAt: isoNow(now || contract.createdAt || contract.created_at),
+        metadata: {
+            contractId: cleanText(contract.contractId || contract.contract_id, 180),
+            status: statusText,
+            sourceEditsAllowed: contract.sourceEditsAllowed === true || contract.source_edits_allowed === true,
+            canRunWithoutCodexMonitor: contract.canRunWithoutCodexMonitor === true || contract.can_run_without_codex_monitor === true,
+            issueClass: cleanText(contract.issueClass || contract.issue_class, 120),
+            ownerFiles: cleanStringList(contract.ownerFiles || contract.owner_files, 40, 500),
+            proofMatrixId: cleanText(contract.proofMatrixId || contract.proof_matrix_id, 180),
+            changedFiles: cleanStringList(contract.changedFiles || contract.changed_files, 60, 500),
+            outsideOwnerFiles: outsideOwnerFiles,
+            patchUnitCount: patchUnits.length,
+            patchUnits: patchUnits.map(function (unit) { return ({
+                ownerFile: cleanText(unit.ownerFile || unit.owner_file, 500),
+                coverageEvidenceIds: cleanStringList(unit.coverageEvidenceIds || unit.coverage_evidence_ids, 20, 180),
+                failingPathFields: cleanStringList(unit.failingPathFields || unit.failing_path_fields, 10, 120)
+            }); }),
+            requiredEvidenceBeforeRepair: cleanStringList(contract.requiredEvidenceBeforeRepair || contract.required_evidence_before_repair, 30, 500),
+            requiredEvidenceAfterRepair: requiredEvidenceAfterRepair,
+            nextCommands: cleanStringList(contract.nextCommands || contract.next_commands, 20, 240),
+            forbiddenActions: cleanStringList(contract.forbiddenActions || contract.forbidden_actions, 20, 500),
+            blockers: blockers
+        }
+    };
+}
 function supportIssueClassProbePlanGate(plan, diagnosisGate, now, required) {
     if (required === void 0) { required = false; }
     if (!plan || !Object.keys(plan).length) {
@@ -3332,7 +5448,7 @@ function applyAssistantAnswerQualityGate(qa, decision, now) {
 }
 function buildSupportAIRunFromEvidence(input) {
     var e_32, _a, e_33, _b;
-    var _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72;
+    var _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, _73, _74, _75, _76, _77, _78, _79, _80, _81, _82, _83, _84, _85, _86, _87, _88, _89, _90, _91, _92, _93, _94, _95, _96, _97, _98, _99, _100, _101, _102, _103, _104, _105, _106, _107, _108, _109, _110, _111, _112, _113, _114, _115, _116, _117, _118, _119, _120, _121, _122, _123, _124, _125, _126, _127, _128, _129, _130, _131, _132, _133, _134, _135, _136, _137, _138, _139, _140, _141, _142, _143, _144, _145, _146, _147, _148, _149, _150, _151, _152, _153, _154, _155, _156, _157, _158, _159, _160, _161, _162, _163, _164, _165, _166, _167, _168, _169, _170, _171, _172, _173, _174, _175, _176, _177, _178, _179, _180, _181, _182, _183, _184, _185, _186, _187, _188, _189, _190, _191, _192, _193, _194, _195, _196, _197, _198, _199, _200, _201, _202, _203, _204, _205, _206, _207, _208, _209, _210, _211, _212, _213, _214, _215, _216, _217, _218, _219, _220, _221, _222, _223, _224, _225, _226, _227, _228, _229, _230, _231, _232, _233, _234, _235, _236, _237, _238, _239, _240, _241, _242, _243, _244, _245, _246, _247, _248, _249, _250, _251, _252, _253, _254, _255, _256, _257, _258, _259, _260, _261, _262, _263, _264, _265, _266, _267, _268, _269, _270, _271, _272, _273, _274, _275, _276, _277, _278, _279, _280, _281, _282, _283, _284, _285, _286, _287, _288, _289, _290, _291, _292, _293, _294, _295, _296, _297, _298, _299, _300, _301, _302, _303, _304, _305, _306, _307, _308, _309, _310, _311, _312, _313, _314, _315, _316, _317, _318, _319, _320, _321, _322, _323, _324, _325, _326, _327, _328, _329, _330, _331, _332, _333, _334, _335, _336, _337, _338, _339, _340, _341, _342, _343, _344, _345, _346, _347, _348, _349, _350, _351, _352, _353, _354, _355, _356, _357, _358, _359, _360, _361, _362, _363, _364, _365, _366, _367, _368, _369, _370, _371, _372, _373, _374, _375, _376, _377, _378, _379, _380, _381, _382, _383, _384, _385, _386, _387, _388, _389, _390, _391, _392, _393, _394, _395, _396, _397, _398, _399, _400, _401, _402, _403, _404, _405, _406, _407, _408, _409, _410, _411, _412, _413, _414, _415, _416, _417, _418, _419, _420, _421, _422, _423, _424, _425, _426, _427, _428, _429, _430, _431, _432, _433, _434, _435, _436, _437, _438, _439, _440, _441, _442, _443, _444, _445, _446, _447, _448, _449, _450, _451, _452, _453, _454, _455, _456, _457, _458, _459, _460, _461, _462, _463, _464, _465, _466, _467, _468, _469, _470, _471, _472, _473, _474, _475, _476, _477, _478, _479, _480, _481, _482, _483, _484, _485, _486, _487, _488, _489, _490, _491, _492, _493, _494, _495, _496, _497, _498, _499, _500, _501, _502, _503, _504, _505, _506, _507, _508, _509, _510, _511, _512, _513, _514, _515, _516, _517, _518, _519, _520, _521, _522, _523, _524, _525, _526, _527, _528, _529, _530, _531, _532, _533, _534, _535, _536, _537, _538, _539, _540;
     var ticket = input.ticket || {};
     var job = input.job || {};
     var evidence = buildSupportQaEvidence(input);
@@ -3344,8 +5460,8 @@ function buildSupportAIRunFromEvidence(input) {
     addSourceId(sourceIds, 'jobId', job._id || job.id || job.jobId);
     addSourceId(sourceIds, 'buildPlanId', job.buildPlanId || ticket.buildPlanId);
     try {
-        for (var _73 = __values(asArray(input.taskEvents)), _74 = _73.next(); !_74.done; _74 = _73.next()) {
-            var event_1 = _74.value;
+        for (var _541 = __values(asArray(input.taskEvents)), _542 = _541.next(); !_542.done; _542 = _541.next()) {
+            var event_1 = _542.value;
             pushEvent(events, {
                 type: event_1.type === 'human_intervention' ? 'human_intervention' : 'log',
                 category: cleanText(event_1.category || event_1.phase || event_1.type, 160),
@@ -3362,13 +5478,13 @@ function buildSupportAIRunFromEvidence(input) {
     catch (e_32_1) { e_32 = { error: e_32_1 }; }
     finally {
         try {
-            if (_74 && !_74.done && (_a = _73.return)) _a.call(_73);
+            if (_542 && !_542.done && (_a = _541.return)) _a.call(_541);
         }
         finally { if (e_32) throw e_32.error; }
     }
     try {
-        for (var _75 = __values(asArray(input.aiJobs)), _76 = _75.next(); !_76.done; _76 = _75.next()) {
-            var aiJob = _76.value;
+        for (var _543 = __values(asArray(input.aiJobs)), _544 = _543.next(); !_544.done; _544 = _543.next()) {
+            var aiJob = _544.value;
             pushEvent(events, {
                 type: aiJob.model ? 'model_call' : 'log',
                 category: cleanText(aiJob.category || aiJob.phase || aiJob.runner, 160),
@@ -3386,7 +5502,7 @@ function buildSupportAIRunFromEvidence(input) {
     catch (e_33_1) { e_33 = { error: e_33_1 }; }
     finally {
         try {
-            if (_76 && !_76.done && (_b = _75.return)) _b.call(_75);
+            if (_544 && !_544.done && (_b = _543.return)) _b.call(_543);
         }
         finally { if (e_33) throw e_33.error; }
     }
@@ -3446,6 +5562,201 @@ function buildSupportAIRunFromEvidence(input) {
             metadata: customerReplyReadinessGate.metadata
         });
     }
+    var customerReplySendContract = supportProofBackedCustomerReplySendObject(ticket, job, evidence);
+    var customerReplySendGuard = supportCustomerReplySendGuardObject(ticket, job, evidence);
+    var customerReplySendGate = supportProofBackedCustomerReplySendGate(customerReplySendContract, customerReplySendGuard, input.now);
+    if (customerReplySendGate) {
+        gates.push(customerReplySendGate);
+        pushEvent(events, {
+            type: customerReplySendGate.status === 'pass' ? 'human_intervention' : 'log',
+            category: 'support_proof_backed_customer_reply_send',
+            message: customerReplySendGate.reason,
+            artifactPaths: customerReplySendGate.evidenceRefs,
+            recordedAt: customerReplySendGate.recordedAt,
+            metadata: customerReplySendGate.metadata
+        });
+    }
+    var autonomyApproval = supportAutonomyApprovalObject(ticket, job, evidence);
+    var autonomyApprovalGate = supportAutonomyApprovalGate(autonomyApproval, input.now);
+    if (autonomyApprovalGate) {
+        gates.push(autonomyApprovalGate);
+        pushEvent(events, {
+            type: 'human_intervention',
+            category: 'support_autonomy_approval',
+            message: autonomyApprovalGate.reason,
+            artifactPaths: autonomyApprovalGate.evidenceRefs,
+            recordedAt: autonomyApprovalGate.recordedAt,
+            metadata: autonomyApprovalGate.metadata
+        });
+    }
+    var productRepairDispatchGuard = supportProductRepairDispatchGuardObject(ticket, job, evidence);
+    var productRepairDispatchGate = supportProductRepairDispatchGuardGate(productRepairDispatchGuard, input.now);
+    if (productRepairDispatchGate) {
+        gates.push(productRepairDispatchGate);
+        pushEvent(events, {
+            type: 'human_intervention',
+            category: 'support_product_repair_dispatch_guard',
+            message: productRepairDispatchGate.reason,
+            artifactPaths: productRepairDispatchGate.evidenceRefs,
+            recordedAt: productRepairDispatchGate.recordedAt,
+            metadata: productRepairDispatchGate.metadata
+        });
+    }
+    var autoloopApprovalBlock = supportAutoloopApprovalBlockObject(ticket, job, evidence);
+    var autoloopApprovalBlockGate = supportAutoloopApprovalBlockGate(autoloopApprovalBlock, input.now);
+    if (autoloopApprovalBlockGate) {
+        gates.push(autoloopApprovalBlockGate);
+        pushEvent(events, {
+            type: 'human_intervention',
+            category: 'support_autoloop_approval_block',
+            message: autoloopApprovalBlockGate.reason,
+            artifactPaths: autoloopApprovalBlockGate.evidenceRefs,
+            recordedAt: autoloopApprovalBlockGate.recordedAt,
+            metadata: autoloopApprovalBlockGate.metadata
+        });
+    }
+    var autoloopNoProgress = supportAutoloopNoProgressObject(ticket, job, evidence);
+    var autoloopNoProgressGate = supportAutoloopNoProgressGate(autoloopNoProgress, input.now);
+    if (autoloopNoProgressGate) {
+        gates.push(autoloopNoProgressGate);
+        pushEvent(events, {
+            type: autoloopNoProgressGate.status === 'blocked' ? 'human_intervention' : 'log',
+            category: 'support_autoloop_no_progress',
+            message: autoloopNoProgressGate.reason,
+            artifactPaths: autoloopNoProgressGate.evidenceRefs,
+            recordedAt: autoloopNoProgressGate.recordedAt,
+            metadata: autoloopNoProgressGate.metadata
+        });
+    }
+    var humanDecisionRequest = supportHumanDecisionRequestObject(ticket, job, evidence);
+    var humanDecisionRequestGate = supportHumanDecisionRequestGate(humanDecisionRequest, input.now);
+    if (humanDecisionRequestGate) {
+        gates.push(humanDecisionRequestGate);
+        pushEvent(events, {
+            type: 'human_intervention',
+            category: 'support_human_decision_request',
+            message: humanDecisionRequestGate.reason,
+            artifactPaths: humanDecisionRequestGate.evidenceRefs,
+            recordedAt: humanDecisionRequestGate.recordedAt,
+            metadata: humanDecisionRequestGate.metadata
+        });
+    }
+    var postApprovalAutostart = supportPostApprovalAutostartObject(ticket, job, evidence);
+    var postApprovalAutostartGate = supportPostApprovalAutostartGate(postApprovalAutostart, input.now);
+    if (postApprovalAutostartGate) {
+        gates.push(postApprovalAutostartGate);
+        pushEvent(events, {
+            type: 'log',
+            category: 'support_post_approval_autostart',
+            message: postApprovalAutostartGate.reason,
+            artifactPaths: postApprovalAutostartGate.evidenceRefs,
+            recordedAt: postApprovalAutostartGate.recordedAt,
+            metadata: postApprovalAutostartGate.metadata
+        });
+    }
+    var postApprovalResumeAttempt = supportPostApprovalResumeAttemptObject(ticket, job, evidence);
+    var postApprovalResumeAttemptGate = supportPostApprovalResumeAttemptGate(postApprovalResumeAttempt, input.now);
+    if (postApprovalResumeAttemptGate) {
+        gates.push(postApprovalResumeAttemptGate);
+        pushEvent(events, {
+            type: 'log',
+            category: 'support_post_approval_resume_attempt',
+            message: postApprovalResumeAttemptGate.reason,
+            artifactPaths: postApprovalResumeAttemptGate.evidenceRefs,
+            recordedAt: postApprovalResumeAttemptGate.recordedAt,
+            metadata: postApprovalResumeAttemptGate.metadata
+        });
+    }
+    var intakeRevisionContract = supportIntakeRevisionContractObject(ticket, job, evidence);
+    var intakeRevisionContractGate = supportIntakeRevisionContractGate(intakeRevisionContract, input.now);
+    if (intakeRevisionContractGate) {
+        gates.push(intakeRevisionContractGate);
+        pushEvent(events, {
+            type: 'human_intervention',
+            category: 'support_intake_revision_contract',
+            message: intakeRevisionContractGate.reason,
+            artifactPaths: intakeRevisionContractGate.evidenceRefs,
+            recordedAt: intakeRevisionContractGate.recordedAt,
+            metadata: intakeRevisionContractGate.metadata
+        });
+    }
+    var managerContinuation = supportManagerContinuationObject(ticket, job, evidence);
+    var managerContinuationGate = supportManagerContinuationGate(managerContinuation, input.now);
+    if (managerContinuationGate) {
+        gates.push(managerContinuationGate);
+        pushEvent(events, {
+            type: 'human_intervention',
+            category: 'support_manager_continuation',
+            message: managerContinuationGate.reason,
+            artifactPaths: managerContinuationGate.evidenceRefs,
+            recordedAt: managerContinuationGate.recordedAt,
+            metadata: managerContinuationGate.metadata
+        });
+    }
+    var prReadinessContract = supportPrReadinessContractObject(ticket, job, evidence);
+    var prReadinessContractGate = supportPrReadinessContractGate(prReadinessContract, input.now);
+    if (prReadinessContractGate) {
+        gates.push(prReadinessContractGate);
+        pushEvent(events, {
+            type: 'log',
+            category: 'support_pr_readiness_contract',
+            message: prReadinessContractGate.reason,
+            artifactPaths: prReadinessContractGate.evidenceRefs,
+            recordedAt: prReadinessContractGate.recordedAt,
+            metadata: prReadinessContractGate.metadata
+        });
+    }
+    var prReviewContract = supportPrReviewContractObject(ticket, job, evidence);
+    var prReviewContractGate = supportPrReviewContractGate(prReviewContract, input.now);
+    if (prReviewContractGate) {
+        gates.push(prReviewContractGate);
+        pushEvent(events, {
+            type: 'log',
+            category: 'support_pr_review_contract',
+            message: prReviewContractGate.reason,
+            artifactPaths: prReviewContractGate.evidenceRefs,
+            recordedAt: prReviewContractGate.recordedAt,
+            metadata: prReviewContractGate.metadata
+        });
+    }
+    var prCreationResult = supportPrCreationResultObject(ticket, job, evidence);
+    var prCreationResultGate = supportPrCreationResultGate(prCreationResult, input.now);
+    if (prCreationResultGate) {
+        gates.push(prCreationResultGate);
+        pushEvent(events, {
+            type: 'log',
+            category: 'support_pr_creation_result',
+            message: prCreationResultGate.reason,
+            artifactPaths: prCreationResultGate.evidenceRefs,
+            recordedAt: prCreationResultGate.recordedAt,
+            metadata: prCreationResultGate.metadata
+        });
+    }
+    var autopilotCompletionGate = supportAutopilotCompletionContractGate(autonomyApproval, prReadinessContract, prReviewContract, input.now);
+    if (autopilotCompletionGate) {
+        gates.push(autopilotCompletionGate);
+        pushEvent(events, {
+            type: 'log',
+            category: 'support_autopilot_completion_contract',
+            message: autopilotCompletionGate.reason,
+            artifactPaths: autopilotCompletionGate.evidenceRefs,
+            recordedAt: autopilotCompletionGate.recordedAt,
+            metadata: autopilotCompletionGate.metadata
+        });
+    }
+    var releaseCustomerAcceptance = supportReleaseCustomerAcceptanceObject(ticket, job, evidence, prReadinessContract);
+    var releaseCustomerAcceptanceGate = supportReleaseCustomerAcceptanceGate(releaseCustomerAcceptance, input.now);
+    if (releaseCustomerAcceptanceGate) {
+        gates.push(releaseCustomerAcceptanceGate);
+        pushEvent(events, {
+            type: 'deploy',
+            category: 'support_release_customer_acceptance',
+            message: releaseCustomerAcceptanceGate.reason,
+            artifactPaths: releaseCustomerAcceptanceGate.evidenceRefs,
+            recordedAt: releaseCustomerAcceptanceGate.recordedAt,
+            metadata: releaseCustomerAcceptanceGate.metadata
+        });
+    }
     var nextActionContract = supportNextActionContractObject(ticket, job, evidence);
     var nextActionContractRequired = supportNextActionContractRequired(ticket, job, evidence);
     var nextActionContractGate = supportNextActionContractGate(nextActionContract, input.now, nextActionContractRequired);
@@ -3460,6 +5771,35 @@ function buildSupportAIRunFromEvidence(input) {
             metadata: nextActionContractGate.metadata
         });
     }
+    var evidenceProbeContract = supportEvidenceProbeContractObject(ticket, job, evidence);
+    var evidenceProbeContractRequired = cleanText(nextActionContract.action, 160) === 'collect_new_evidence'
+        || ((_c = noBlindLoopGate === null || noBlindLoopGate === void 0 ? void 0 : noBlindLoopGate.metadata) === null || _c === void 0 ? void 0 : _c.requiresNewEvidence) === true
+        || Object.keys(evidenceProbeContract).length > 0;
+    var evidenceProbeContractGate = supportEvidenceProbeContractGate(evidenceProbeContract, input.now, evidenceProbeContractRequired);
+    if (evidenceProbeContractGate) {
+        gates.push(evidenceProbeContractGate);
+        pushEvent(events, {
+            type: 'log',
+            category: 'support_evidence_probe_contract',
+            message: evidenceProbeContractGate.reason,
+            artifactPaths: evidenceProbeContractGate.evidenceRefs,
+            recordedAt: evidenceProbeContractGate.recordedAt,
+            metadata: evidenceProbeContractGate.metadata
+        });
+    }
+    var managerExecutionPacket = supportManagerExecutionPacketObject(ticket, job, evidence, nextActionContract);
+    var managerExecutionPacketGate = supportManagerExecutionPacketGate(managerExecutionPacket, input.now, nextActionContractRequired);
+    if (managerExecutionPacketGate) {
+        gates.push(managerExecutionPacketGate);
+        pushEvent(events, {
+            type: 'log',
+            category: 'support_manager_execution_packet',
+            message: managerExecutionPacketGate.reason,
+            artifactPaths: managerExecutionPacketGate.evidenceRefs,
+            recordedAt: managerExecutionPacketGate.recordedAt,
+            metadata: managerExecutionPacketGate.metadata
+        });
+    }
     var managerRecoveryExecutionProof = plainObject(evidence.managerRecoveryExecutionProof || evidence.manager_recovery_execution_proof);
     var recoveryExecutionProofGate = managerRecoveryExecutionProofGate(managerRecoveryExecutionProof, input.now);
     if (recoveryExecutionProofGate) {
@@ -3504,7 +5844,7 @@ function buildSupportAIRunFromEvidence(input) {
     if (preflightGate) {
         gates.push(preflightGate);
         pushEvent(events, {
-            type: ((_c = preflightGate.metadata) === null || _c === void 0 ? void 0 : _c.failureClass) === 'compile' || preflightGateSource.status === 'compile_failed' ? 'qa_compile' : 'qa_infra',
+            type: ((_d = preflightGate.metadata) === null || _d === void 0 ? void 0 : _d.failureClass) === 'compile' || preflightGateSource.status === 'compile_failed' ? 'qa_compile' : 'qa_infra',
             category: 'support_preflight_gate',
             message: preflightGate.reason,
             artifactPaths: preflightGate.evidenceRefs,
@@ -3515,6 +5855,19 @@ function buildSupportAIRunFromEvidence(input) {
     var diagnosisGate = evidenceObject(job.supportV5DiagnosisGate, job.support_v5_diagnosis_gate, job.diagnosisGate, ticket.supportV5DiagnosisGate, ticket.diagnosisGate, evidence.diagnosisGate, evidence.supportV5DiagnosisGate);
     var diagnosisEvidencePackSource = supportDiagnosisEvidencePackObject(ticket, job, evidence);
     var similarFixHints = supportSimilarFixHintsObject(ticket, job, evidence);
+    var similarFixHintContract = supportSimilarFixHintContractObject(ticket, job, evidence);
+    var similarFixHintContractGate = supportSimilarFixHintContractGate(similarFixHintContract, input.now);
+    if (similarFixHintContractGate) {
+        gates.push(similarFixHintContractGate);
+        pushEvent(events, {
+            type: 'log',
+            category: 'support_similar_fix_hint_contract',
+            message: similarFixHintContractGate.reason,
+            artifactPaths: similarFixHintContractGate.evidenceRefs,
+            recordedAt: similarFixHintContractGate.recordedAt,
+            metadata: similarFixHintContractGate.metadata
+        });
+    }
     var diagnosisEvidencePack = Object.keys(diagnosisEvidencePackSource).length
         ? diagnosisEvidencePackSource
         : (Object.keys(diagnosisGate).length || Object.keys(similarFixHints).length)
@@ -3545,6 +5898,23 @@ function buildSupportAIRunFromEvidence(input) {
             metadata: diagnosisEvidencePackGate.metadata
         });
     }
+    var diagnosisProofMatrix = Object.keys(plainObject(diagnosisEvidencePack.proofMatrix || diagnosisEvidencePack.proof_matrix)).length
+        ? plainObject(diagnosisEvidencePack.proofMatrix || diagnosisEvidencePack.proof_matrix)
+        : Object.keys(diagnosisGate).length
+            ? (0, support_runner_v5_1.buildResolveIOSupportDiagnosisProofMatrix)(diagnosisGate, input.now)
+            : {};
+    var diagnosisProofMatrixGate = supportDiagnosisProofMatrixGate(diagnosisProofMatrix, input.now, Object.keys(diagnosisGate).length > 0 || nextActionContractRequired);
+    if (diagnosisProofMatrixGate) {
+        gates.push(diagnosisProofMatrixGate);
+        pushEvent(events, {
+            type: 'log',
+            category: 'support_diagnosis_proof_matrix',
+            message: diagnosisProofMatrixGate.reason,
+            artifactPaths: diagnosisProofMatrixGate.evidenceRefs,
+            recordedAt: diagnosisProofMatrixGate.recordedAt,
+            metadata: diagnosisProofMatrixGate.metadata
+        });
+    }
     var issueClassProbePlanSource = supportIssueClassProbePlanObject(ticket, job, evidence);
     var issueClassProbePlan = Object.keys(issueClassProbePlanSource).length
         ? issueClassProbePlanSource
@@ -3565,6 +5935,36 @@ function buildSupportAIRunFromEvidence(input) {
         });
     }
     var productRepairEvidence = supportProductRepairEvidence(input, evidence);
+    var autonomousDecisionForRepairContract = plainObject(job.supportV5AutonomousDecision
+        || job.support_v5_autonomous_decision
+        || evidence.supportV5AutonomousDecision
+        || evidence.support_v5_autonomous_decision
+        || ticket.supportV5AutonomousDecision
+        || ticket.support_v5_autonomous_decision);
+    var repairGateForRepairContract = plainObject(autonomousDecisionForRepairContract.repairGate || autonomousDecisionForRepairContract.repair_gate);
+    var ownerScopedRepairContractSource = evidenceObject(autonomousDecisionForRepairContract.ownerScopedRepairContract, autonomousDecisionForRepairContract.owner_scoped_repair_contract, repairGateForRepairContract.ownerScopedRepairContract, repairGateForRepairContract.owner_scoped_repair_contract, job.supportV5OwnerScopedRepairContract, job.support_v5_owner_scoped_repair_contract, job.ownerScopedRepairContract, job.owner_scoped_repair_contract, evidence.supportV5OwnerScopedRepairContract, evidence.support_v5_owner_scoped_repair_contract, evidence.ownerScopedRepairContract, evidence.owner_scoped_repair_contract, ticket.supportV5OwnerScopedRepairContract, ticket.support_v5_owner_scoped_repair_contract, ticket.ownerScopedRepairContract, ticket.owner_scoped_repair_contract);
+    var ownerScopedRepairContract = Object.keys(ownerScopedRepairContractSource).length
+        ? ownerScopedRepairContractSource
+        : Object.keys(diagnosisGate).length
+            ? (0, support_runner_v5_1.buildResolveIOSupportOwnerScopedRepairContract)({
+                diagnosisGate: diagnosisGate,
+                changedFiles: productRepairEvidence.changedFiles,
+                allowTestsOutsideOwnerFiles: true,
+                now: input.now
+            })
+            : {};
+    var ownerScopedRepairContractGate = supportOwnerScopedRepairContractGate(ownerScopedRepairContract, input.now, productRepairEvidence.attempted || cleanText(nextActionContract.action, 120) === 'run_owner_scoped_repair');
+    if (ownerScopedRepairContractGate) {
+        gates.push(ownerScopedRepairContractGate);
+        pushEvent(events, {
+            type: 'log',
+            category: 'support_owner_scoped_repair_contract',
+            message: ownerScopedRepairContractGate.reason,
+            artifactPaths: ownerScopedRepairContractGate.evidenceRefs,
+            recordedAt: ownerScopedRepairContractGate.recordedAt,
+            metadata: ownerScopedRepairContractGate.metadata
+        });
+    }
     var diagnosisBeforeRepairGate = supportDiagnosisBeforeRepairGate(diagnosisGate, productRepairEvidence, input.now);
     if (diagnosisBeforeRepairGate) {
         gates.push(diagnosisBeforeRepairGate);
@@ -3596,7 +5996,7 @@ function buildSupportAIRunFromEvidence(input) {
         pushEvent(events, {
             type: 'log',
             category: 'diagnosis_gate',
-            message: cleanText(((_d = diagnosisGate.accepted_hypothesis) === null || _d === void 0 ? void 0 : _d.statement) || ((_e = diagnosisGate.acceptedHypothesis) === null || _e === void 0 ? void 0 : _e.statement) || diagnosisGate.summary || 'Support diagnosis gate recorded.', 1800),
+            message: cleanText(((_e = diagnosisGate.accepted_hypothesis) === null || _e === void 0 ? void 0 : _e.statement) || ((_f = diagnosisGate.acceptedHypothesis) === null || _f === void 0 ? void 0 : _f.statement) || diagnosisGate.summary || 'Support diagnosis gate recorded.', 1800),
             metadata: {
                 status: diagnosisGate.status,
                 issueClass: diagnosisIssueClass,
@@ -3632,71 +6032,542 @@ function buildSupportAIRunFromEvidence(input) {
             costObservability: costObservabilityMetadata(costGate),
             hotfixDurability: hotfixDurabilityMetadata(gates),
             managerNoBlindLoopPolicy: managerNoBlindLoopMetadata(noBlindLoopGate),
+            autonomyApproval: autonomyApprovalGate ? {
+                status: autonomyApprovalGate.status,
+                approved: ((_g = autonomyApprovalGate.metadata) === null || _g === void 0 ? void 0 : _g.approved) === true,
+                contractId: cleanText((_h = autonomyApprovalGate.metadata) === null || _h === void 0 ? void 0 : _h.contractId, 180),
+                decisionKind: cleanText((_j = autonomyApprovalGate.metadata) === null || _j === void 0 ? void 0 : _j.decisionKind, 120),
+                approvalAction: cleanText((_k = autonomyApprovalGate.metadata) === null || _k === void 0 ? void 0 : _k.approvalAction, 120),
+                preferredChoiceId: cleanText((_l = autonomyApprovalGate.metadata) === null || _l === void 0 ? void 0 : _l.preferredChoiceId, 120),
+                canApproveFromConsole: ((_m = autonomyApprovalGate.metadata) === null || _m === void 0 ? void 0 : _m.canApproveFromConsole) === true,
+                estimatedHours: Number(((_o = autonomyApprovalGate.metadata) === null || _o === void 0 ? void 0 : _o.estimatedHours) || 0),
+                estimatedHoursKnown: ((_p = autonomyApprovalGate.metadata) === null || _p === void 0 ? void 0 : _p.estimatedHoursKnown) === true,
+                maxAutoHoursWithoutApproval: Number(((_q = autonomyApprovalGate.metadata) === null || _q === void 0 ? void 0 : _q.maxAutoHoursWithoutApproval) || 0),
+                overMaxAutoHours: ((_r = autonomyApprovalGate.metadata) === null || _r === void 0 ? void 0 : _r.overMaxAutoHours) === true,
+                approveOverMaxHours: ((_s = autonomyApprovalGate.metadata) === null || _s === void 0 ? void 0 : _s.approveOverMaxHours) === true,
+                approveOverSixHours: ((_t = autonomyApprovalGate.metadata) === null || _t === void 0 ? void 0 : _t.approveOverSixHours) === true,
+                explicitOverLimitApproval: ((_u = autonomyApprovalGate.metadata) === null || _u === void 0 ? void 0 : _u.explicitOverLimitApproval) === true,
+                bugNotBug: cleanText((_v = autonomyApprovalGate.metadata) === null || _v === void 0 ? void 0 : _v.bugNotBug, 80),
+                bugNotBugKnown: ((_w = autonomyApprovalGate.metadata) === null || _w === void 0 ? void 0 : _w.bugNotBugKnown) === true,
+                bugNotBugClassificationApproved: ((_x = autonomyApprovalGate.metadata) === null || _x === void 0 ? void 0 : _x.bugNotBugClassificationApproved) === true,
+                requiresOverLimitApproval: ((_y = autonomyApprovalGate.metadata) === null || _y === void 0 ? void 0 : _y.requiresOverLimitApproval) === true,
+                requiresScopeReapproval: ((_z = autonomyApprovalGate.metadata) === null || _z === void 0 ? void 0 : _z.requiresScopeReapproval) === true,
+                requiresOwnerFileReapproval: ((_0 = autonomyApprovalGate.metadata) === null || _0 === void 0 ? void 0 : _0.requiresOwnerFileReapproval) === true,
+                requiresIntakeReapproval: ((_1 = autonomyApprovalGate.metadata) === null || _1 === void 0 ? void 0 : _1.requiresIntakeReapproval) === true,
+                requiresDiagnosisScopeReapproval: ((_2 = autonomyApprovalGate.metadata) === null || _2 === void 0 ? void 0 : _2.requiresDiagnosisScopeReapproval) === true,
+                requiresClassificationApproval: ((_3 = autonomyApprovalGate.metadata) === null || _3 === void 0 ? void 0 : _3.requiresClassificationApproval) === true,
+                requiresEstimateHours: ((_4 = autonomyApprovalGate.metadata) === null || _4 === void 0 ? void 0 : _4.requiresEstimateHours) === true,
+                changeApprovalMode: cleanText((_5 = autonomyApprovalGate.metadata) === null || _5 === void 0 ? void 0 : _5.changeApprovalMode, 120),
+                overSixHourRequiresExplicitOperatorApproval: ((_6 = autonomyApprovalGate.metadata) === null || _6 === void 0 ? void 0 : _6.overSixHourRequiresExplicitOperatorApproval) === true,
+                leSixHourScopeCanAutofixAfterApproval: ((_7 = autonomyApprovalGate.metadata) === null || _7 === void 0 ? void 0 : _7.leSixHourScopeCanAutofixAfterApproval) === true,
+                afterApprovalAutopilotUntilAGrade: ((_8 = autonomyApprovalGate.metadata) === null || _8 === void 0 ? void 0 : _8.afterApprovalAutopilotUntilAGrade) === true,
+                targetGrade: cleanText((_9 = autonomyApprovalGate.metadata) === null || _9 === void 0 ? void 0 : _9.targetGrade, 20),
+                autopilotCompletionStatus: cleanText((_10 = autonomyApprovalGate.metadata) === null || _10 === void 0 ? void 0 : _10.autopilotCompletionStatus, 120),
+                terminalTarget: cleanText((_11 = autonomyApprovalGate.metadata) === null || _11 === void 0 ? void 0 : _11.terminalTarget, 800),
+                stopOrParkConditions: cleanStringList((_12 = autonomyApprovalGate.metadata) === null || _12 === void 0 ? void 0 : _12.stopOrParkConditions, 20, 500),
+                qaScreenshotsRequired: ((_13 = autonomyApprovalGate.metadata) === null || _13 === void 0 ? void 0 : _13.qaScreenshotsRequired) === true,
+                beforeActionAfterBusinessProofRequired: ((_14 = autonomyApprovalGate.metadata) === null || _14 === void 0 ? void 0 : _14.beforeActionAfterBusinessProofRequired) === true,
+                aiqaBusinessAssertionRequired: ((_15 = autonomyApprovalGate.metadata) === null || _15 === void 0 ? void 0 : _15.aiqaBusinessAssertionRequired) === true,
+                scopeFingerprint: cleanText((_16 = autonomyApprovalGate.metadata) === null || _16 === void 0 ? void 0 : _16.scopeFingerprint, 180),
+                previousScopeFingerprint: cleanText((_17 = autonomyApprovalGate.metadata) === null || _17 === void 0 ? void 0 : _17.previousScopeFingerprint, 180),
+                scopeChangedSinceApproval: ((_18 = autonomyApprovalGate.metadata) === null || _18 === void 0 ? void 0 : _18.scopeChangedSinceApproval) === true,
+                ownerFilesChangedSinceApproval: ((_19 = autonomyApprovalGate.metadata) === null || _19 === void 0 ? void 0 : _19.ownerFilesChangedSinceApproval) === true,
+                ownerFileFingerprint: cleanText((_20 = autonomyApprovalGate.metadata) === null || _20 === void 0 ? void 0 : _20.ownerFileFingerprint, 180),
+                approvedOwnerFileFingerprint: cleanText((_21 = autonomyApprovalGate.metadata) === null || _21 === void 0 ? void 0 : _21.approvedOwnerFileFingerprint, 180),
+                approvedOwnerFileSetChanged: ((_22 = autonomyApprovalGate.metadata) === null || _22 === void 0 ? void 0 : _22.approvedOwnerFileSetChanged) === true,
+                diagnosisScopeFingerprint: cleanText((_23 = autonomyApprovalGate.metadata) === null || _23 === void 0 ? void 0 : _23.diagnosisScopeFingerprint, 180),
+                previousDiagnosisScopeFingerprint: cleanText((_24 = autonomyApprovalGate.metadata) === null || _24 === void 0 ? void 0 : _24.previousDiagnosisScopeFingerprint, 180),
+                diagnosisScopeIncluded: ((_25 = autonomyApprovalGate.metadata) === null || _25 === void 0 ? void 0 : _25.diagnosisScopeIncluded) === true,
+                diagnosisScopeValid: ((_26 = autonomyApprovalGate.metadata) === null || _26 === void 0 ? void 0 : _26.diagnosisScopeValid) === true,
+                diagnosisScopeChangedSinceApproval: ((_27 = autonomyApprovalGate.metadata) === null || _27 === void 0 ? void 0 : _27.diagnosisScopeChangedSinceApproval) === true,
+                diagnosisScopeFields: cleanStringList((_28 = autonomyApprovalGate.metadata) === null || _28 === void 0 ? void 0 : _28.diagnosisScopeFields, 40, 160),
+                diagnosisScopeBlockers: cleanStringList((_29 = autonomyApprovalGate.metadata) === null || _29 === void 0 ? void 0 : _29.diagnosisScopeBlockers, 40, 500),
+                boundedAutopilotApproval: ((_30 = autonomyApprovalGate.metadata) === null || _30 === void 0 ? void 0 : _30.boundedAutopilotApproval) === true,
+                autopilotApprovalBoundaryValid: ((_31 = autonomyApprovalGate.metadata) === null || _31 === void 0 ? void 0 : _31.autopilotApprovalBoundaryValid) === true,
+                ownerFilesAddedSinceApproval: cleanStringList((_32 = autonomyApprovalGate.metadata) === null || _32 === void 0 ? void 0 : _32.ownerFilesAddedSinceApproval, 40, 500),
+                ownerFilesRemovedSinceApproval: cleanStringList((_33 = autonomyApprovalGate.metadata) === null || _33 === void 0 ? void 0 : _33.ownerFilesRemovedSinceApproval, 40, 500),
+                ownerFiles: cleanStringList((_34 = autonomyApprovalGate.metadata) === null || _34 === void 0 ? void 0 : _34.ownerFiles, 60, 500),
+                approvedOwnerFiles: cleanStringList((_35 = autonomyApprovalGate.metadata) === null || _35 === void 0 ? void 0 : _35.approvedOwnerFiles, 60, 500),
+                currentOwnerFiles: cleanStringList((_36 = autonomyApprovalGate.metadata) === null || _36 === void 0 ? void 0 : _36.currentOwnerFiles, 60, 500),
+                requiredCompletionEvidence: cleanStringList((_37 = autonomyApprovalGate.metadata) === null || _37 === void 0 ? void 0 : _37.requiredCompletionEvidence, 30, 500),
+                forbiddenWithoutReapproval: cleanStringList((_38 = autonomyApprovalGate.metadata) === null || _38 === void 0 ? void 0 : _38.forbiddenWithoutReapproval, 30, 500),
+                blockers: cleanStringList((_39 = autonomyApprovalGate.metadata) === null || _39 === void 0 ? void 0 : _39.blockers, 40, 500)
+            } : undefined,
+            productRepairDispatchGuard: productRepairDispatchGate ? {
+                status: productRepairDispatchGate.status,
+                allowed: ((_40 = productRepairDispatchGate.metadata) === null || _40 === void 0 ? void 0 : _40.allowed) === true,
+                guardStatus: cleanText((_41 = productRepairDispatchGate.metadata) === null || _41 === void 0 ? void 0 : _41.status, 120),
+                action: cleanText((_42 = productRepairDispatchGate.metadata) === null || _42 === void 0 ? void 0 : _42.action, 160),
+                nextAction: cleanText((_43 = productRepairDispatchGate.metadata) === null || _43 === void 0 ? void 0 : _43.nextAction, 160),
+                editsProductCode: ((_44 = productRepairDispatchGate.metadata) === null || _44 === void 0 ? void 0 : _44.editsProductCode) === true,
+                canEditProductCode: ((_45 = productRepairDispatchGate.metadata) === null || _45 === void 0 ? void 0 : _45.canEditProductCode) === true,
+                autoContinueAfterApproval: ((_46 = productRepairDispatchGate.metadata) === null || _46 === void 0 ? void 0 : _46.autoContinueAfterApproval) === true,
+                approvalContractId: cleanText((_47 = productRepairDispatchGate.metadata) === null || _47 === void 0 ? void 0 : _47.approvalContractId, 180),
+                continuationContractStatus: cleanText((_48 = productRepairDispatchGate.metadata) === null || _48 === void 0 ? void 0 : _48.continuationContractStatus, 120),
+                continuationContractMode: cleanText((_49 = productRepairDispatchGate.metadata) === null || _49 === void 0 ? void 0 : _49.continuationContractMode, 160),
+                terminalTarget: cleanText((_50 = productRepairDispatchGate.metadata) === null || _50 === void 0 ? void 0 : _50.terminalTarget, 800),
+                nextProofPhases: cleanStringList((_51 = productRepairDispatchGate.metadata) === null || _51 === void 0 ? void 0 : _51.nextProofPhases, 20, 240),
+                allowedAutoActions: cleanStringList((_52 = productRepairDispatchGate.metadata) === null || _52 === void 0 ? void 0 : _52.allowedAutoActions, 20, 240),
+                forbiddenActions: cleanStringList((_53 = productRepairDispatchGate.metadata) === null || _53 === void 0 ? void 0 : _53.forbiddenActions, 30, 500),
+                scopeFingerprint: cleanText((_54 = productRepairDispatchGate.metadata) === null || _54 === void 0 ? void 0 : _54.scopeFingerprint, 180),
+                ownerFilesChangedSinceApproval: ((_55 = productRepairDispatchGate.metadata) === null || _55 === void 0 ? void 0 : _55.ownerFilesChangedSinceApproval) === true,
+                ownerFileFingerprint: cleanText((_56 = productRepairDispatchGate.metadata) === null || _56 === void 0 ? void 0 : _56.ownerFileFingerprint, 180),
+                approvedOwnerFileFingerprint: cleanText((_57 = productRepairDispatchGate.metadata) === null || _57 === void 0 ? void 0 : _57.approvedOwnerFileFingerprint, 180),
+                ownerFilesAddedSinceApproval: cleanStringList((_58 = productRepairDispatchGate.metadata) === null || _58 === void 0 ? void 0 : _58.ownerFilesAddedSinceApproval, 40, 500),
+                ownerFilesRemovedSinceApproval: cleanStringList((_59 = productRepairDispatchGate.metadata) === null || _59 === void 0 ? void 0 : _59.ownerFilesRemovedSinceApproval, 40, 500),
+                requiresOverLimitApproval: ((_60 = productRepairDispatchGate.metadata) === null || _60 === void 0 ? void 0 : _60.requiresOverLimitApproval) === true,
+                requiresScopeReapproval: ((_61 = productRepairDispatchGate.metadata) === null || _61 === void 0 ? void 0 : _61.requiresScopeReapproval) === true,
+                requiresOwnerFileReapproval: ((_62 = productRepairDispatchGate.metadata) === null || _62 === void 0 ? void 0 : _62.requiresOwnerFileReapproval) === true,
+                requiresDiagnosisScopeReapproval: ((_63 = productRepairDispatchGate.metadata) === null || _63 === void 0 ? void 0 : _63.requiresDiagnosisScopeReapproval) === true,
+                ownerFiles: cleanStringList((_64 = productRepairDispatchGate.metadata) === null || _64 === void 0 ? void 0 : _64.ownerFiles, 60, 500),
+                approvedOwnerFiles: cleanStringList((_65 = productRepairDispatchGate.metadata) === null || _65 === void 0 ? void 0 : _65.approvedOwnerFiles, 60, 500),
+                currentOwnerFiles: cleanStringList((_66 = productRepairDispatchGate.metadata) === null || _66 === void 0 ? void 0 : _66.currentOwnerFiles, 60, 500),
+                blockers: cleanStringList((_67 = productRepairDispatchGate.metadata) === null || _67 === void 0 ? void 0 : _67.blockers, 40, 500)
+            } : undefined,
+            autoloopApprovalBlock: autoloopApprovalBlockGate ? {
+                status: autoloopApprovalBlockGate.status,
+                recordId: cleanText((_68 = autoloopApprovalBlockGate.metadata) === null || _68 === void 0 ? void 0 : _68.recordId, 180),
+                blockStatus: cleanText((_69 = autoloopApprovalBlockGate.metadata) === null || _69 === void 0 ? void 0 : _69.status, 160),
+                action: cleanText((_70 = autoloopApprovalBlockGate.metadata) === null || _70 === void 0 ? void 0 : _70.action, 160),
+                nextAction: cleanText((_71 = autoloopApprovalBlockGate.metadata) === null || _71 === void 0 ? void 0 : _71.nextAction, 160),
+                approvalContractId: cleanText((_72 = autoloopApprovalBlockGate.metadata) === null || _72 === void 0 ? void 0 : _72.approvalContractId, 180),
+                scopeFingerprint: cleanText((_73 = autoloopApprovalBlockGate.metadata) === null || _73 === void 0 ? void 0 : _73.scopeFingerprint, 180),
+                diagnosisScopeFingerprint: cleanText((_74 = autoloopApprovalBlockGate.metadata) === null || _74 === void 0 ? void 0 : _74.diagnosisScopeFingerprint, 180),
+                repairIntentScopeFingerprint: cleanText((_75 = autoloopApprovalBlockGate.metadata) === null || _75 === void 0 ? void 0 : _75.repairIntentScopeFingerprint, 180),
+                decisionKind: cleanText((_76 = autoloopApprovalBlockGate.metadata) === null || _76 === void 0 ? void 0 : _76.decisionKind, 160),
+                requiresOverLimitApproval: ((_77 = autoloopApprovalBlockGate.metadata) === null || _77 === void 0 ? void 0 : _77.requiresOverLimitApproval) === true,
+                requiresScopeReapproval: ((_78 = autoloopApprovalBlockGate.metadata) === null || _78 === void 0 ? void 0 : _78.requiresScopeReapproval) === true,
+                requiresOwnerFileReapproval: ((_79 = autoloopApprovalBlockGate.metadata) === null || _79 === void 0 ? void 0 : _79.requiresOwnerFileReapproval) === true,
+                requiresDiagnosisScopeReapproval: ((_80 = autoloopApprovalBlockGate.metadata) === null || _80 === void 0 ? void 0 : _80.requiresDiagnosisScopeReapproval) === true,
+                requiresRepairIntentReapproval: ((_81 = autoloopApprovalBlockGate.metadata) === null || _81 === void 0 ? void 0 : _81.requiresRepairIntentReapproval) === true,
+                requiresRepairIntent: ((_82 = autoloopApprovalBlockGate.metadata) === null || _82 === void 0 ? void 0 : _82.requiresRepairIntent) === true,
+                requiresClassificationApproval: ((_83 = autoloopApprovalBlockGate.metadata) === null || _83 === void 0 ? void 0 : _83.requiresClassificationApproval) === true,
+                requiresEstimateHours: ((_84 = autoloopApprovalBlockGate.metadata) === null || _84 === void 0 ? void 0 : _84.requiresEstimateHours) === true,
+                requiresElapsedReapproval: ((_85 = autoloopApprovalBlockGate.metadata) === null || _85 === void 0 ? void 0 : _85.requiresElapsedReapproval) === true,
+                elapsedRuntimeMs: Number(((_86 = autoloopApprovalBlockGate.metadata) === null || _86 === void 0 ? void 0 : _86.elapsedRuntimeMs) || 0) || 0,
+                elapsedRuntimeHours: Number(((_87 = autoloopApprovalBlockGate.metadata) === null || _87 === void 0 ? void 0 : _87.elapsedRuntimeHours) || 0) || 0,
+                maxApprovedRuntimeMs: Number(((_88 = autoloopApprovalBlockGate.metadata) === null || _88 === void 0 ? void 0 : _88.maxApprovedRuntimeMs) || 0) || 0,
+                maxApprovedRuntimeHours: Number(((_89 = autoloopApprovalBlockGate.metadata) === null || _89 === void 0 ? void 0 : _89.maxApprovedRuntimeHours) || 0) || 0,
+                maxWallClockMs: Number(((_90 = autoloopApprovalBlockGate.metadata) === null || _90 === void 0 ? void 0 : _90.maxWallClockMs) || 0) || 0,
+                maxWallClockHours: Number(((_91 = autoloopApprovalBlockGate.metadata) === null || _91 === void 0 ? void 0 : _91.maxWallClockHours) || 0) || 0,
+                onTheFlyScopeChangeApprovalRequired: ((_92 = autoloopApprovalBlockGate.metadata) === null || _92 === void 0 ? void 0 : _92.onTheFlyScopeChangeApprovalRequired) === true,
+                targetGrade: cleanText((_93 = autoloopApprovalBlockGate.metadata) === null || _93 === void 0 ? void 0 : _93.targetGrade, 20),
+                requiredTerminalState: cleanText((_94 = autoloopApprovalBlockGate.metadata) === null || _94 === void 0 ? void 0 : _94.requiredTerminalState, 800),
+                humanDecisionRequestId: cleanText((_95 = autoloopApprovalBlockGate.metadata) === null || _95 === void 0 ? void 0 : _95.humanDecisionRequestId, 180),
+                humanDecisionPreferredChoiceId: cleanText((_96 = autoloopApprovalBlockGate.metadata) === null || _96 === void 0 ? void 0 : _96.humanDecisionPreferredChoiceId, 160),
+                humanDecisionApprovalAction: cleanText((_97 = autoloopApprovalBlockGate.metadata) === null || _97 === void 0 ? void 0 : _97.humanDecisionApprovalAction, 160),
+                productRepairDispatchGuardStatus: cleanText((_98 = autoloopApprovalBlockGate.metadata) === null || _98 === void 0 ? void 0 : _98.productRepairDispatchGuardStatus, 120),
+                productRepairDispatchNextAction: cleanText((_99 = autoloopApprovalBlockGate.metadata) === null || _99 === void 0 ? void 0 : _99.productRepairDispatchNextAction, 160),
+                blockers: cleanStringList((_100 = autoloopApprovalBlockGate.metadata) === null || _100 === void 0 ? void 0 : _100.blockers, 40, 500)
+            } : undefined,
+            autoloopNoProgress: autoloopNoProgressGate ? {
+                status: autoloopNoProgressGate.status,
+                runId: cleanText((_101 = autoloopNoProgressGate.metadata) === null || _101 === void 0 ? void 0 : _101.runId, 180),
+                noProgressStreak: Number(((_102 = autoloopNoProgressGate.metadata) === null || _102 === void 0 ? void 0 : _102.noProgressStreak) || 0),
+                lastProgressSignal: ((_103 = autoloopNoProgressGate.metadata) === null || _103 === void 0 ? void 0 : _103.lastProgressSignal) === true,
+                evidenceChanged: ((_104 = autoloopNoProgressGate.metadata) === null || _104 === void 0 ? void 0 : _104.evidenceChanged) === true,
+                handoffRequired: ((_105 = autoloopNoProgressGate.metadata) === null || _105 === void 0 ? void 0 : _105.handoffRequired) === true,
+                requiresNewEvidence: ((_106 = autoloopNoProgressGate.metadata) === null || _106 === void 0 ? void 0 : _106.requiresNewEvidence) === true,
+                productRepairAllowed: ((_107 = autoloopNoProgressGate.metadata) === null || _107 === void 0 ? void 0 : _107.productRepairAllowed) === true,
+                nextAction: cleanText((_108 = autoloopNoProgressGate.metadata) === null || _108 === void 0 ? void 0 : _108.nextAction, 160),
+                strictGateReason: cleanText((_109 = autoloopNoProgressGate.metadata) === null || _109 === void 0 ? void 0 : _109.strictGateReason, 500),
+                diffFingerprint: cleanText((_110 = autoloopNoProgressGate.metadata) === null || _110 === void 0 ? void 0 : _110.diffFingerprint, 180),
+                failingCheckFingerprint: cleanText((_111 = autoloopNoProgressGate.metadata) === null || _111 === void 0 ? void 0 : _111.failingCheckFingerprint, 180),
+                continuationAction: cleanText((_112 = autoloopNoProgressGate.metadata) === null || _112 === void 0 ? void 0 : _112.continuationAction, 160),
+                continuationReason: cleanText((_113 = autoloopNoProgressGate.metadata) === null || _113 === void 0 ? void 0 : _113.continuationReason, 1000),
+                progressReasons: cleanStringList((_114 = autoloopNoProgressGate.metadata) === null || _114 === void 0 ? void 0 : _114.progressReasons, 20, 240),
+                evidenceReasons: cleanStringList((_115 = autoloopNoProgressGate.metadata) === null || _115 === void 0 ? void 0 : _115.evidenceReasons, 20, 240),
+                requiredEvidence: cleanStringList((_116 = autoloopNoProgressGate.metadata) === null || _116 === void 0 ? void 0 : _116.requiredEvidence, 20, 500),
+                forbiddenActions: cleanStringList((_117 = autoloopNoProgressGate.metadata) === null || _117 === void 0 ? void 0 : _117.forbiddenActions, 20, 500),
+                blockers: cleanStringList((_118 = autoloopNoProgressGate.metadata) === null || _118 === void 0 ? void 0 : _118.blockers, 40, 500)
+            } : undefined,
+            humanDecisionRequest: humanDecisionRequestGate ? {
+                status: humanDecisionRequestGate.status,
+                required: ((_119 = humanDecisionRequestGate.metadata) === null || _119 === void 0 ? void 0 : _119.required) === true,
+                requestId: cleanText((_120 = humanDecisionRequestGate.metadata) === null || _120 === void 0 ? void 0 : _120.requestId, 180),
+                decisionKind: cleanText((_121 = humanDecisionRequestGate.metadata) === null || _121 === void 0 ? void 0 : _121.decisionKind, 120),
+                approvalAction: cleanText((_122 = humanDecisionRequestGate.metadata) === null || _122 === void 0 ? void 0 : _122.approvalAction, 120),
+                preferredChoiceId: cleanText((_123 = humanDecisionRequestGate.metadata) === null || _123 === void 0 ? void 0 : _123.preferredChoiceId, 120),
+                canApproveFromConsole: ((_124 = humanDecisionRequestGate.metadata) === null || _124 === void 0 ? void 0 : _124.canApproveFromConsole) === true,
+                choiceCount: Number(((_125 = humanDecisionRequestGate.metadata) === null || _125 === void 0 ? void 0 : _125.choiceCount) || 0),
+                requiresOverLimitApproval: ((_126 = humanDecisionRequestGate.metadata) === null || _126 === void 0 ? void 0 : _126.requiresOverLimitApproval) === true,
+                requiresScopeReapproval: ((_127 = humanDecisionRequestGate.metadata) === null || _127 === void 0 ? void 0 : _127.requiresScopeReapproval) === true,
+                requiresIntakeReapproval: ((_128 = humanDecisionRequestGate.metadata) === null || _128 === void 0 ? void 0 : _128.requiresIntakeReapproval) === true,
+                requiresDiagnosisScopeReapproval: ((_129 = humanDecisionRequestGate.metadata) === null || _129 === void 0 ? void 0 : _129.requiresDiagnosisScopeReapproval) === true,
+                requiresClassificationApproval: ((_130 = humanDecisionRequestGate.metadata) === null || _130 === void 0 ? void 0 : _130.requiresClassificationApproval) === true,
+                requiresEstimateHours: ((_131 = humanDecisionRequestGate.metadata) === null || _131 === void 0 ? void 0 : _131.requiresEstimateHours) === true
+            } : undefined,
+            postApprovalAutostart: postApprovalAutostartGate ? {
+                gateStatus: postApprovalAutostartGate.status,
+                status: cleanText((_132 = postApprovalAutostartGate.metadata) === null || _132 === void 0 ? void 0 : _132.status, 120),
+                contractStatus: cleanText((_133 = postApprovalAutostartGate.metadata) === null || _133 === void 0 ? void 0 : _133.contractStatus, 120),
+                resultStatus: cleanText((_134 = postApprovalAutostartGate.metadata) === null || _134 === void 0 ? void 0 : _134.resultStatus, 120),
+                failureClass: cleanText((_135 = postApprovalAutostartGate.metadata) === null || _135 === void 0 ? void 0 : _135.failureClass, 120),
+                blockerFingerprint: cleanText((_136 = postApprovalAutostartGate.metadata) === null || _136 === void 0 ? void 0 : _136.blockerFingerprint, 180),
+                blockerReason: cleanText((_137 = postApprovalAutostartGate.metadata) === null || _137 === void 0 ? void 0 : _137.blockerReason, 1200),
+                approvalBoundaryValid: ((_138 = postApprovalAutostartGate.metadata) === null || _138 === void 0 ? void 0 : _138.approvalBoundaryValid) === true,
+                canRetryWithoutReapproval: ((_139 = postApprovalAutostartGate.metadata) === null || _139 === void 0 ? void 0 : _139.canRetryWithoutReapproval) === true,
+                safeRetryAction: cleanText((_140 = postApprovalAutostartGate.metadata) === null || _140 === void 0 ? void 0 : _140.safeRetryAction, 160),
+                resumeContract: plainObject((_141 = postApprovalAutostartGate.metadata) === null || _141 === void 0 ? void 0 : _141.resumeContract),
+                postApprovalResumeContract: plainObject((_142 = postApprovalAutostartGate.metadata) === null || _142 === void 0 ? void 0 : _142.postApprovalResumeContract),
+                started: ((_143 = postApprovalAutostartGate.metadata) === null || _143 === void 0 ? void 0 : _143.started) === true,
+                skipped: ((_144 = postApprovalAutostartGate.metadata) === null || _144 === void 0 ? void 0 : _144.skipped) === true,
+                blocked: ((_145 = postApprovalAutostartGate.metadata) === null || _145 === void 0 ? void 0 : _145.blocked) === true,
+                nextAction: cleanText((_146 = postApprovalAutostartGate.metadata) === null || _146 === void 0 ? void 0 : _146.nextAction, 160),
+                runId: cleanText((_147 = postApprovalAutostartGate.metadata) === null || _147 === void 0 ? void 0 : _147.runId, 180),
+                activeTicketId: cleanText((_148 = postApprovalAutostartGate.metadata) === null || _148 === void 0 ? void 0 : _148.activeTicketId, 180),
+                activeRunId: cleanText((_149 = postApprovalAutostartGate.metadata) === null || _149 === void 0 ? void 0 : _149.activeRunId, 180),
+                error: cleanText((_150 = postApprovalAutostartGate.metadata) === null || _150 === void 0 ? void 0 : _150.error, 1000),
+                contractId: cleanText((_151 = postApprovalAutostartGate.metadata) === null || _151 === void 0 ? void 0 : _151.contractId, 180),
+                recordId: cleanText((_152 = postApprovalAutostartGate.metadata) === null || _152 === void 0 ? void 0 : _152.recordId, 180),
+                approvalContractId: cleanText((_153 = postApprovalAutostartGate.metadata) === null || _153 === void 0 ? void 0 : _153.approvalContractId, 180),
+                scopeFingerprint: cleanText((_154 = postApprovalAutostartGate.metadata) === null || _154 === void 0 ? void 0 : _154.scopeFingerprint, 180),
+                method: cleanText((_155 = postApprovalAutostartGate.metadata) === null || _155 === void 0 ? void 0 : _155.method, 180),
+                autoStartEnabled: ((_156 = postApprovalAutostartGate.metadata) === null || _156 === void 0 ? void 0 : _156.autoStartEnabled) === true,
+                canContinueWithoutCodexMonitor: ((_157 = postApprovalAutostartGate.metadata) === null || _157 === void 0 ? void 0 : _157.canContinueWithoutCodexMonitor) === true,
+                blocksManualCodexMonitoring: ((_158 = postApprovalAutostartGate.metadata) === null || _158 === void 0 ? void 0 : _158.blocksManualCodexMonitoring) === true,
+                terminalTarget: cleanText((_159 = postApprovalAutostartGate.metadata) === null || _159 === void 0 ? void 0 : _159.terminalTarget, 800),
+                targetGrade: cleanText((_160 = postApprovalAutostartGate.metadata) === null || _160 === void 0 ? void 0 : _160.targetGrade, 20),
+                maxIterations: Number(((_161 = postApprovalAutostartGate.metadata) === null || _161 === void 0 ? void 0 : _161.maxIterations) || 0),
+                iterationTimeoutMs: Number(((_162 = postApprovalAutostartGate.metadata) === null || _162 === void 0 ? void 0 : _162.iterationTimeoutMs) || 0),
+                autoCreatePr: ((_163 = postApprovalAutostartGate.metadata) === null || _163 === void 0 ? void 0 : _163.autoCreatePr) === true,
+                forceNewJob: ((_164 = postApprovalAutostartGate.metadata) === null || _164 === void 0 ? void 0 : _164.forceNewJob) === true,
+                forceRestart: ((_165 = postApprovalAutostartGate.metadata) === null || _165 === void 0 ? void 0 : _165.forceRestart) === true,
+                budgetSoftUsd: Number(((_166 = postApprovalAutostartGate.metadata) === null || _166 === void 0 ? void 0 : _166.budgetSoftUsd) || 0),
+                budgetHardUsd: Number(((_167 = postApprovalAutostartGate.metadata) === null || _167 === void 0 ? void 0 : _167.budgetHardUsd) || 0),
+                executionTier: cleanText((_168 = postApprovalAutostartGate.metadata) === null || _168 === void 0 ? void 0 : _168.executionTier, 120),
+                requiredTerminalEvidence: cleanStringList((_169 = postApprovalAutostartGate.metadata) === null || _169 === void 0 ? void 0 : _169.requiredTerminalEvidence, 30, 500),
+                allowedAutoActions: cleanStringList((_170 = postApprovalAutostartGate.metadata) === null || _170 === void 0 ? void 0 : _170.allowedAutoActions, 30, 240),
+                forbiddenWithoutReapproval: cleanStringList((_171 = postApprovalAutostartGate.metadata) === null || _171 === void 0 ? void 0 : _171.forbiddenWithoutReapproval, 30, 500),
+                blockers: cleanStringList((_172 = postApprovalAutostartGate.metadata) === null || _172 === void 0 ? void 0 : _172.blockers, 40, 500)
+            } : undefined,
+            postApprovalResumeAttempt: postApprovalResumeAttemptGate ? {
+                gateStatus: postApprovalResumeAttemptGate.status,
+                status: cleanText((_173 = postApprovalResumeAttemptGate.metadata) === null || _173 === void 0 ? void 0 : _173.status, 120),
+                resultStatus: cleanText((_174 = postApprovalResumeAttemptGate.metadata) === null || _174 === void 0 ? void 0 : _174.resultStatus, 120),
+                failureClass: cleanText((_175 = postApprovalResumeAttemptGate.metadata) === null || _175 === void 0 ? void 0 : _175.failureClass, 120),
+                blockerFingerprint: cleanText((_176 = postApprovalResumeAttemptGate.metadata) === null || _176 === void 0 ? void 0 : _176.blockerFingerprint, 180),
+                blockerReason: cleanText((_177 = postApprovalResumeAttemptGate.metadata) === null || _177 === void 0 ? void 0 : _177.blockerReason, 1200),
+                started: ((_178 = postApprovalResumeAttemptGate.metadata) === null || _178 === void 0 ? void 0 : _178.started) === true,
+                blocked: ((_179 = postApprovalResumeAttemptGate.metadata) === null || _179 === void 0 ? void 0 : _179.blocked) === true,
+                nextAction: cleanText((_180 = postApprovalResumeAttemptGate.metadata) === null || _180 === void 0 ? void 0 : _180.nextAction, 160),
+                runId: cleanText((_181 = postApprovalResumeAttemptGate.metadata) === null || _181 === void 0 ? void 0 : _181.runId, 180),
+                activeTicketId: cleanText((_182 = postApprovalResumeAttemptGate.metadata) === null || _182 === void 0 ? void 0 : _182.activeTicketId, 180),
+                activeRunId: cleanText((_183 = postApprovalResumeAttemptGate.metadata) === null || _183 === void 0 ? void 0 : _183.activeRunId, 180),
+                activeJobId: cleanText((_184 = postApprovalResumeAttemptGate.metadata) === null || _184 === void 0 ? void 0 : _184.activeJobId, 180),
+                error: cleanText((_185 = postApprovalResumeAttemptGate.metadata) === null || _185 === void 0 ? void 0 : _185.error, 1000),
+                attemptId: cleanText((_186 = postApprovalResumeAttemptGate.metadata) === null || _186 === void 0 ? void 0 : _186.attemptId, 180),
+                contractId: cleanText((_187 = postApprovalResumeAttemptGate.metadata) === null || _187 === void 0 ? void 0 : _187.contractId, 180),
+                approvalContractId: cleanText((_188 = postApprovalResumeAttemptGate.metadata) === null || _188 === void 0 ? void 0 : _188.approvalContractId, 180),
+                scopeFingerprint: cleanText((_189 = postApprovalResumeAttemptGate.metadata) === null || _189 === void 0 ? void 0 : _189.scopeFingerprint, 180),
+                resumeContract: plainObject((_190 = postApprovalResumeAttemptGate.metadata) === null || _190 === void 0 ? void 0 : _190.resumeContract),
+                postApprovalResumeContract: plainObject((_191 = postApprovalResumeAttemptGate.metadata) === null || _191 === void 0 ? void 0 : _191.postApprovalResumeContract),
+                startGuardStatus: cleanText((_192 = postApprovalResumeAttemptGate.metadata) === null || _192 === void 0 ? void 0 : _192.startGuardStatus, 120),
+                canContinueWithoutCodexMonitor: ((_193 = postApprovalResumeAttemptGate.metadata) === null || _193 === void 0 ? void 0 : _193.canContinueWithoutCodexMonitor) === true,
+                productRepairAllowed: ((_194 = postApprovalResumeAttemptGate.metadata) === null || _194 === void 0 ? void 0 : _194.productRepairAllowed) === true,
+                canSendCustomerReply: ((_195 = postApprovalResumeAttemptGate.metadata) === null || _195 === void 0 ? void 0 : _195.canSendCustomerReply) === true,
+                blockers: cleanStringList((_196 = postApprovalResumeAttemptGate.metadata) === null || _196 === void 0 ? void 0 : _196.blockers, 40, 500)
+            } : undefined,
+            intakeRevisionContract: intakeRevisionContractGate ? {
+                status: intakeRevisionContractGate.status,
+                contractStatus: cleanText((_197 = intakeRevisionContractGate.metadata) === null || _197 === void 0 ? void 0 : _197.status, 120),
+                contractId: cleanText((_198 = intakeRevisionContractGate.metadata) === null || _198 === void 0 ? void 0 : _198.contractId, 180),
+                requiresReapproval: ((_199 = intakeRevisionContractGate.metadata) === null || _199 === void 0 ? void 0 : _199.requiresReapproval) === true,
+                blocksProductRepair: ((_200 = intakeRevisionContractGate.metadata) === null || _200 === void 0 ? void 0 : _200.blocksProductRepair) === true,
+                blocksAutoRetry: ((_201 = intakeRevisionContractGate.metadata) === null || _201 === void 0 ? void 0 : _201.blocksAutoRetry) === true,
+                requiredOperatorAction: cleanText((_202 = intakeRevisionContractGate.metadata) === null || _202 === void 0 ? void 0 : _202.requiredOperatorAction, 160),
+                previousAutonomyContractId: cleanText((_203 = intakeRevisionContractGate.metadata) === null || _203 === void 0 ? void 0 : _203.previousAutonomyContractId, 180),
+                previousScopeFingerprint: cleanText((_204 = intakeRevisionContractGate.metadata) === null || _204 === void 0 ? void 0 : _204.previousScopeFingerprint, 180),
+                nextScopeFingerprint: cleanText((_205 = intakeRevisionContractGate.metadata) === null || _205 === void 0 ? void 0 : _205.nextScopeFingerprint, 180),
+                intakeScopeFingerprint: cleanText((_206 = intakeRevisionContractGate.metadata) === null || _206 === void 0 ? void 0 : _206.intakeScopeFingerprint, 180),
+                changedFieldNames: cleanStringList((_207 = intakeRevisionContractGate.metadata) === null || _207 === void 0 ? void 0 : _207.changedFieldNames, 40, 120),
+                changedFields: asArray((_208 = intakeRevisionContractGate.metadata) === null || _208 === void 0 ? void 0 : _208.changedFields).map(function (entry) { return ({
+                    field: cleanText(entry.field, 120),
+                    previous: cleanText(entry.previous, 500),
+                    next: cleanText(entry.next, 500)
+                }); }).filter(function (entry) { return entry.field; }),
+                approvalImpactingEditFields: cleanStringList((_209 = intakeRevisionContractGate.metadata) === null || _209 === void 0 ? void 0 : _209.approvalImpactingEditFields, 40, 120),
+                updatedBy: cleanText((_210 = intakeRevisionContractGate.metadata) === null || _210 === void 0 ? void 0 : _210.updatedBy, 160),
+                blockers: cleanStringList((_211 = intakeRevisionContractGate.metadata) === null || _211 === void 0 ? void 0 : _211.blockers, 40, 500)
+            } : undefined,
+            managerContinuation: managerContinuationGate ? {
+                status: managerContinuationGate.status,
+                managerStatus: cleanText((_212 = managerContinuationGate.metadata) === null || _212 === void 0 ? void 0 : _212.managerStatus, 120),
+                continuationContractId: cleanText((_213 = managerContinuationGate.metadata) === null || _213 === void 0 ? void 0 : _213.continuationContractId, 180),
+                continuationStatus: cleanText((_214 = managerContinuationGate.metadata) === null || _214 === void 0 ? void 0 : _214.continuationStatus, 120),
+                action: cleanText((_215 = managerContinuationGate.metadata) === null || _215 === void 0 ? void 0 : _215.action, 180),
+                requiredStateTransition: cleanText((_216 = managerContinuationGate.metadata) === null || _216 === void 0 ? void 0 : _216.requiredStateTransition, 1000),
+                operatorGuidanceResponseId: cleanText((_217 = managerContinuationGate.metadata) === null || _217 === void 0 ? void 0 : _217.operatorGuidanceResponseId, 180),
+                operatorGuidanceAccepted: ((_218 = managerContinuationGate.metadata) === null || _218 === void 0 ? void 0 : _218.operatorGuidanceAccepted) === true,
+                operatorGuidanceConsumed: ((_219 = managerContinuationGate.metadata) === null || _219 === void 0 ? void 0 : _219.operatorGuidanceConsumed) === true,
+                resumeUnblockContractId: cleanText((_220 = managerContinuationGate.metadata) === null || _220 === void 0 ? void 0 : _220.resumeUnblockContractId, 180),
+                resumeUnblockAction: cleanText((_221 = managerContinuationGate.metadata) === null || _221 === void 0 ? void 0 : _221.resumeUnblockAction, 180),
+                resumeDispatchStatus: cleanText((_222 = managerContinuationGate.metadata) === null || _222 === void 0 ? void 0 : _222.resumeDispatchStatus, 120),
+                resumeDispatchJobId: cleanText((_223 = managerContinuationGate.metadata) === null || _223 === void 0 ? void 0 : _223.resumeDispatchJobId, 180),
+                canRunWithoutCodexMonitor: ((_224 = managerContinuationGate.metadata) === null || _224 === void 0 ? void 0 : _224.canRunWithoutCodexMonitor) === true,
+                safeToAutoRunAfterInput: ((_225 = managerContinuationGate.metadata) === null || _225 === void 0 ? void 0 : _225.safeToAutoRunAfterInput) === true,
+                blocksProductRepairUntilChangedEvidence: ((_226 = managerContinuationGate.metadata) === null || _226 === void 0 ? void 0 : _226.blocksProductRepairUntilChangedEvidence) === true,
+                proofRequiredBeforeContinuation: ((_227 = managerContinuationGate.metadata) === null || _227 === void 0 ? void 0 : _227.proofRequiredBeforeContinuation) === true,
+                allowedAfterInput: cleanStringList((_228 = managerContinuationGate.metadata) === null || _228 === void 0 ? void 0 : _228.allowedAfterInput, 20, 240),
+                materialEvidenceClaimed: ((_229 = managerContinuationGate.metadata) === null || _229 === void 0 ? void 0 : _229.materialEvidenceClaimed) === true,
+                materialEvidenceSignals: cleanStringList((_230 = managerContinuationGate.metadata) === null || _230 === void 0 ? void 0 : _230.materialEvidenceSignals, 20, 240),
+                artifactPaths: cleanStringList((_231 = managerContinuationGate.metadata) === null || _231 === void 0 ? void 0 : _231.artifactPaths, 60, 500),
+                blockers: cleanStringList((_232 = managerContinuationGate.metadata) === null || _232 === void 0 ? void 0 : _232.blockers, 40, 500)
+            } : undefined,
+            prReadinessContract: prReadinessContractGate ? {
+                status: prReadinessContractGate.status,
+                ready: ((_233 = prReadinessContractGate.metadata) === null || _233 === void 0 ? void 0 : _233.ready) === true,
+                contractId: cleanText((_234 = prReadinessContractGate.metadata) === null || _234 === void 0 ? void 0 : _234.contractId, 180),
+                action: cleanText((_235 = prReadinessContractGate.metadata) === null || _235 === void 0 ? void 0 : _235.action, 120),
+                dispatchAction: cleanText((_236 = prReadinessContractGate.metadata) === null || _236 === void 0 ? void 0 : _236.dispatchAction, 120),
+                method: cleanText((_237 = prReadinessContractGate.metadata) === null || _237 === void 0 ? void 0 : _237.method, 180),
+                businessProofReady: ((_238 = prReadinessContractGate.metadata) === null || _238 === void 0 ? void 0 : _238.businessProofReady) === true,
+                diagnosisValid: ((_239 = prReadinessContractGate.metadata) === null || _239 === void 0 ? void 0 : _239.diagnosisValid) === true,
+                pullRequestUrl: cleanText((_240 = prReadinessContractGate.metadata) === null || _240 === void 0 ? void 0 : _240.pullRequestUrl, 500),
+                pullRequestStatus: cleanText((_241 = prReadinessContractGate.metadata) === null || _241 === void 0 ? void 0 : _241.pullRequestStatus, 120),
+                prFailureStatus: cleanText((_242 = prReadinessContractGate.metadata) === null || _242 === void 0 ? void 0 : _242.prFailureStatus, 120),
+                passedBusinessAssertionCount: Number(((_243 = prReadinessContractGate.metadata) === null || _243 === void 0 ? void 0 : _243.passedBusinessAssertionCount) || 0),
+                targetGrade: cleanText((_244 = prReadinessContractGate.metadata) === null || _244 === void 0 ? void 0 : _244.targetGrade, 20),
+                mergeBlockedUntilHumanApproval: ((_245 = prReadinessContractGate.metadata) === null || _245 === void 0 ? void 0 : _245.mergeBlockedUntilHumanApproval) === true,
+                customerReplyBlockedUntilReleaseGate: ((_246 = prReadinessContractGate.metadata) === null || _246 === void 0 ? void 0 : _246.customerReplyBlockedUntilReleaseGate) === true,
+                releaseBlockedUntilPrReview: ((_247 = prReadinessContractGate.metadata) === null || _247 === void 0 ? void 0 : _247.releaseBlockedUntilPrReview) === true,
+                businessProofArtifacts: cleanStringList((_248 = prReadinessContractGate.metadata) === null || _248 === void 0 ? void 0 : _248.businessProofArtifacts, 80, 500),
+                modifiedFiles: cleanStringList((_249 = prReadinessContractGate.metadata) === null || _249 === void 0 ? void 0 : _249.modifiedFiles, 120, 500),
+                requiredEvidence: cleanStringList((_250 = prReadinessContractGate.metadata) === null || _250 === void 0 ? void 0 : _250.requiredEvidence, 40, 500),
+                blockers: cleanStringList((_251 = prReadinessContractGate.metadata) === null || _251 === void 0 ? void 0 : _251.blockers, 50, 500)
+            } : undefined,
+            prReviewContract: prReviewContractGate ? {
+                status: prReviewContractGate.status,
+                ready: ((_252 = prReviewContractGate.metadata) === null || _252 === void 0 ? void 0 : _252.ready) === true,
+                contractId: cleanText((_253 = prReviewContractGate.metadata) === null || _253 === void 0 ? void 0 : _253.contractId, 180),
+                strictGatePassed: ((_254 = prReviewContractGate.metadata) === null || _254 === void 0 ? void 0 : _254.strictGatePassed) === true,
+                strictGateReason: cleanText((_255 = prReviewContractGate.metadata) === null || _255 === void 0 ? void 0 : _255.strictGateReason, 500),
+                executionGrade: cleanText((_256 = prReviewContractGate.metadata) === null || _256 === void 0 ? void 0 : _256.executionGrade, 20),
+                artifactsGrade: cleanText((_257 = prReviewContractGate.metadata) === null || _257 === void 0 ? void 0 : _257.artifactsGrade, 20),
+                pullRequestGrade: cleanText((_258 = prReviewContractGate.metadata) === null || _258 === void 0 ? void 0 : _258.pullRequestGrade, 20),
+                targetGrade: cleanText((_259 = prReviewContractGate.metadata) === null || _259 === void 0 ? void 0 : _259.targetGrade, 20),
+                pullRequestUrl: cleanText((_260 = prReviewContractGate.metadata) === null || _260 === void 0 ? void 0 : _260.pullRequestUrl, 500),
+                pullRequestStatus: cleanText((_261 = prReviewContractGate.metadata) === null || _261 === void 0 ? void 0 : _261.pullRequestStatus, 120),
+                failureClass: cleanText((_262 = prReviewContractGate.metadata) === null || _262 === void 0 ? void 0 : _262.failureClass, 120),
+                blockerFingerprint: cleanText((_263 = prReviewContractGate.metadata) === null || _263 === void 0 ? void 0 : _263.blockerFingerprint, 180),
+                evidenceHash: cleanText((_264 = prReviewContractGate.metadata) === null || _264 === void 0 ? void 0 : _264.evidenceHash, 180),
+                continuationContract: (_265 = prReviewContractGate.metadata) === null || _265 === void 0 ? void 0 : _265.continuationContract,
+                nextAction: cleanText((_266 = prReviewContractGate.metadata) === null || _266 === void 0 ? void 0 : _266.nextAction, 160),
+                requiredEvidence: cleanStringList((_267 = prReviewContractGate.metadata) === null || _267 === void 0 ? void 0 : _267.requiredEvidence, 40, 500),
+                evidenceRefs: cleanStringList((_268 = prReviewContractGate.metadata) === null || _268 === void 0 ? void 0 : _268.evidenceRefs, 80, 500),
+                blockers: cleanStringList((_269 = prReviewContractGate.metadata) === null || _269 === void 0 ? void 0 : _269.blockers, 50, 500)
+            } : undefined,
+            prCreationResult: prCreationResultGate ? {
+                status: prCreationResultGate.status,
+                resultStatus: cleanText((_270 = prCreationResultGate.metadata) === null || _270 === void 0 ? void 0 : _270.status, 120),
+                pullRequestUrl: cleanText((_271 = prCreationResultGate.metadata) === null || _271 === void 0 ? void 0 : _271.pullRequestUrl, 500),
+                pullRequestStatus: cleanText((_272 = prCreationResultGate.metadata) === null || _272 === void 0 ? void 0 : _272.pullRequestStatus, 120),
+                prFailureStatus: cleanText((_273 = prCreationResultGate.metadata) === null || _273 === void 0 ? void 0 : _273.prFailureStatus, 120),
+                error: cleanText((_274 = prCreationResultGate.metadata) === null || _274 === void 0 ? void 0 : _274.error, 1000),
+                jobId: cleanText((_275 = prCreationResultGate.metadata) === null || _275 === void 0 ? void 0 : _275.jobId, 180),
+                method: cleanText((_276 = prCreationResultGate.metadata) === null || _276 === void 0 ? void 0 : _276.method, 180),
+                prReadinessContractId: cleanText((_277 = prCreationResultGate.metadata) === null || _277 === void 0 ? void 0 : _277.prReadinessContractId, 180),
+                releasePushMasterStatus: cleanText((_278 = prCreationResultGate.metadata) === null || _278 === void 0 ? void 0 : _278.releasePushMasterStatus, 120),
+                modifiedFiles: cleanStringList((_279 = prCreationResultGate.metadata) === null || _279 === void 0 ? void 0 : _279.modifiedFiles, 120, 500),
+                businessProofReady: ((_280 = prCreationResultGate.metadata) === null || _280 === void 0 ? void 0 : _280.businessProofReady) === true,
+                diagnosisValid: ((_281 = prCreationResultGate.metadata) === null || _281 === void 0 ? void 0 : _281.diagnosisValid) === true,
+                mergeBlockedUntilHumanApproval: ((_282 = prCreationResultGate.metadata) === null || _282 === void 0 ? void 0 : _282.mergeBlockedUntilHumanApproval) === true,
+                customerReplyBlockedUntilReleaseGate: ((_283 = prCreationResultGate.metadata) === null || _283 === void 0 ? void 0 : _283.customerReplyBlockedUntilReleaseGate) === true,
+                releaseBlockedUntilPrReview: ((_284 = prCreationResultGate.metadata) === null || _284 === void 0 ? void 0 : _284.releaseBlockedUntilPrReview) === true,
+                nextAction: cleanText((_285 = prCreationResultGate.metadata) === null || _285 === void 0 ? void 0 : _285.nextAction, 160)
+            } : undefined,
+            autopilotCompletion: autopilotCompletionGate ? {
+                status: autopilotCompletionGate.status,
+                completionStatus: cleanText((_286 = autopilotCompletionGate.metadata) === null || _286 === void 0 ? void 0 : _286.status, 120),
+                nextAction: cleanText((_287 = autopilotCompletionGate.metadata) === null || _287 === void 0 ? void 0 : _287.nextAction, 160),
+                targetGrade: cleanText((_288 = autopilotCompletionGate.metadata) === null || _288 === void 0 ? void 0 : _288.targetGrade, 20),
+                businessProofReady: ((_289 = autopilotCompletionGate.metadata) === null || _289 === void 0 ? void 0 : _289.businessProofReady) === true,
+                prReady: ((_290 = autopilotCompletionGate.metadata) === null || _290 === void 0 ? void 0 : _290.prReady) === true,
+                pullRequestUrl: cleanText((_291 = autopilotCompletionGate.metadata) === null || _291 === void 0 ? void 0 : _291.pullRequestUrl, 500),
+                pullRequestStatus: cleanText((_292 = autopilotCompletionGate.metadata) === null || _292 === void 0 ? void 0 : _292.pullRequestStatus, 120),
+                prReviewReady: ((_293 = autopilotCompletionGate.metadata) === null || _293 === void 0 ? void 0 : _293.prReviewReady) === true,
+                prReviewStatus: cleanText((_294 = autopilotCompletionGate.metadata) === null || _294 === void 0 ? void 0 : _294.prReviewStatus, 120),
+                prReviewContractId: cleanText((_295 = autopilotCompletionGate.metadata) === null || _295 === void 0 ? void 0 : _295.prReviewContractId, 180),
+                prReviewStrictGatePassed: ((_296 = autopilotCompletionGate.metadata) === null || _296 === void 0 ? void 0 : _296.prReviewStrictGatePassed) === true,
+                prReviewStrictGateReason: cleanText((_297 = autopilotCompletionGate.metadata) === null || _297 === void 0 ? void 0 : _297.prReviewStrictGateReason, 500),
+                prReviewExecutionGrade: cleanText((_298 = autopilotCompletionGate.metadata) === null || _298 === void 0 ? void 0 : _298.prReviewExecutionGrade, 20),
+                prReviewArtifactsGrade: cleanText((_299 = autopilotCompletionGate.metadata) === null || _299 === void 0 ? void 0 : _299.prReviewArtifactsGrade, 20),
+                prReviewPullRequestGrade: cleanText((_300 = autopilotCompletionGate.metadata) === null || _300 === void 0 ? void 0 : _300.prReviewPullRequestGrade, 20),
+                qaScreenshotsRequired: ((_301 = autopilotCompletionGate.metadata) === null || _301 === void 0 ? void 0 : _301.qaScreenshotsRequired) === true,
+                beforeActionAfterBusinessProofRequired: ((_302 = autopilotCompletionGate.metadata) === null || _302 === void 0 ? void 0 : _302.beforeActionAfterBusinessProofRequired) === true,
+                aiqaBusinessAssertionRequired: ((_303 = autopilotCompletionGate.metadata) === null || _303 === void 0 ? void 0 : _303.aiqaBusinessAssertionRequired) === true,
+                hasScreenshotOrTrace: ((_304 = autopilotCompletionGate.metadata) === null || _304 === void 0 ? void 0 : _304.hasScreenshotOrTrace) === true,
+                businessProofArtifacts: cleanStringList((_305 = autopilotCompletionGate.metadata) === null || _305 === void 0 ? void 0 : _305.businessProofArtifacts, 80, 500),
+                modifiedFiles: cleanStringList((_306 = autopilotCompletionGate.metadata) === null || _306 === void 0 ? void 0 : _306.modifiedFiles, 120, 500),
+                requiredCompletionEvidence: cleanStringList((_307 = autopilotCompletionGate.metadata) === null || _307 === void 0 ? void 0 : _307.requiredCompletionEvidence, 50, 500),
+                missingCompletionEvidence: cleanStringList((_308 = autopilotCompletionGate.metadata) === null || _308 === void 0 ? void 0 : _308.missingCompletionEvidence, 50, 500),
+                mergeBlockedUntilHumanApproval: ((_309 = autopilotCompletionGate.metadata) === null || _309 === void 0 ? void 0 : _309.mergeBlockedUntilHumanApproval) === true,
+                customerReplyBlockedUntilReleaseGate: ((_310 = autopilotCompletionGate.metadata) === null || _310 === void 0 ? void 0 : _310.customerReplyBlockedUntilReleaseGate) === true,
+                releaseBlockedUntilPrReview: ((_311 = autopilotCompletionGate.metadata) === null || _311 === void 0 ? void 0 : _311.releaseBlockedUntilPrReview) === true
+            } : undefined,
+            releaseCustomerAcceptance: releaseCustomerAcceptanceGate ? {
+                status: releaseCustomerAcceptanceGate.status,
+                required: ((_312 = releaseCustomerAcceptanceGate.metadata) === null || _312 === void 0 ? void 0 : _312.required) === true,
+                nextAction: cleanText((_313 = releaseCustomerAcceptanceGate.metadata) === null || _313 === void 0 ? void 0 : _313.nextAction, 160),
+                pullRequestUrl: cleanText((_314 = releaseCustomerAcceptanceGate.metadata) === null || _314 === void 0 ? void 0 : _314.pullRequestUrl, 500),
+                releasePullRequestUrl: cleanText((_315 = releaseCustomerAcceptanceGate.metadata) === null || _315 === void 0 ? void 0 : _315.releasePullRequestUrl, 500),
+                deployPullRequestUrl: cleanText((_316 = releaseCustomerAcceptanceGate.metadata) === null || _316 === void 0 ? void 0 : _316.deployPullRequestUrl, 500),
+                replyPullRequestUrl: cleanText((_317 = releaseCustomerAcceptanceGate.metadata) === null || _317 === void 0 ? void 0 : _317.replyPullRequestUrl, 500),
+                prReady: ((_318 = releaseCustomerAcceptanceGate.metadata) === null || _318 === void 0 ? void 0 : _318.prReady) === true,
+                pushMasterStatus: cleanText((_319 = releaseCustomerAcceptanceGate.metadata) === null || _319 === void 0 ? void 0 : _319.pushMasterStatus, 120),
+                deployProductionStatus: cleanText((_320 = releaseCustomerAcceptanceGate.metadata) === null || _320 === void 0 ? void 0 : _320.deployProductionStatus, 120),
+                hotfixReleaseGateStatus: cleanText((_321 = releaseCustomerAcceptanceGate.metadata) === null || _321 === void 0 ? void 0 : _321.hotfixReleaseGateStatus, 120),
+                releasePrMatchesCurrent: ((_322 = releaseCustomerAcceptanceGate.metadata) === null || _322 === void 0 ? void 0 : _322.releasePrMatchesCurrent) === true,
+                deployPrMatchesCurrent: ((_323 = releaseCustomerAcceptanceGate.metadata) === null || _323 === void 0 ? void 0 : _323.deployPrMatchesCurrent) === true,
+                replyPrReferencePresent: ((_324 = releaseCustomerAcceptanceGate.metadata) === null || _324 === void 0 ? void 0 : _324.replyPrReferencePresent) === true,
+                replyPrMatchesCurrent: ((_325 = releaseCustomerAcceptanceGate.metadata) === null || _325 === void 0 ? void 0 : _325.replyPrMatchesCurrent) === true,
+                pushMasterComplete: ((_326 = releaseCustomerAcceptanceGate.metadata) === null || _326 === void 0 ? void 0 : _326.pushMasterComplete) === true,
+                productionDeployComplete: ((_327 = releaseCustomerAcceptanceGate.metadata) === null || _327 === void 0 ? void 0 : _327.productionDeployComplete) === true,
+                productionDeployNotRequired: ((_328 = releaseCustomerAcceptanceGate.metadata) === null || _328 === void 0 ? void 0 : _328.productionDeployNotRequired) === true,
+                hotfixReleaseGatePassed: ((_329 = releaseCustomerAcceptanceGate.metadata) === null || _329 === void 0 ? void 0 : _329.hotfixReleaseGatePassed) === true,
+                releaseReady: ((_330 = releaseCustomerAcceptanceGate.metadata) === null || _330 === void 0 ? void 0 : _330.releaseReady) === true,
+                customerReplyReady: ((_331 = releaseCustomerAcceptanceGate.metadata) === null || _331 === void 0 ? void 0 : _331.customerReplyReady) === true,
+                customerReplyReadinessStatus: cleanText((_332 = releaseCustomerAcceptanceGate.metadata) === null || _332 === void 0 ? void 0 : _332.customerReplyReadinessStatus, 120),
+                proofBackedSendStatus: cleanText((_333 = releaseCustomerAcceptanceGate.metadata) === null || _333 === void 0 ? void 0 : _333.proofBackedSendStatus, 120),
+                proofBackedSendRecorded: ((_334 = releaseCustomerAcceptanceGate.metadata) === null || _334 === void 0 ? void 0 : _334.proofBackedSendRecorded) === true,
+                sendGuardReady: ((_335 = releaseCustomerAcceptanceGate.metadata) === null || _335 === void 0 ? void 0 : _335.sendGuardReady) === true,
+                replyDraftReady: ((_336 = releaseCustomerAcceptanceGate.metadata) === null || _336 === void 0 ? void 0 : _336.replyDraftReady) === true,
+                customerReplyRequiresHumanApproval: ((_337 = releaseCustomerAcceptanceGate.metadata) === null || _337 === void 0 ? void 0 : _337.customerReplyRequiresHumanApproval) === true,
+                blockers: cleanStringList((_338 = releaseCustomerAcceptanceGate.metadata) === null || _338 === void 0 ? void 0 : _338.blockers, 20, 500)
+            } : undefined,
+            evidenceProbeContract: evidenceProbeContractGate ? {
+                status: evidenceProbeContractGate.status,
+                contractId: cleanText((_339 = evidenceProbeContractGate.metadata) === null || _339 === void 0 ? void 0 : _339.contractId, 200),
+                contractStatus: cleanText((_340 = evidenceProbeContractGate.metadata) === null || _340 === void 0 ? void 0 : _340.status, 120),
+                probeType: cleanText((_341 = evidenceProbeContractGate.metadata) === null || _341 === void 0 ? void 0 : _341.probeType, 120),
+                evidenceOnly: ((_342 = evidenceProbeContractGate.metadata) === null || _342 === void 0 ? void 0 : _342.evidenceOnly) === true,
+                productRepairAllowed: ((_343 = evidenceProbeContractGate.metadata) === null || _343 === void 0 ? void 0 : _343.productRepairAllowed) === true,
+                canRunWithoutCodexMonitor: ((_344 = evidenceProbeContractGate.metadata) === null || _344 === void 0 ? void 0 : _344.canRunWithoutCodexMonitor) === true,
+                issueClass: cleanText((_345 = evidenceProbeContractGate.metadata) === null || _345 === void 0 ? void 0 : _345.issueClass, 120),
+                planId: cleanText((_346 = evidenceProbeContractGate.metadata) === null || _346 === void 0 ? void 0 : _346.planId, 200),
+                activeRoute: cleanText((_347 = evidenceProbeContractGate.metadata) === null || _347 === void 0 ? void 0 : _347.activeRoute, 500),
+                actionUnderTest: cleanText((_348 = evidenceProbeContractGate.metadata) === null || _348 === void 0 ? void 0 : _348.actionUnderTest, 1000),
+                expectedBusinessProof: cleanText((_349 = evidenceProbeContractGate.metadata) === null || _349 === void 0 ? void 0 : _349.expectedBusinessProof, 1200),
+                startingFailureClass: cleanText((_350 = evidenceProbeContractGate.metadata) === null || _350 === void 0 ? void 0 : _350.startingFailureClass, 120),
+                startingEvidenceHash: cleanText((_351 = evidenceProbeContractGate.metadata) === null || _351 === void 0 ? void 0 : _351.startingEvidenceHash, 200),
+                sameFailureCount: Number(((_352 = evidenceProbeContractGate.metadata) === null || _352 === void 0 ? void 0 : _352.sameFailureCount) || 0),
+                requiredNewSignals: cleanStringList((_353 = evidenceProbeContractGate.metadata) === null || _353 === void 0 ? void 0 : _353.requiredNewSignals, 20, 500),
+                requiredArtifacts: cleanStringList((_354 = evidenceProbeContractGate.metadata) === null || _354 === void 0 ? void 0 : _354.requiredArtifacts, 20, 500),
+                acceptableEvidence: cleanStringList((_355 = evidenceProbeContractGate.metadata) === null || _355 === void 0 ? void 0 : _355.acceptableEvidence, 20, 500),
+                nextCommands: cleanStringList((_356 = evidenceProbeContractGate.metadata) === null || _356 === void 0 ? void 0 : _356.nextCommands, 20, 300),
+                blockers: cleanStringList((_357 = evidenceProbeContractGate.metadata) === null || _357 === void 0 ? void 0 : _357.blockers, 20, 500)
+            } : undefined,
             diagnosisBeforeRepair: diagnosisBeforeRepairGate ? {
                 status: diagnosisBeforeRepairGate.status,
-                diagnosisValid: ((_f = diagnosisBeforeRepairGate.metadata) === null || _f === void 0 ? void 0 : _f.diagnosisValid) === true,
-                diagnosisStatus: cleanText((_g = diagnosisBeforeRepairGate.metadata) === null || _g === void 0 ? void 0 : _g.diagnosisStatus, 120),
-                activityCount: Number(((_h = diagnosisBeforeRepairGate.metadata) === null || _h === void 0 ? void 0 : _h.activityCount) || 0),
-                changedFiles: cleanStringList((_j = diagnosisBeforeRepairGate.metadata) === null || _j === void 0 ? void 0 : _j.changedFiles, 40, 500),
-                allowedDispatchAction: cleanText((_k = diagnosisBeforeRepairGate.metadata) === null || _k === void 0 ? void 0 : _k.allowedDispatchAction, 160),
-                productRepairAllowed: ((_l = diagnosisBeforeRepairGate.metadata) === null || _l === void 0 ? void 0 : _l.productRepairAllowed) === true,
-                blockers: cleanStringList((_m = diagnosisBeforeRepairGate.metadata) === null || _m === void 0 ? void 0 : _m.blockers, 20, 500)
+                diagnosisValid: ((_358 = diagnosisBeforeRepairGate.metadata) === null || _358 === void 0 ? void 0 : _358.diagnosisValid) === true,
+                diagnosisStatus: cleanText((_359 = diagnosisBeforeRepairGate.metadata) === null || _359 === void 0 ? void 0 : _359.diagnosisStatus, 120),
+                activityCount: Number(((_360 = diagnosisBeforeRepairGate.metadata) === null || _360 === void 0 ? void 0 : _360.activityCount) || 0),
+                changedFiles: cleanStringList((_361 = diagnosisBeforeRepairGate.metadata) === null || _361 === void 0 ? void 0 : _361.changedFiles, 40, 500),
+                allowedDispatchAction: cleanText((_362 = diagnosisBeforeRepairGate.metadata) === null || _362 === void 0 ? void 0 : _362.allowedDispatchAction, 160),
+                productRepairAllowed: ((_363 = diagnosisBeforeRepairGate.metadata) === null || _363 === void 0 ? void 0 : _363.productRepairAllowed) === true,
+                blockers: cleanStringList((_364 = diagnosisBeforeRepairGate.metadata) === null || _364 === void 0 ? void 0 : _364.blockers, 20, 500)
             } : undefined,
             ownerFileScope: ownerFileScopeGate ? {
                 status: ownerFileScopeGate.status,
-                productRepairAllowed: ((_o = ownerFileScopeGate.metadata) === null || _o === void 0 ? void 0 : _o.productRepairAllowed) === true,
-                allowedDispatchAction: cleanText((_p = ownerFileScopeGate.metadata) === null || _p === void 0 ? void 0 : _p.allowedDispatchAction, 160),
-                ownerFiles: cleanStringList((_q = ownerFileScopeGate.metadata) === null || _q === void 0 ? void 0 : _q.ownerFiles, 40, 500),
-                changedFiles: cleanStringList((_r = ownerFileScopeGate.metadata) === null || _r === void 0 ? void 0 : _r.changedFiles, 60, 500),
-                outsideOwnerFiles: cleanStringList((_s = ownerFileScopeGate.metadata) === null || _s === void 0 ? void 0 : _s.outsideOwnerFiles, 40, 500),
-                allowedTestFilesOutsideOwnerScope: ((_t = ownerFileScopeGate.metadata) === null || _t === void 0 ? void 0 : _t.allowedTestFilesOutsideOwnerScope) === true,
-                requiredEvidence: cleanStringList((_u = ownerFileScopeGate.metadata) === null || _u === void 0 ? void 0 : _u.requiredEvidence, 20, 500)
+                productRepairAllowed: ((_365 = ownerFileScopeGate.metadata) === null || _365 === void 0 ? void 0 : _365.productRepairAllowed) === true,
+                allowedDispatchAction: cleanText((_366 = ownerFileScopeGate.metadata) === null || _366 === void 0 ? void 0 : _366.allowedDispatchAction, 160),
+                ownerFiles: cleanStringList((_367 = ownerFileScopeGate.metadata) === null || _367 === void 0 ? void 0 : _367.ownerFiles, 40, 500),
+                changedFiles: cleanStringList((_368 = ownerFileScopeGate.metadata) === null || _368 === void 0 ? void 0 : _368.changedFiles, 60, 500),
+                outsideOwnerFiles: cleanStringList((_369 = ownerFileScopeGate.metadata) === null || _369 === void 0 ? void 0 : _369.outsideOwnerFiles, 40, 500),
+                allowedTestFilesOutsideOwnerScope: ((_370 = ownerFileScopeGate.metadata) === null || _370 === void 0 ? void 0 : _370.allowedTestFilesOutsideOwnerScope) === true,
+                requiredEvidence: cleanStringList((_371 = ownerFileScopeGate.metadata) === null || _371 === void 0 ? void 0 : _371.requiredEvidence, 20, 500)
             } : undefined,
             rootCauseEntryContract: Object.keys(rootCauseEntryContract).length ? {
                 contractId: cleanText(rootCauseEntryContract.contract_id || rootCauseEntryContract.contractId, 160),
                 version: cleanText(rootCauseEntryContract.version, 120),
                 status: cleanText(rootCauseEntryContract.status, 120),
                 issueClassProbeCount: asArray(rootCauseEntryContract.issue_class_probes || rootCauseEntryContract.issueClassProbes).length,
-                ownerFileMax: Number(((_v = rootCauseEntryContract.owner_file_policy) === null || _v === void 0 ? void 0 : _v.max_files) || ((_w = rootCauseEntryContract.ownerFilePolicy) === null || _w === void 0 ? void 0 : _w.maxFiles) || 0) || 0,
-                requiresBusinessAssertion: ((_x = rootCauseEntryContract.business_proof_policy) === null || _x === void 0 ? void 0 : _x.requires_aiqa_business_assertion) === true
-                    || ((_y = rootCauseEntryContract.businessProofPolicy) === null || _y === void 0 ? void 0 : _y.requiresAiqaBusinessAssertion) === true
+                ownerFileMax: Number(((_372 = rootCauseEntryContract.owner_file_policy) === null || _372 === void 0 ? void 0 : _372.max_files) || ((_373 = rootCauseEntryContract.ownerFilePolicy) === null || _373 === void 0 ? void 0 : _373.maxFiles) || 0) || 0,
+                requiresBusinessAssertion: ((_374 = rootCauseEntryContract.business_proof_policy) === null || _374 === void 0 ? void 0 : _374.requires_aiqa_business_assertion) === true
+                    || ((_375 = rootCauseEntryContract.businessProofPolicy) === null || _375 === void 0 ? void 0 : _375.requiresAiqaBusinessAssertion) === true
             } : undefined,
             diagnosis: Object.keys(diagnosisGate).length ? {
                 status: cleanText(diagnosisGate.status, 80),
                 issueClass: diagnosisIssueClass,
                 ownerFiles: diagnosisOwnerFiles,
-                acceptedHypothesis: cleanText(((_z = diagnosisGate.accepted_hypothesis) === null || _z === void 0 ? void 0 : _z.statement) || ((_0 = diagnosisGate.acceptedHypothesis) === null || _0 === void 0 ? void 0 : _0.statement), 1000),
-                proofPlan: diagnosisGate.proof_plan || diagnosisGate.proofPlan
+                acceptedHypothesis: cleanText(((_376 = diagnosisGate.accepted_hypothesis) === null || _376 === void 0 ? void 0 : _376.statement) || ((_377 = diagnosisGate.acceptedHypothesis) === null || _377 === void 0 ? void 0 : _377.statement), 1000),
+                proofPlan: diagnosisGate.proof_plan || diagnosisGate.proofPlan,
+                proofMatrixId: cleanText((_378 = diagnosisProofMatrixGate === null || diagnosisProofMatrixGate === void 0 ? void 0 : diagnosisProofMatrixGate.metadata) === null || _378 === void 0 ? void 0 : _378.matrixId, 180),
+                proofMatrixStatus: cleanText((_379 = diagnosisProofMatrixGate === null || diagnosisProofMatrixGate === void 0 ? void 0 : diagnosisProofMatrixGate.metadata) === null || _379 === void 0 ? void 0 : _379.status, 120)
+            } : undefined,
+            diagnosisProofMatrix: diagnosisProofMatrixGate ? {
+                status: diagnosisProofMatrixGate.status,
+                matrixId: cleanText((_380 = diagnosisProofMatrixGate.metadata) === null || _380 === void 0 ? void 0 : _380.matrixId, 180),
+                matrixStatus: cleanText((_381 = diagnosisProofMatrixGate.metadata) === null || _381 === void 0 ? void 0 : _381.status, 120),
+                issueClass: cleanText((_382 = diagnosisProofMatrixGate.metadata) === null || _382 === void 0 ? void 0 : _382.issueClass, 120),
+                ownerFiles: cleanStringList((_383 = diagnosisProofMatrixGate.metadata) === null || _383 === void 0 ? void 0 : _383.ownerFiles, 40, 500),
+                uncoveredOwnerFiles: cleanStringList((_384 = diagnosisProofMatrixGate.metadata) === null || _384 === void 0 ? void 0 : _384.uncoveredOwnerFiles, 40, 500),
+                reproductionEvidenceCount: Number(((_385 = diagnosisProofMatrixGate.metadata) === null || _385 === void 0 ? void 0 : _385.reproductionEvidenceCount) || 0),
+                rootCauseEvidenceCount: Number(((_386 = diagnosisProofMatrixGate.metadata) === null || _386 === void 0 ? void 0 : _386.rootCauseEvidenceCount) || 0),
+                businessProofArtifacts: cleanStringList((_387 = diagnosisProofMatrixGate.metadata) === null || _387 === void 0 ? void 0 : _387.businessProofArtifacts, 40, 500),
+                blockers: cleanStringList((_388 = diagnosisProofMatrixGate.metadata) === null || _388 === void 0 ? void 0 : _388.blockers, 40, 500)
+            } : undefined,
+            ownerScopedRepairContract: ownerScopedRepairContractGate ? {
+                status: ownerScopedRepairContractGate.status,
+                contractId: cleanText((_389 = ownerScopedRepairContractGate.metadata) === null || _389 === void 0 ? void 0 : _389.contractId, 180),
+                contractStatus: cleanText((_390 = ownerScopedRepairContractGate.metadata) === null || _390 === void 0 ? void 0 : _390.status, 120),
+                sourceEditsAllowed: ((_391 = ownerScopedRepairContractGate.metadata) === null || _391 === void 0 ? void 0 : _391.sourceEditsAllowed) === true,
+                canRunWithoutCodexMonitor: ((_392 = ownerScopedRepairContractGate.metadata) === null || _392 === void 0 ? void 0 : _392.canRunWithoutCodexMonitor) === true,
+                issueClass: cleanText((_393 = ownerScopedRepairContractGate.metadata) === null || _393 === void 0 ? void 0 : _393.issueClass, 120),
+                ownerFiles: cleanStringList((_394 = ownerScopedRepairContractGate.metadata) === null || _394 === void 0 ? void 0 : _394.ownerFiles, 40, 500),
+                proofMatrixId: cleanText((_395 = ownerScopedRepairContractGate.metadata) === null || _395 === void 0 ? void 0 : _395.proofMatrixId, 180),
+                changedFiles: cleanStringList((_396 = ownerScopedRepairContractGate.metadata) === null || _396 === void 0 ? void 0 : _396.changedFiles, 60, 500),
+                outsideOwnerFiles: cleanStringList((_397 = ownerScopedRepairContractGate.metadata) === null || _397 === void 0 ? void 0 : _397.outsideOwnerFiles, 40, 500),
+                patchUnitCount: Number(((_398 = ownerScopedRepairContractGate.metadata) === null || _398 === void 0 ? void 0 : _398.patchUnitCount) || 0),
+                requiredEvidenceAfterRepair: cleanStringList((_399 = ownerScopedRepairContractGate.metadata) === null || _399 === void 0 ? void 0 : _399.requiredEvidenceAfterRepair, 30, 500),
+                blockers: cleanStringList((_400 = ownerScopedRepairContractGate.metadata) === null || _400 === void 0 ? void 0 : _400.blockers, 40, 500)
             } : undefined,
             diagnosisEvidencePack: diagnosisEvidencePackGate ? {
-                status: cleanText((_1 = diagnosisEvidencePackGate.metadata) === null || _1 === void 0 ? void 0 : _1.status, 120),
+                status: cleanText((_401 = diagnosisEvidencePackGate.metadata) === null || _401 === void 0 ? void 0 : _401.status, 120),
                 gateStatus: diagnosisEvidencePackGate.status,
-                packId: cleanText((_2 = diagnosisEvidencePackGate.metadata) === null || _2 === void 0 ? void 0 : _2.packId, 180),
-                readOnly: ((_3 = diagnosisEvidencePackGate.metadata) === null || _3 === void 0 ? void 0 : _3.readOnly) !== false,
-                sourceEditsAllowed: ((_4 = diagnosisEvidencePackGate.metadata) === null || _4 === void 0 ? void 0 : _4.sourceEditsAllowed) === true,
-                requiredOutputKey: cleanText((_5 = diagnosisEvidencePackGate.metadata) === null || _5 === void 0 ? void 0 : _5.requiredOutputKey, 120),
-                diagnosisValid: ((_6 = diagnosisEvidencePackGate.metadata) === null || _6 === void 0 ? void 0 : _6.diagnosisValid) === true,
-                issueClassHint: cleanText((_7 = diagnosisEvidencePackGate.metadata) === null || _7 === void 0 ? void 0 : _7.issueClassHint, 120),
-                ownerFileHints: cleanStringList((_8 = diagnosisEvidencePackGate.metadata) === null || _8 === void 0 ? void 0 : _8.ownerFileHints, 20, 500),
-                similarHintCount: Number(((_9 = diagnosisEvidencePackGate.metadata) === null || _9 === void 0 ? void 0 : _9.similarHintCount) || 0),
-                similarHintsAdvisoryOnly: ((_10 = diagnosisEvidencePackGate.metadata) === null || _10 === void 0 ? void 0 : _10.similarHintsAdvisoryOnly) === true,
-                issueClassProbeCount: Number(((_11 = diagnosisEvidencePackGate.metadata) === null || _11 === void 0 ? void 0 : _11.issueClassProbeCount) || 0),
-                validationBlockers: cleanStringList((_12 = diagnosisEvidencePackGate.metadata) === null || _12 === void 0 ? void 0 : _12.validationBlockers, 20, 500)
+                packId: cleanText((_402 = diagnosisEvidencePackGate.metadata) === null || _402 === void 0 ? void 0 : _402.packId, 180),
+                readOnly: ((_403 = diagnosisEvidencePackGate.metadata) === null || _403 === void 0 ? void 0 : _403.readOnly) !== false,
+                sourceEditsAllowed: ((_404 = diagnosisEvidencePackGate.metadata) === null || _404 === void 0 ? void 0 : _404.sourceEditsAllowed) === true,
+                requiredOutputKey: cleanText((_405 = diagnosisEvidencePackGate.metadata) === null || _405 === void 0 ? void 0 : _405.requiredOutputKey, 120),
+                diagnosisValid: ((_406 = diagnosisEvidencePackGate.metadata) === null || _406 === void 0 ? void 0 : _406.diagnosisValid) === true,
+                issueClassHint: cleanText((_407 = diagnosisEvidencePackGate.metadata) === null || _407 === void 0 ? void 0 : _407.issueClassHint, 120),
+                ownerFileHints: cleanStringList((_408 = diagnosisEvidencePackGate.metadata) === null || _408 === void 0 ? void 0 : _408.ownerFileHints, 20, 500),
+                similarHintCount: Number(((_409 = diagnosisEvidencePackGate.metadata) === null || _409 === void 0 ? void 0 : _409.similarHintCount) || 0),
+                similarHintsAdvisoryOnly: ((_410 = diagnosisEvidencePackGate.metadata) === null || _410 === void 0 ? void 0 : _410.similarHintsAdvisoryOnly) === true,
+                issueClassProbeCount: Number(((_411 = diagnosisEvidencePackGate.metadata) === null || _411 === void 0 ? void 0 : _411.issueClassProbeCount) || 0),
+                validationBlockers: cleanStringList((_412 = diagnosisEvidencePackGate.metadata) === null || _412 === void 0 ? void 0 : _412.validationBlockers, 20, 500)
+            } : undefined,
+            similarFixHintContract: similarFixHintContractGate ? {
+                gateStatus: similarFixHintContractGate.status,
+                contractId: cleanText((_413 = similarFixHintContractGate.metadata) === null || _413 === void 0 ? void 0 : _413.contractId, 200),
+                version: cleanText((_414 = similarFixHintContractGate.metadata) === null || _414 === void 0 ? void 0 : _414.version, 120),
+                status: cleanText((_415 = similarFixHintContractGate.metadata) === null || _415 === void 0 ? void 0 : _415.status, 120),
+                source: cleanText((_416 = similarFixHintContractGate.metadata) === null || _416 === void 0 ? void 0 : _416.source, 160),
+                candidateCount: Number(((_417 = similarFixHintContractGate.metadata) === null || _417 === void 0 ? void 0 : _417.candidateCount) || 0),
+                hintCount: Number(((_418 = similarFixHintContractGate.metadata) === null || _418 === void 0 ? void 0 : _418.hintCount) || 0),
+                rankedHintCount: Number(((_419 = similarFixHintContractGate.metadata) === null || _419 === void 0 ? void 0 : _419.rankedHintCount) || 0),
+                ownerFileHints: cleanStringList((_420 = similarFixHintContractGate.metadata) === null || _420 === void 0 ? void 0 : _420.ownerFileHints, 30, 500),
+                advisoryOnly: ((_421 = similarFixHintContractGate.metadata) === null || _421 === void 0 ? void 0 : _421.advisoryOnly) === true,
+                similarHintsAreNotProof: ((_422 = similarFixHintContractGate.metadata) === null || _422 === void 0 ? void 0 : _422.similarHintsAreNotProof) === true,
+                ownerFilesRequireCurrentEvidence: ((_423 = similarFixHintContractGate.metadata) === null || _423 === void 0 ? void 0 : _423.ownerFilesRequireCurrentEvidence) === true,
+                acceptedHypothesisCurrent: ((_424 = similarFixHintContractGate.metadata) === null || _424 === void 0 ? void 0 : _424.acceptedHypothesisCurrent) === true,
+                requiredModelActions: cleanStringList((_425 = similarFixHintContractGate.metadata) === null || _425 === void 0 ? void 0 : _425.requiredModelActions, 20, 500),
+                blockers: cleanStringList((_426 = similarFixHintContractGate.metadata) === null || _426 === void 0 ? void 0 : _426.blockers, 20, 500)
             } : undefined,
             issueClassProbePlan: issueClassProbePlanGate ? {
-                status: cleanText((_13 = issueClassProbePlanGate.metadata) === null || _13 === void 0 ? void 0 : _13.status, 120),
+                status: cleanText((_427 = issueClassProbePlanGate.metadata) === null || _427 === void 0 ? void 0 : _427.status, 120),
                 gateStatus: issueClassProbePlanGate.status,
-                planId: cleanText((_14 = issueClassProbePlanGate.metadata) === null || _14 === void 0 ? void 0 : _14.planId, 180),
-                issueClass: cleanText((_15 = issueClassProbePlanGate.metadata) === null || _15 === void 0 ? void 0 : _15.issueClass, 120),
-                diagnosisValid: ((_16 = issueClassProbePlanGate.metadata) === null || _16 === void 0 ? void 0 : _16.diagnosisValid) === true,
-                issueClassProbePlanReady: ((_17 = issueClassProbePlanGate.metadata) === null || _17 === void 0 ? void 0 : _17.issueClassProbePlanReady) === true,
-                activeRoute: cleanText((_18 = issueClassProbePlanGate.metadata) === null || _18 === void 0 ? void 0 : _18.activeRoute, 500),
-                action: cleanText((_19 = issueClassProbePlanGate.metadata) === null || _19 === void 0 ? void 0 : _19.action, 1000),
-                expectedBusinessProof: cleanText((_20 = issueClassProbePlanGate.metadata) === null || _20 === void 0 ? void 0 : _20.expectedBusinessProof, 1200),
-                acceptanceGate: cleanText((_21 = issueClassProbePlanGate.metadata) === null || _21 === void 0 ? void 0 : _21.acceptanceGate, 120),
-                requiredArtifacts: cleanStringList((_22 = issueClassProbePlanGate.metadata) === null || _22 === void 0 ? void 0 : _22.requiredArtifacts, 20, 500),
-                falsePassBlockers: cleanStringList((_23 = issueClassProbePlanGate.metadata) === null || _23 === void 0 ? void 0 : _23.falsePassBlockers, 20, 500),
-                blockers: cleanStringList((_24 = issueClassProbePlanGate.metadata) === null || _24 === void 0 ? void 0 : _24.blockers, 20, 500)
+                planId: cleanText((_428 = issueClassProbePlanGate.metadata) === null || _428 === void 0 ? void 0 : _428.planId, 180),
+                issueClass: cleanText((_429 = issueClassProbePlanGate.metadata) === null || _429 === void 0 ? void 0 : _429.issueClass, 120),
+                diagnosisValid: ((_430 = issueClassProbePlanGate.metadata) === null || _430 === void 0 ? void 0 : _430.diagnosisValid) === true,
+                issueClassProbePlanReady: ((_431 = issueClassProbePlanGate.metadata) === null || _431 === void 0 ? void 0 : _431.issueClassProbePlanReady) === true,
+                activeRoute: cleanText((_432 = issueClassProbePlanGate.metadata) === null || _432 === void 0 ? void 0 : _432.activeRoute, 500),
+                action: cleanText((_433 = issueClassProbePlanGate.metadata) === null || _433 === void 0 ? void 0 : _433.action, 1000),
+                expectedBusinessProof: cleanText((_434 = issueClassProbePlanGate.metadata) === null || _434 === void 0 ? void 0 : _434.expectedBusinessProof, 1200),
+                acceptanceGate: cleanText((_435 = issueClassProbePlanGate.metadata) === null || _435 === void 0 ? void 0 : _435.acceptanceGate, 120),
+                requiredArtifacts: cleanStringList((_436 = issueClassProbePlanGate.metadata) === null || _436 === void 0 ? void 0 : _436.requiredArtifacts, 20, 500),
+                falsePassBlockers: cleanStringList((_437 = issueClassProbePlanGate.metadata) === null || _437 === void 0 ? void 0 : _437.falsePassBlockers, 20, 500),
+                blockers: cleanStringList((_438 = issueClassProbePlanGate.metadata) === null || _438 === void 0 ? void 0 : _438.blockers, 20, 500)
             } : undefined,
             businessProofReadiness: Object.keys(businessProofReadiness).length ? {
                 ready: businessProofReadiness.ready === true,
@@ -3706,33 +6577,80 @@ function buildSupportAIRunFromEvidence(input) {
             } : undefined,
             nextActionContract: nextActionContractGate ? {
                 status: nextActionContractGate.status,
-                action: cleanText((_25 = nextActionContractGate.metadata) === null || _25 === void 0 ? void 0 : _25.action, 160),
-                primaryCommand: cleanText((_26 = nextActionContractGate.metadata) === null || _26 === void 0 ? void 0 : _26.primaryCommand, 240),
-                safeToAutoRun: ((_27 = nextActionContractGate.metadata) === null || _27 === void 0 ? void 0 : _27.safeToAutoRun) === true,
-                canRunWithoutCodexMonitor: ((_28 = nextActionContractGate.metadata) === null || _28 === void 0 ? void 0 : _28.canRunWithoutCodexMonitor) === true,
-                codexFallbackRequired: ((_29 = nextActionContractGate.metadata) === null || _29 === void 0 ? void 0 : _29.codexFallbackRequired) === true,
-                requiresHumanApproval: ((_30 = nextActionContractGate.metadata) === null || _30 === void 0 ? void 0 : _30.requiresHumanApproval) === true,
-                rootCauseFirstSatisfied: ((_31 = nextActionContractGate.metadata) === null || _31 === void 0 ? void 0 : _31.rootCauseFirstSatisfied) === true,
-                hotfixCommitRequired: ((_32 = nextActionContractGate.metadata) === null || _32 === void 0 ? void 0 : _32.hotfixCommitRequired) === true,
-                liveHotfixBlockedUntilCommit: ((_33 = nextActionContractGate.metadata) === null || _33 === void 0 ? void 0 : _33.liveHotfixBlockedUntilCommit) === true,
-                failureClass: cleanText((_34 = nextActionContractGate.metadata) === null || _34 === void 0 ? void 0 : _34.failureClass, 120),
-                evidenceFreshnessStatus: cleanText((_35 = nextActionContractGate.metadata) === null || _35 === void 0 ? void 0 : _35.evidenceFreshnessStatus, 120),
-                sameFailureCount: Number(((_36 = nextActionContractGate.metadata) === null || _36 === void 0 ? void 0 : _36.sameFailureCount) || 0),
-                blockers: cleanStringList((_37 = nextActionContractGate.metadata) === null || _37 === void 0 ? void 0 : _37.blockers, 20, 500)
+                action: cleanText((_439 = nextActionContractGate.metadata) === null || _439 === void 0 ? void 0 : _439.action, 160),
+                primaryCommand: cleanText((_440 = nextActionContractGate.metadata) === null || _440 === void 0 ? void 0 : _440.primaryCommand, 240),
+                safeToAutoRun: ((_441 = nextActionContractGate.metadata) === null || _441 === void 0 ? void 0 : _441.safeToAutoRun) === true,
+                canRunWithoutCodexMonitor: ((_442 = nextActionContractGate.metadata) === null || _442 === void 0 ? void 0 : _442.canRunWithoutCodexMonitor) === true,
+                codexFallbackRequired: ((_443 = nextActionContractGate.metadata) === null || _443 === void 0 ? void 0 : _443.codexFallbackRequired) === true,
+                requiresHumanApproval: ((_444 = nextActionContractGate.metadata) === null || _444 === void 0 ? void 0 : _444.requiresHumanApproval) === true,
+                rootCauseFirstSatisfied: ((_445 = nextActionContractGate.metadata) === null || _445 === void 0 ? void 0 : _445.rootCauseFirstSatisfied) === true,
+                proofMatrixReady: ((_446 = nextActionContractGate.metadata) === null || _446 === void 0 ? void 0 : _446.proofMatrixReady) === true,
+                proofMatrixId: cleanText((_447 = nextActionContractGate.metadata) === null || _447 === void 0 ? void 0 : _447.proofMatrixId, 200),
+                ownerScopedRepairContractReady: ((_448 = nextActionContractGate.metadata) === null || _448 === void 0 ? void 0 : _448.ownerScopedRepairContractReady) === true,
+                ownerScopedRepairContractId: cleanText((_449 = nextActionContractGate.metadata) === null || _449 === void 0 ? void 0 : _449.ownerScopedRepairContractId, 200),
+                hotfixCommitRequired: ((_450 = nextActionContractGate.metadata) === null || _450 === void 0 ? void 0 : _450.hotfixCommitRequired) === true,
+                liveHotfixBlockedUntilCommit: ((_451 = nextActionContractGate.metadata) === null || _451 === void 0 ? void 0 : _451.liveHotfixBlockedUntilCommit) === true,
+                evidenceProbeContractReady: ((_452 = nextActionContractGate.metadata) === null || _452 === void 0 ? void 0 : _452.evidenceProbeContractReady) === true,
+                evidenceProbeContractId: cleanText((_453 = nextActionContractGate.metadata) === null || _453 === void 0 ? void 0 : _453.evidenceProbeContractId, 200),
+                autonomyMode: cleanText((_454 = nextActionContractGate.metadata) === null || _454 === void 0 ? void 0 : _454.autonomyMode, 120),
+                autonomyCanAutoDispatch: ((_455 = nextActionContractGate.metadata) === null || _455 === void 0 ? void 0 : _455.autonomyCanAutoDispatch) === true,
+                autonomyReason: cleanText((_456 = nextActionContractGate.metadata) === null || _456 === void 0 ? void 0 : _456.autonomyReason, 1000),
+                autonomyExpectedValueScore: Number(((_457 = nextActionContractGate.metadata) === null || _457 === void 0 ? void 0 : _457.autonomyExpectedValueScore) || 0),
+                autonomyExpectedValuePositive: ((_458 = nextActionContractGate.metadata) === null || _458 === void 0 ? void 0 : _458.autonomyExpectedValuePositive) === true,
+                autonomyProjectedSpendUsd: Number(((_459 = nextActionContractGate.metadata) === null || _459 === void 0 ? void 0 : _459.autonomyProjectedSpendUsd) || 0),
+                failureClass: cleanText((_460 = nextActionContractGate.metadata) === null || _460 === void 0 ? void 0 : _460.failureClass, 120),
+                evidenceFreshnessStatus: cleanText((_461 = nextActionContractGate.metadata) === null || _461 === void 0 ? void 0 : _461.evidenceFreshnessStatus, 120),
+                sameFailureCount: Number(((_462 = nextActionContractGate.metadata) === null || _462 === void 0 ? void 0 : _462.sameFailureCount) || 0),
+                blockers: cleanStringList((_463 = nextActionContractGate.metadata) === null || _463 === void 0 ? void 0 : _463.blockers, 20, 500)
+            } : undefined,
+            managerExecutionPacket: managerExecutionPacketGate ? {
+                status: cleanText((_464 = managerExecutionPacketGate.metadata) === null || _464 === void 0 ? void 0 : _464.status, 120),
+                gateStatus: managerExecutionPacketGate.status,
+                action: cleanText((_465 = managerExecutionPacketGate.metadata) === null || _465 === void 0 ? void 0 : _465.action, 160),
+                primaryCommand: cleanText((_466 = managerExecutionPacketGate.metadata) === null || _466 === void 0 ? void 0 : _466.primaryCommand, 240),
+                executeNow: ((_467 = managerExecutionPacketGate.metadata) === null || _467 === void 0 ? void 0 : _467.executeNow) === true,
+                canRunWithoutCodexMonitor: ((_468 = managerExecutionPacketGate.metadata) === null || _468 === void 0 ? void 0 : _468.canRunWithoutCodexMonitor) === true,
+                codexFallbackRequired: ((_469 = managerExecutionPacketGate.metadata) === null || _469 === void 0 ? void 0 : _469.codexFallbackRequired) === true,
+                retryScope: cleanText((_470 = managerExecutionPacketGate.metadata) === null || _470 === void 0 ? void 0 : _470.retryScope, 120),
+                maxAttemptsBeforeFreshEvidence: Number(((_471 = managerExecutionPacketGate.metadata) === null || _471 === void 0 ? void 0 : _471.maxAttemptsBeforeFreshEvidence) || 0),
+                costRisk: cleanText((_472 = managerExecutionPacketGate.metadata) === null || _472 === void 0 ? void 0 : _472.costRisk, 120),
+                validationStatus: cleanText((_474 = (_473 = managerExecutionPacketGate.metadata) === null || _473 === void 0 ? void 0 : _473.validation) === null || _474 === void 0 ? void 0 : _474.status, 120),
+                validationValid: ((_476 = (_475 = managerExecutionPacketGate.metadata) === null || _475 === void 0 ? void 0 : _475.validation) === null || _476 === void 0 ? void 0 : _476.valid) === true,
+                proofRequiredBeforeContinuation: cleanStringList((_477 = managerExecutionPacketGate.metadata) === null || _477 === void 0 ? void 0 : _477.proofRequiredBeforeContinuation, 20, 500),
+                stopConditions: cleanStringList((_478 = managerExecutionPacketGate.metadata) === null || _478 === void 0 ? void 0 : _478.stopConditions, 20, 500),
+                forbiddenActions: cleanStringList((_479 = managerExecutionPacketGate.metadata) === null || _479 === void 0 ? void 0 : _479.forbiddenActions, 20, 500),
+                ownerFiles: cleanStringList((_480 = managerExecutionPacketGate.metadata) === null || _480 === void 0 ? void 0 : _480.ownerFiles, 40, 500),
+                proofResetContract: ((_481 = managerExecutionPacketGate.metadata) === null || _481 === void 0 ? void 0 : _481.proofResetContract) ? {
+                    contractId: cleanText(managerExecutionPacketGate.metadata.proofResetContract.contractId, 200),
+                    status: cleanText(managerExecutionPacketGate.metadata.proofResetContract.status, 120),
+                    action: cleanText(managerExecutionPacketGate.metadata.proofResetContract.action, 160),
+                    retryScope: cleanText(managerExecutionPacketGate.metadata.proofResetContract.retryScope, 120),
+                    maxAttemptsBeforeFreshEvidence: Number(managerExecutionPacketGate.metadata.proofResetContract.maxAttemptsBeforeFreshEvidence || 0),
+                    startingFailureClass: cleanText(managerExecutionPacketGate.metadata.proofResetContract.startingFailureClass, 120),
+                    startingBlockerFingerprint: cleanText(managerExecutionPacketGate.metadata.proofResetContract.startingBlockerFingerprint, 200),
+                    startingEvidenceHash: cleanText(managerExecutionPacketGate.metadata.proofResetContract.startingEvidenceHash, 200),
+                    requiredResetEvidence: cleanStringList(managerExecutionPacketGate.metadata.proofResetContract.requiredResetEvidence, 40, 500),
+                    proofRequiredBeforeContinuation: cleanStringList(managerExecutionPacketGate.metadata.proofResetContract.proofRequiredBeforeContinuation, 40, 500),
+                    stopConditions: cleanStringList(managerExecutionPacketGate.metadata.proofResetContract.stopConditions, 40, 500),
+                    canRunWithoutCodexMonitor: managerExecutionPacketGate.metadata.proofResetContract.canRunWithoutCodexMonitor === true,
+                    sourceNextActionContractId: cleanText(managerExecutionPacketGate.metadata.proofResetContract.sourceNextActionContractId, 200),
+                    createdAt: cleanText(managerExecutionPacketGate.metadata.proofResetContract.createdAt, 120)
+                } : undefined,
+                blockers: cleanStringList((_482 = managerExecutionPacketGate.metadata) === null || _482 === void 0 ? void 0 : _482.blockers, 20, 500)
             } : undefined,
             managerRecoveryExecutionProof: recoveryExecutionProofGate ? {
-                status: cleanText((_38 = recoveryExecutionProofGate.metadata) === null || _38 === void 0 ? void 0 : _38.status, 120),
+                status: cleanText((_483 = recoveryExecutionProofGate.metadata) === null || _483 === void 0 ? void 0 : _483.status, 120),
                 gateStatus: recoveryExecutionProofGate.status,
-                canContinueRun: ((_39 = recoveryExecutionProofGate.metadata) === null || _39 === void 0 ? void 0 : _39.canContinueRun) === true,
-                canRunProductRepair: ((_40 = recoveryExecutionProofGate.metadata) === null || _40 === void 0 ? void 0 : _40.canRunProductRepair) === true,
-                canRunExpensiveModel: ((_41 = recoveryExecutionProofGate.metadata) === null || _41 === void 0 ? void 0 : _41.canRunExpensiveModel) === true,
-                canResetLoopBudget: ((_42 = recoveryExecutionProofGate.metadata) === null || _42 === void 0 ? void 0 : _42.canResetLoopBudget) === true,
-                newEvidence: ((_43 = recoveryExecutionProofGate.metadata) === null || _43 === void 0 ? void 0 : _43.newEvidence) === true,
-                materialEvidence: ((_44 = recoveryExecutionProofGate.metadata) === null || _44 === void 0 ? void 0 : _44.materialEvidence) === true,
-                evidenceStrength: cleanText((_45 = recoveryExecutionProofGate.metadata) === null || _45 === void 0 ? void 0 : _45.evidenceStrength, 120),
-                nextAllowedAction: cleanText((_46 = recoveryExecutionProofGate.metadata) === null || _46 === void 0 ? void 0 : _46.nextAllowedAction, 180),
-                missingEvidence: cleanStringList((_47 = recoveryExecutionProofGate.metadata) === null || _47 === void 0 ? void 0 : _47.missingEvidence, 20, 500),
-                blockers: cleanStringList((_48 = recoveryExecutionProofGate.metadata) === null || _48 === void 0 ? void 0 : _48.blockers, 20, 500)
+                canContinueRun: ((_484 = recoveryExecutionProofGate.metadata) === null || _484 === void 0 ? void 0 : _484.canContinueRun) === true,
+                canRunProductRepair: ((_485 = recoveryExecutionProofGate.metadata) === null || _485 === void 0 ? void 0 : _485.canRunProductRepair) === true,
+                canRunExpensiveModel: ((_486 = recoveryExecutionProofGate.metadata) === null || _486 === void 0 ? void 0 : _486.canRunExpensiveModel) === true,
+                canResetLoopBudget: ((_487 = recoveryExecutionProofGate.metadata) === null || _487 === void 0 ? void 0 : _487.canResetLoopBudget) === true,
+                newEvidence: ((_488 = recoveryExecutionProofGate.metadata) === null || _488 === void 0 ? void 0 : _488.newEvidence) === true,
+                materialEvidence: ((_489 = recoveryExecutionProofGate.metadata) === null || _489 === void 0 ? void 0 : _489.materialEvidence) === true,
+                evidenceStrength: cleanText((_490 = recoveryExecutionProofGate.metadata) === null || _490 === void 0 ? void 0 : _490.evidenceStrength, 120),
+                nextAllowedAction: cleanText((_491 = recoveryExecutionProofGate.metadata) === null || _491 === void 0 ? void 0 : _491.nextAllowedAction, 180),
+                missingEvidence: cleanStringList((_492 = recoveryExecutionProofGate.metadata) === null || _492 === void 0 ? void 0 : _492.missingEvidence, 20, 500),
+                blockers: cleanStringList((_493 = recoveryExecutionProofGate.metadata) === null || _493 === void 0 ? void 0 : _493.blockers, 20, 500)
             } : undefined,
             customerReplyPolicy: Object.keys(customerReplyPolicy).length ? {
                 action: cleanText(customerReplyPolicy.action, 120),
@@ -3740,31 +6658,57 @@ function buildSupportAIRunFromEvidence(input) {
                 canDraftCustomerReply: customerReplyPolicy.canDraftCustomerReply === true || customerReplyPolicy.can_draft_customer_reply === true,
                 canSendCustomerReply: customerReplyPolicy.canSendCustomerReply === true || customerReplyPolicy.can_send_customer_reply === true,
                 reason: cleanText(customerReplyPolicy.reason, 1000),
-                reviewType: cleanText(((_49 = customerReplyPolicy.humanReviewPacket) === null || _49 === void 0 ? void 0 : _49.reviewType)
-                    || ((_50 = customerReplyPolicy.human_review_packet) === null || _50 === void 0 ? void 0 : _50.review_type)
-                    || ((_51 = customerReplyPolicy.human_review_packet) === null || _51 === void 0 ? void 0 : _51.reviewType), 160),
-                primaryAction: cleanText(((_52 = customerReplyPolicy.humanReviewPacket) === null || _52 === void 0 ? void 0 : _52.primaryAction)
-                    || ((_53 = customerReplyPolicy.human_review_packet) === null || _53 === void 0 ? void 0 : _53.primary_action)
-                    || ((_54 = customerReplyPolicy.human_review_packet) === null || _54 === void 0 ? void 0 : _54.primaryAction), 160),
+                reviewType: cleanText(((_494 = customerReplyPolicy.humanReviewPacket) === null || _494 === void 0 ? void 0 : _494.reviewType)
+                    || ((_495 = customerReplyPolicy.human_review_packet) === null || _495 === void 0 ? void 0 : _495.review_type)
+                    || ((_496 = customerReplyPolicy.human_review_packet) === null || _496 === void 0 ? void 0 : _496.reviewType), 160),
+                primaryAction: cleanText(((_497 = customerReplyPolicy.humanReviewPacket) === null || _497 === void 0 ? void 0 : _497.primaryAction)
+                    || ((_498 = customerReplyPolicy.human_review_packet) === null || _498 === void 0 ? void 0 : _498.primary_action)
+                    || ((_499 = customerReplyPolicy.human_review_packet) === null || _499 === void 0 ? void 0 : _499.primaryAction), 160),
                 clarificationContract: customerReplyPolicy.clarificationContract || customerReplyPolicy.clarification_contract ? {
-                    status: cleanText(((_55 = customerReplyPolicy.clarificationContract) === null || _55 === void 0 ? void 0 : _55.status) || ((_56 = customerReplyPolicy.clarification_contract) === null || _56 === void 0 ? void 0 : _56.status), 120),
-                    missingField: cleanText(((_57 = customerReplyPolicy.clarificationContract) === null || _57 === void 0 ? void 0 : _57.missingField) || ((_58 = customerReplyPolicy.clarification_contract) === null || _58 === void 0 ? void 0 : _58.missing_field), 120),
-                    oneQuestionOnly: ((_59 = customerReplyPolicy.clarificationContract) === null || _59 === void 0 ? void 0 : _59.oneQuestionOnly) === true || ((_60 = customerReplyPolicy.clarification_contract) === null || _60 === void 0 ? void 0 : _60.one_question_only) === true,
-                    parksTicketUntilCustomerReply: ((_61 = customerReplyPolicy.clarificationContract) === null || _61 === void 0 ? void 0 : _61.parksTicketUntilCustomerReply) === true || ((_62 = customerReplyPolicy.clarification_contract) === null || _62 === void 0 ? void 0 : _62.parks_ticket_until_customer_reply) === true
+                    status: cleanText(((_500 = customerReplyPolicy.clarificationContract) === null || _500 === void 0 ? void 0 : _500.status) || ((_501 = customerReplyPolicy.clarification_contract) === null || _501 === void 0 ? void 0 : _501.status), 120),
+                    missingField: cleanText(((_502 = customerReplyPolicy.clarificationContract) === null || _502 === void 0 ? void 0 : _502.missingField) || ((_503 = customerReplyPolicy.clarification_contract) === null || _503 === void 0 ? void 0 : _503.missing_field), 120),
+                    oneQuestionOnly: ((_504 = customerReplyPolicy.clarificationContract) === null || _504 === void 0 ? void 0 : _504.oneQuestionOnly) === true || ((_505 = customerReplyPolicy.clarification_contract) === null || _505 === void 0 ? void 0 : _505.one_question_only) === true,
+                    parksTicketUntilCustomerReply: ((_506 = customerReplyPolicy.clarificationContract) === null || _506 === void 0 ? void 0 : _506.parksTicketUntilCustomerReply) === true || ((_507 = customerReplyPolicy.clarification_contract) === null || _507 === void 0 ? void 0 : _507.parks_ticket_until_customer_reply) === true
                 } : undefined
             } : undefined,
             customerReplyReadiness: customerReplyReadinessGate ? {
-                status: cleanText((_63 = customerReplyReadinessGate.metadata) === null || _63 === void 0 ? void 0 : _63.status, 120),
+                status: cleanText((_508 = customerReplyReadinessGate.metadata) === null || _508 === void 0 ? void 0 : _508.status, 120),
                 gateStatus: customerReplyReadinessGate.status,
-                primaryCommand: cleanText((_64 = customerReplyReadinessGate.metadata) === null || _64 === void 0 ? void 0 : _64.primaryCommand, 180),
-                policyAction: cleanText((_65 = customerReplyReadinessGate.metadata) === null || _65 === void 0 ? void 0 : _65.policyAction, 120),
-                canDraftCustomerReply: ((_66 = customerReplyReadinessGate.metadata) === null || _66 === void 0 ? void 0 : _66.canDraftCustomerReply) === true,
-                canSendCustomerReply: ((_67 = customerReplyReadinessGate.metadata) === null || _67 === void 0 ? void 0 : _67.canSendCustomerReply) === true,
-                requiresHumanApproval: ((_68 = customerReplyReadinessGate.metadata) === null || _68 === void 0 ? void 0 : _68.requiresHumanApproval) === true,
-                proofBacked: ((_69 = customerReplyReadinessGate.metadata) === null || _69 === void 0 ? void 0 : _69.proofBacked) === true,
-                businessProofReady: ((_70 = customerReplyReadinessGate.metadata) === null || _70 === void 0 ? void 0 : _70.businessProofReady) === true,
-                releaseReady: ((_71 = customerReplyReadinessGate.metadata) === null || _71 === void 0 ? void 0 : _71.releaseReady) === true,
-                blockers: cleanStringList((_72 = customerReplyReadinessGate.metadata) === null || _72 === void 0 ? void 0 : _72.blockers, 20, 500)
+                primaryCommand: cleanText((_509 = customerReplyReadinessGate.metadata) === null || _509 === void 0 ? void 0 : _509.primaryCommand, 180),
+                policyAction: cleanText((_510 = customerReplyReadinessGate.metadata) === null || _510 === void 0 ? void 0 : _510.policyAction, 120),
+                canDraftCustomerReply: ((_511 = customerReplyReadinessGate.metadata) === null || _511 === void 0 ? void 0 : _511.canDraftCustomerReply) === true,
+                canSendCustomerReply: ((_512 = customerReplyReadinessGate.metadata) === null || _512 === void 0 ? void 0 : _512.canSendCustomerReply) === true,
+                requiresHumanApproval: ((_513 = customerReplyReadinessGate.metadata) === null || _513 === void 0 ? void 0 : _513.requiresHumanApproval) === true,
+                proofBacked: ((_514 = customerReplyReadinessGate.metadata) === null || _514 === void 0 ? void 0 : _514.proofBacked) === true,
+                businessProofReady: ((_515 = customerReplyReadinessGate.metadata) === null || _515 === void 0 ? void 0 : _515.businessProofReady) === true,
+                releaseReady: ((_516 = customerReplyReadinessGate.metadata) === null || _516 === void 0 ? void 0 : _516.releaseReady) === true,
+                blockers: cleanStringList((_517 = customerReplyReadinessGate.metadata) === null || _517 === void 0 ? void 0 : _517.blockers, 20, 500)
+            } : undefined,
+            customerReplySend: customerReplySendGate ? {
+                status: cleanText((_518 = customerReplySendGate.metadata) === null || _518 === void 0 ? void 0 : _518.status, 160),
+                gateStatus: customerReplySendGate.status,
+                contractId: cleanText((_519 = customerReplySendGate.metadata) === null || _519 === void 0 ? void 0 : _519.contractId, 180),
+                guardStatus: cleanText((_520 = customerReplySendGate.metadata) === null || _520 === void 0 ? void 0 : _520.guardStatus, 160),
+                allowed: ((_521 = customerReplySendGate.metadata) === null || _521 === void 0 ? void 0 : _521.allowed) === true,
+                sentAfterManualApproval: ((_522 = customerReplySendGate.metadata) === null || _522 === void 0 ? void 0 : _522.sentAfterManualApproval) === true,
+                directSendAllowed: ((_523 = customerReplySendGate.metadata) === null || _523 === void 0 ? void 0 : _523.directSendAllowed) === true,
+                manualSendAfterReviewAllowed: ((_524 = customerReplySendGate.metadata) === null || _524 === void 0 ? void 0 : _524.manualSendAfterReviewAllowed) === true,
+                requiresHumanApproval: ((_525 = customerReplySendGate.metadata) === null || _525 === void 0 ? void 0 : _525.requiresHumanApproval) === true,
+                proofBacked: ((_526 = customerReplySendGate.metadata) === null || _526 === void 0 ? void 0 : _526.proofBacked) === true,
+                businessProofReady: ((_527 = customerReplySendGate.metadata) === null || _527 === void 0 ? void 0 : _527.businessProofReady) === true,
+                releaseReady: ((_528 = customerReplySendGate.metadata) === null || _528 === void 0 ? void 0 : _528.releaseReady) === true,
+                diagnosisReady: ((_529 = customerReplySendGate.metadata) === null || _529 === void 0 ? void 0 : _529.diagnosisReady) === true,
+                issueClassProbePlanReady: ((_530 = customerReplySendGate.metadata) === null || _530 === void 0 ? void 0 : _530.issueClassProbePlanReady) === true,
+                confidenceLevel: cleanText((_531 = customerReplySendGate.metadata) === null || _531 === void 0 ? void 0 : _531.confidenceLevel, 120),
+                nextAction: cleanText((_532 = customerReplySendGate.metadata) === null || _532 === void 0 ? void 0 : _532.nextAction, 160),
+                pullRequestUrl: cleanText((_533 = customerReplySendGate.metadata) === null || _533 === void 0 ? void 0 : _533.pullRequestUrl, 500),
+                jobId: cleanText((_534 = customerReplySendGate.metadata) === null || _534 === void 0 ? void 0 : _534.jobId, 180),
+                readinessContractId: cleanText((_535 = customerReplySendGate.metadata) === null || _535 === void 0 ? void 0 : _535.readinessContractId, 180),
+                readinessStatus: cleanText((_536 = customerReplySendGate.metadata) === null || _536 === void 0 ? void 0 : _536.readinessStatus, 160),
+                messageHash: cleanText((_537 = customerReplySendGate.metadata) === null || _537 === void 0 ? void 0 : _537.messageHash, 180),
+                recipients: cleanStringList((_538 = customerReplySendGate.metadata) === null || _538 === void 0 ? void 0 : _538.recipients, 20, 240),
+                requiredEvidence: cleanStringList((_539 = customerReplySendGate.metadata) === null || _539 === void 0 ? void 0 : _539.requiredEvidence, 40, 500),
+                blockers: cleanStringList((_540 = customerReplySendGate.metadata) === null || _540 === void 0 ? void 0 : _540.blockers, 40, 500)
             } : undefined
         }
     });