@resolveio/server-lib 22.3.181 → 22.3.183

package/package.json

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

package/util/support-runner-v5.d.ts

@@ -186,6 +186,42 @@ export interface ResolveIOSupportHumanReviewPacket {
     costRisk: 'free_or_deterministic' | 'small_model_or_qa' | 'expensive_model' | 'release_or_customer_send';
     createdAt: string;
 }
+export interface ResolveIOSupportHumanDecisionChoice {
+    choiceId: string;
+    label: string;
+    action: string;
+    description: string;
+    safety: 'low' | 'medium' | 'high';
+    requiresConfirmation: boolean;
+    nextCommand: string;
+    expectedResult: string;
+    allowedWithoutCodexMonitor: boolean;
+}
+export interface ResolveIOSupportHumanDecisionRequest {
+    requestId: string;
+    required: boolean;
+    status: 'not_required' | 'waiting_for_operator' | 'auto_dispatch_allowed';
+    reason: string;
+    question: string;
+    preferredChoiceId: string;
+    evidence: {
+        failureClass: string;
+        blocker: string;
+        blockerFingerprint: string;
+        evidenceHash: string;
+        sameFailureCount: number;
+        pingPongCount: number;
+        evidenceStrength: ResolveIOAIManagerEvidenceStrength;
+        requiredResetEvidence: string[];
+        recentArtifactPaths: string[];
+        changedFiles: string[];
+        nextActionContractId: string;
+    };
+    choices: ResolveIOSupportHumanDecisionChoice[];
+    blockedUntil: string[];
+    autoDispatchAllowed: boolean;
+    createdAt: string;
+}
 export interface ResolveIOSupportCustomerReplyPolicyInput {
     diagnosisGate?: any;
     issueClassProbePlan?: any;
@@ -198,6 +234,10 @@ export interface ResolveIOSupportCustomerReplyPolicyInput {
     previousArtifactFingerprint?: string;
     unresolvedBlockers?: any[];
     releaseStatus?: string;
+    releaseEvidence?: any;
+    hotfixEvidence?: any;
+    releasePolicy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
+    releaseGatePassed?: boolean;
 }
 export interface ResolveIOSupportCustomerReplyPolicy {
     action: ResolveIOSupportCustomerReplyAction;
@@ -721,6 +761,7 @@ export interface ResolveIOSupportV5AutonomousDecision {
     continuationProofCheckpoint: ResolveIOSupportContinuationProofCheckpoint;
     nextActionContract: ResolveIOSupportNextActionContract;
     humanReviewPacket: ResolveIOSupportHumanReviewPacket;
+    humanDecisionRequest?: ResolveIOSupportHumanDecisionRequest;
     hotfixContinuation?: ResolveIOAIManagerHotfixContinuationDecision;
     recordedAt: string;
 }

package/util/support-runner-v5.js

@@ -1001,6 +1001,146 @@ function normalizeSupportConfidenceLevel(value) {
 function supportReleaseLooksBlocked(value) {
     return /\b(fail|failed|error|blocked|missing|empty|stale|denied|timeout)\b/i.test(cleanText(value, 200));
 }
+function supportStatusLooksPassed(value) {
+    return /\b(pass|passed|success|succeeded|complete|completed|ready|not_required|not required)\b/i.test(cleanText(value, 200));
+}
+function nestedObject(source) {
+    var e_5, _a;
+    var keys = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        keys[_i - 1] = arguments[_i];
+    }
+    try {
+        for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+            var key = keys_1_1.value;
+            var value = cleanObject(source[key]);
+            if (Object.keys(value).length) {
+                return value;
+            }
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return {};
+}
+function resolveSupportReplyReleaseGate(input) {
+    var e_6, _a;
+    var _b;
+    var releaseEvidence = cleanObject(input.releaseEvidence);
+    var releaseStatus = cleanText(input.releaseStatus
+        || releaseEvidence.status
+        || releaseEvidence.releaseStatus
+        || releaseEvidence.release_status
+        || nestedObject(releaseEvidence, 'deploy_production', 'production').status
+        || nestedObject(releaseEvidence, 'deploy_dev', 'dev').status
+        || nestedObject(releaseEvidence, 'push_master', 'pushMaster').status, 200);
+    var hotfixEvidenceContainer = nestedObject(releaseEvidence, 'hotfix_evidence', 'hotfixEvidence');
+    var currentHotfixEvidence = nestedObject(hotfixEvidenceContainer, 'current');
+    var hotfixEvidence = cleanObject(input.hotfixEvidence
+        || hotfixEvidenceContainer.normalized
+        || hotfixEvidenceContainer.evidence
+        || currentHotfixEvidence.evidence
+        || currentHotfixEvidence.normalized
+        || hotfixEvidenceContainer.current_evidence
+        || hotfixEvidenceContainer.currentEvidence);
+    var hotfixCommitProof = nestedObject(releaseEvidence, 'hotfix_commit_proof', 'hotfixCommitProof');
+    var hotfixDurabilityContract = nestedObject(releaseEvidence, 'hotfix_durability_contract', 'hotfixDurabilityContract');
+    var hotfixCommitGuard = cleanObject(hotfixCommitProof.github_commit_guard
+        || hotfixCommitProof.githubCommitGuard
+        || hotfixDurabilityContract.hotfix_commit_guard
+        || hotfixDurabilityContract.hotfixCommitGuard
+        || hotfixEvidenceContainer.github_commit_guard
+        || hotfixEvidenceContainer.githubCommitGuard);
+    var hotfixEvidenceStatus = cleanText(hotfixEvidenceContainer.status || currentHotfixEvidence.status || hotfixEvidence.status, 120);
+    var releaseGateStatus = cleanText(hotfixEvidence.releaseGateStatus
+        || hotfixEvidence.release_gate_status
+        || hotfixEvidenceContainer.release_gate_status
+        || hotfixEvidenceContainer.releaseGateStatus
+        || releaseEvidence.releaseGateStatus
+        || releaseEvidence.release_gate_status, 160);
+    var releaseGatePassed = input.releaseGatePassed === true
+        || supportStatusLooksPassed(releaseGateStatus);
+    var missingCommitProofFields = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(cleanList(hotfixCommitProof.missing_fields || hotfixCommitProof.missingFields, 12, 160)), false), __read(cleanList(hotfixEvidenceContainer.missing_fields || hotfixEvidenceContainer.missingFields, 12, 160)), false), __read(cleanList(hotfixDurabilityContract.missing_commit_proof_fields || hotfixDurabilityContract.missingCommitProofFields, 12, 160)), false), __read(cleanList(hotfixCommitGuard.missing_fields || hotfixCommitGuard.missingFields, 12, 160)), false).filter(Boolean)));
+    var commitProofRequired = hotfixCommitProof.required === true
+        || hotfixEvidenceContainer.github_commit_required === true
+        || hotfixEvidenceContainer.githubCommitRequired === true
+        || hotfixCommitGuard.required === true
+        || hotfixDurabilityContract.required === true;
+    var commitProofPassed = hotfixCommitProof.passed === true
+        || hotfixEvidenceContainer.github_commit_proof_passed === true
+        || hotfixEvidenceContainer.githubCommitProofPassed === true
+        || hotfixCommitGuard.passed === true;
+    var commitProofBlocked = hotfixCommitProof.blocked === true
+        || hotfixEvidenceContainer.manager_must_commit_before_hotfix === true
+        || hotfixEvidenceContainer.managerMustCommitBeforeHotfix === true
+        || hotfixDurabilityContract.live_hotfix_blocked_until_commit === true
+        || hotfixDurabilityContract.liveHotfixBlockedUntilCommit === true
+        || hotfixCommitGuard.manager_must_commit_before_hotfix === true
+        || hotfixCommitGuard.managerMustCommitBeforeHotfix === true
+        || (commitProofRequired && !commitProofPassed)
+        || missingCommitProofFields.length > 0;
+    var statusBlocked = supportReleaseLooksBlocked(releaseStatus)
+        || supportReleaseLooksBlocked(hotfixEvidenceStatus)
+        || supportReleaseLooksBlocked(releaseGateStatus);
+    var blockers = [];
+    if (statusBlocked) {
+        blockers.push("release_status=".concat(releaseStatus || hotfixEvidenceStatus || releaseGateStatus || 'blocked'));
+    }
+    if (commitProofBlocked) {
+        blockers.push('hotfix_commit_proof_missing_or_blocked');
+    }
+    try {
+        for (var missingCommitProofFields_1 = __values(missingCommitProofFields), missingCommitProofFields_1_1 = missingCommitProofFields_1.next(); !missingCommitProofFields_1_1.done; missingCommitProofFields_1_1 = missingCommitProofFields_1.next()) {
+            var field = missingCommitProofFields_1_1.value;
+            blockers.push("missing_".concat(field));
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (missingCommitProofFields_1_1 && !missingCommitProofFields_1_1.done && (_a = missingCommitProofFields_1.return)) _a.call(missingCommitProofFields_1);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    var shouldEvaluateHotfix = statusBlocked || commitProofRequired || Object.keys(hotfixEvidence).length > 0;
+    var hotfixContinuation = shouldEvaluateHotfix
+        ? (0, ai_runner_manager_policy_1.decideResolveIOAIManagerHotfixContinuation)({
+            evidence: hotfixEvidence,
+            policy: input.releasePolicy,
+            releaseGatePassed: releaseGatePassed,
+            failureClass: 'release',
+            blocker: blockers.join('; ') || releaseStatus || hotfixEvidenceStatus || releaseGateStatus,
+            now: undefined
+        })
+        : undefined;
+    if (hotfixContinuation && hotfixContinuation.action !== 'continue_runner' && (statusBlocked || commitProofBlocked || hotfixContinuation.action === 'record_hotfix_evidence' || hotfixContinuation.action === 'rerun_release_gate')) {
+        blockers.push("hotfix_next_action=".concat(hotfixContinuation.action));
+    }
+    var uniqueBlockers = Array.from(new Set(blockers.filter(Boolean)));
+    return {
+        blocked: uniqueBlockers.length > 0,
+        reason: uniqueBlockers.length
+            ? 'support_reply_release_or_hotfix_evidence_blocked'
+            : 'support_reply_release_or_hotfix_evidence_clear',
+        status: releaseStatus || hotfixEvidenceStatus || releaseGateStatus || '',
+        blockers: uniqueBlockers,
+        requiredEvidence: [
+            'release status passed or explicitly not required',
+            'hotfix commit proof clear when hotfix evidence is required',
+            'sourceCommitSha, githubCommitUrl, gitCommitStatus=passed, gitPushStatus=passed when backend hotfix was used',
+            'release gate passed when hotfix evidence requires gate rerun'
+        ],
+        nextCommands: ((_b = hotfixContinuation === null || hotfixContinuation === void 0 ? void 0 : hotfixContinuation.nextCommands) === null || _b === void 0 ? void 0 : _b.length)
+            ? hotfixContinuation.nextCommands
+            : ['record_hotfix_evidence', 'commit_and_push_hotfix_to_github', 'rerun_release_gate_once'],
+        hotfixContinuation: hotfixContinuation
+    };
+}
 function supportBusinessAssertionPassed(value) {
     return /^(pass|passed|accepted|business_assertion_passed)$/i.test(cleanText(value, 80));
 }
@@ -1011,7 +1151,7 @@ function supportBusinessAssertionRouteOnly(value) {
     return /^(route_probe_pass|route_only_pass|route_pass|route_probe|route_loaded)$/i.test(cleanText(value, 80));
 }
 function normalizeSupportBusinessProofAssertions(input) {
-    var e_5, _a;
+    var e_7, _a;
     var gate = normalizeResolveIOSupportDiagnosisGate(input.diagnosisGate);
     var proofPlan = gate === null || gate === void 0 ? void 0 : gate.proof_plan;
     var proofContract = proofPlan === null || proofPlan === void 0 ? void 0 : proofPlan.business_proof_contract;
@@ -1045,12 +1185,12 @@ function normalizeSupportBusinessProofAssertions(input) {
             });
         }
     }
-    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
     finally {
         try {
             if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
         }
-        finally { if (e_5) throw e_5.error; }
+        finally { if (e_7) throw e_7.error; }
     }
     var status = cleanText(input.businessAssertionStatus || input.outcomeLabel, 80);
     if (!assertions.length && (supportBusinessAssertionPassed(status) || supportBusinessAssertionRouteOnly(status) || supportBusinessAssertionFailed(status))) {
@@ -1089,7 +1229,7 @@ function supportBusinessProofAssertionText(assertion) {
     ].filter(Boolean).join(' '), 4000);
 }
 function supportBusinessProofAssertionMatchesContract(assertion, gate) {
-    var e_6, _a;
+    var e_8, _a;
     if (!gate) {
         return false;
     }
@@ -1129,12 +1269,12 @@ function supportBusinessProofAssertionMatchesContract(assertion, gate) {
             }
         }
     }
-    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
     finally {
         try {
             if (proofWords_1_1 && !proofWords_1_1.done && (_a = proofWords_1.return)) _a.call(proofWords_1);
         }
-        finally { if (e_6) throw e_6.error; }
+        finally { if (e_8) throw e_8.error; }
     }
     return overlap >= Math.min(5, Math.max(3, Math.ceil(proofWords.size * 0.45)));
 }
@@ -1364,7 +1504,7 @@ function decideResolveIOSupportCustomerReplyPolicy(input) {
     });
     var artifactCount = businessProofReadiness.artifactPaths.length;
     var unresolvedBlockers = cleanList(input.unresolvedBlockers, 20, 500);
-    var releaseBlocked = supportReleaseLooksBlocked(input.releaseStatus);
+    var releaseGate = resolveSupportReplyReleaseGate(input);
     var requiredEvidence = [
         'valid SupportDiagnosisGate',
         'validated IssueClassProbePlan',
@@ -1505,7 +1645,8 @@ function decideResolveIOSupportCustomerReplyPolicy(input) {
             })
         };
     }
-    if (releaseBlocked) {
+    if (releaseGate.blocked) {
+        var releaseRequiredEvidence = Array.from(new Set(__spreadArray(__spreadArray([], __read(requiredEvidence), false), __read(releaseGate.requiredEvidence), false)));
         return {
             action: 'hold_internal',
             canDraftCustomerReply: false,
@@ -1513,7 +1654,7 @@ function decideResolveIOSupportCustomerReplyPolicy(input) {
             confidenceLevel: confidenceLevel,
             safety: 'internal_hold',
             reason: 'support_reply_blocked_until_release_or_hotfix_gate_finishes',
-            requiredEvidence: requiredEvidence,
+            requiredEvidence: releaseRequiredEvidence,
             humanReviewPacket: buildResolveIOSupportHumanReviewPacket({
                 reviewType: 'release_hotfix',
                 title: 'Finish Release Or Hotfix Gate',
@@ -1521,9 +1662,9 @@ function decideResolveIOSupportCustomerReplyPolicy(input) {
                 primaryAction: 'repair_release_hotfix_first',
                 safety: 'internal_hold',
                 reason: 'support_reply_blocked_until_release_or_hotfix_gate_finishes',
-                blockers: [input.releaseStatus],
-                requiredEvidence: requiredEvidence,
-                nextCommands: ['record_hotfix_evidence', 'commit_and_push_hotfix_to_github', 'rerun_release_gate_once'],
+                blockers: releaseGate.blockers,
+                requiredEvidence: releaseRequiredEvidence,
+                nextCommands: releaseGate.nextCommands,
                 forbiddenActions: ['Do not tell the customer the fix is live before release evidence passes.'],
                 costRisk: 'release_or_customer_send'
             })
@@ -2424,7 +2565,7 @@ function buildResolveIOSupportV5ScopeDigest(input) {
     return raw.slice(0, maxChars);
 }
 function buildResolveIOSupportV5MicrotaskLedger(input) {
-    var e_7, _a;
+    var e_9, _a;
     var existing = Array.isArray(input.existing) ? input.existing : [];
     var completedByObjective = new Map();
     try {
@@ -2435,12 +2576,12 @@ function buildResolveIOSupportV5MicrotaskLedger(input) {
             }
         }
     }
-    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
     finally {
         try {
             if (existing_1_1 && !existing_1_1.done && (_a = existing_1.return)) _a.call(existing_1);
         }
-        finally { if (e_7) throw e_7.error; }
+        finally { if (e_9) throw e_9.error; }
     }
     var now = isoNow(input.now);
     var requirements = cleanList(input.requirements, 30, 240);
@@ -2819,7 +2960,7 @@ function decideResolveIOSupportV5Continuation(bundle) {
     return __assign({ action: 'continue', reason: 'support_v5_continue', nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || bundle.supportV5SupervisorState.activeStep, repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, recoveryFieldsFor(recoveryPlan));
 }
 function decideResolveIOSupportV5AutonomousNextAction(input) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     var bundle = input.bundle;
     var activeMicrotask = selectResolveIOSupportV5ActiveMicrotask(bundle.supportV5MicrotaskLedger || [], bundle.supportV5ActiveMicrotaskId);
     var diagnosisValidation = validateResolveIOSupportDiagnosisGate(bundle.supportV5DiagnosisGate, {
@@ -2851,7 +2992,10 @@ function decideResolveIOSupportV5AutonomousNextAction(input) {
         previousProofFingerprint: input.previousProofFingerprint,
         previousArtifactFingerprint: input.previousArtifactFingerprint,
         unresolvedBlockers: input.unresolvedBlockers,
-        releaseStatus: input.releaseStatus
+        releaseStatus: input.releaseStatus,
+        hotfixEvidence: input.hotfixEvidence,
+        releasePolicy: input.releasePolicy,
+        releaseGatePassed: input.releaseGatePassed
     });
     var businessProofReadiness = evaluateResolveIOSupportBusinessProofReadiness({
         diagnosisGate: bundle.supportV5DiagnosisGate,
@@ -3102,6 +3246,128 @@ function decideResolveIOSupportV5AutonomousNextAction(input) {
             createdAt: createdAt
         };
     };
+    var buildHumanDecisionRequest = function (action, label, reason, fields, rootCauseReadiness, continuationProofCheckpoint, nextActionContract, requiredEvidence, blockers) {
+        var repeatedEvidenceBlocked = evidenceFreshness.mustCollectNewEvidence === true
+            || rootCauseReadiness.sameFailureParked === true
+            || continuationProofCheckpoint.status === 'waiting_for_new_evidence';
+        var manualApprovalRequired = action === 'park_manual'
+            || action === 'ask_customer_clarification'
+            || nextActionContract.requiresHumanApproval === true
+            || fields.canRunAutonomously !== true;
+        if (!repeatedEvidenceBlocked && !manualApprovalRequired) {
+            return undefined;
+        }
+        var createdAt = isoNow(input.now);
+        var autoDispatchAllowed = repeatedEvidenceBlocked
+            && action === 'collect_new_evidence'
+            && nextActionContract.safeToAutoRun === true
+            && nextActionContract.canRunWithoutCodexMonitor === true;
+        var preferredChoiceId = autoDispatchAllowed
+            ? 'run_bounded_evidence_probe'
+            : action === 'ask_customer_clarification'
+                ? 'review_customer_clarification'
+                : action === 'run_diagnosis_gate' || action === 'revise_diagnosis_scope'
+                    ? 'revise_diagnosis_gate'
+                    : 'keep_parked';
+        var baseRequiredEvidence = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray([], __read(requiredEvidence), false), __read(continuationProofCheckpoint.requiredResetEvidence), false), __read(evidenceFreshness.requiredResetEvidence), false).filter(Boolean))).slice(0, 20);
+        var choices = [];
+        if (repeatedEvidenceBlocked) {
+            choices.push({
+                choiceId: 'run_bounded_evidence_probe',
+                label: 'Run Evidence Probe',
+                action: 'collect_new_evidence',
+                description: 'Collect changed issue-specific evidence only; product-code repair remains blocked until blockerFingerprint, evidenceHash, or business proof changes.',
+                safety: 'low',
+                requiresConfirmation: false,
+                nextCommand: nextActionContract.primaryCommand || 'run_support_v5_recovery_evidence_probe',
+                expectedResult: nextActionExpectedTransition('collect_new_evidence', nextActionContract.primaryCommand || 'run_support_v5_recovery_evidence_probe'),
+                allowedWithoutCodexMonitor: autoDispatchAllowed
+            });
+        }
+        choices.push({
+            choiceId: 'revise_diagnosis_gate',
+            label: 'Revise Diagnosis',
+            action: 'run_diagnosis_gate',
+            description: 'Re-run read-only root-cause diagnosis with the new evidence and update owner files/proof plan before any repair loop.',
+            safety: 'low',
+            requiresConfirmation: repeatedEvidenceBlocked === false,
+            nextCommand: 'revise_support_diagnosis_gate_with_new_evidence',
+            expectedResult: nextActionExpectedTransition('run_diagnosis_gate', 'revise_support_diagnosis_gate_with_new_evidence'),
+            allowedWithoutCodexMonitor: false
+        });
+        if (action === 'ask_customer_clarification') {
+            choices.push({
+                choiceId: 'review_customer_clarification',
+                label: 'Review Clarification',
+                action: 'ask_customer_clarification',
+                description: 'Review the one customer question before any send action; no product-code repair is allowed from guessed context.',
+                safety: 'medium',
+                requiresConfirmation: true,
+                nextCommand: nextActionContract.primaryCommand || 'review_customer_clarification',
+                expectedResult: nextActionExpectedTransition('ask_customer_clarification', nextActionContract.primaryCommand || 'review_customer_clarification'),
+                allowedWithoutCodexMonitor: false
+            });
+        }
+        choices.push({
+            choiceId: 'keep_parked',
+            label: 'Keep Parked',
+            action: 'park_manual',
+            description: 'Do not spend more model, QA, release, or customer-send budget until new evidence, scope, budget, or approval changes.',
+            safety: 'low',
+            requiresConfirmation: false,
+            nextCommand: 'park_support_ticket_until_new_evidence',
+            expectedResult: 'The support runner stays parked and records the blocker as waiting for an operator decision or fresh evidence.',
+            allowedWithoutCodexMonitor: true
+        });
+        var blockedUntil = Array.from(new Set(__spreadArray(__spreadArray([], __read(baseRequiredEvidence), false), [
+            repeatedEvidenceBlocked ? 'blockerFingerprint changes from the starting repeated blocker' : '',
+            repeatedEvidenceBlocked ? 'evidenceHash changes from the starting repeated evidence hash' : '',
+            repeatedEvidenceBlocked ? 'fresh AIQaBusinessAssertion, infra/compile proof, release proof, or artifact path is attached' : '',
+            action === 'park_manual' ? 'operator changes scope, budget, autonomy policy, or approval' : ''
+        ], false).filter(Boolean))).slice(0, 16);
+        return {
+            requestId: "support-human-decision-".concat(hashResolveIOSupportV5Evidence({
+                action: action,
+                label: label,
+                reason: reason,
+                preferredChoiceId: preferredChoiceId,
+                failureClass: evidenceFreshness.failureClass,
+                blockerFingerprint: evidenceFreshness.blockerFingerprint,
+                evidenceHash: evidenceFreshness.evidenceHash,
+                createdAt: createdAt.slice(0, 16)
+            }).slice(0, 16)),
+            required: true,
+            status: autoDispatchAllowed ? 'auto_dispatch_allowed' : 'waiting_for_operator',
+            reason: repeatedEvidenceBlocked
+                ? "".concat(reason, " Same failure evidence repeated; repair is blocked until new evidence changes the proof state.")
+                : reason,
+            question: repeatedEvidenceBlocked
+                ? 'Same blocker/evidence repeated. Run one bounded evidence probe, revise diagnosis with new facts, or keep the ticket parked?'
+                : action === 'ask_customer_clarification'
+                    ? 'Customer context is missing. Review the clarification question or keep the ticket parked?'
+                    : "Human approval is required for ".concat(label, ". What should the runner do next?"),
+            preferredChoiceId: preferredChoiceId,
+            evidence: {
+                failureClass: evidenceFreshness.failureClass,
+                blocker: cleanText(blockers[0] || reason, 1000),
+                blockerFingerprint: evidenceFreshness.blockerFingerprint,
+                evidenceHash: evidenceFreshness.evidenceHash,
+                sameFailureCount: evidenceFreshness.sameFailureCount,
+                pingPongCount: evidenceFreshness.pingPongCount,
+                evidenceStrength: evidenceFreshness.evidenceStrength,
+                requiredResetEvidence: baseRequiredEvidence,
+                recentArtifactPaths: evidenceFreshness.artifactPaths.slice(0, 20),
+                changedFiles: evidenceFreshness.changedFiles.slice(0, 20),
+                nextActionContractId: nextActionContract.contractId
+            },
+            choices: choices
+                .filter(function (choice, index, source) { return source.findIndex(function (candidate) { return candidate.choiceId === choice.choiceId; }) === index; })
+                .slice(0, 6),
+            blockedUntil: blockedUntil,
+            autoDispatchAllowed: autoDispatchAllowed,
+            createdAt: createdAt
+        };
+    };
     var makeDecision = function (action, label, reason, fields) {
         var _a;
         var primaryCommand = fields.primaryCommand || action;
@@ -3147,6 +3413,7 @@ function decideResolveIOSupportV5AutonomousNextAction(input) {
                             : 'free_or_deterministic',
                 now: input.now
             });
+        var humanDecisionRequest = buildHumanDecisionRequest(action, label, reason, fields, rootCauseReadiness, continuationProofCheckpoint, nextActionContract, requiredEvidence, blockers);
         return {
             action: action,
             label: label,
@@ -3185,6 +3452,7 @@ function decideResolveIOSupportV5AutonomousNextAction(input) {
             continuationProofCheckpoint: continuationProofCheckpoint,
             nextActionContract: nextActionContract,
             humanReviewPacket: humanReviewPacket,
+            humanDecisionRequest: humanDecisionRequest,
             hotfixContinuation: fields.hotfixContinuation,
             recordedAt: isoNow(input.now)
         };
@@ -3376,6 +3644,24 @@ function decideResolveIOSupportV5AutonomousNextAction(input) {
             hotfixContinuation: hotfixContinuation
         });
     }
+    if (customerReplyPolicy.action === 'hold_internal' && customerReplyPolicy.reason === 'support_reply_blocked_until_release_or_hotfix_gate_finishes') {
+        return makeDecision('repair_release_hotfix_first', 'Hotfix Release', 'support_v5_reply_blocked_by_hotfix_evidence', {
+            canRunAutonomously: true,
+            canRunModel: false,
+            canEditProductCode: false,
+            canPrepareHotfixPatch: true,
+            canHotfixBackend: false,
+            liveHotfixBlockedUntilCommit: true,
+            lane: 'release',
+            stepType: 'release_gate',
+            primaryCommand: ((_f = customerReplyPolicy.humanReviewPacket) === null || _f === void 0 ? void 0 : _f.primaryAction) || 'repair_release_hotfix_first',
+            nextCommands: ((_g = customerReplyPolicy.humanReviewPacket) === null || _g === void 0 ? void 0 : _g.nextCommands) || ['record_hotfix_evidence', 'commit_and_push_hotfix_to_github', 'rerun_release_gate_once'],
+            requiredEvidence: customerReplyPolicy.requiredEvidence,
+            blockers: ((_h = customerReplyPolicy.humanReviewPacket) === null || _h === void 0 ? void 0 : _h.blockers) || ['Release or hotfix evidence is incomplete.'],
+            forbiddenActions: ['Do not draft a customer resolution until hotfix commit proof and release evidence are complete.'],
+            humanReviewPacket: customerReplyPolicy.humanReviewPacket
+        });
+    }
     if ((activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.lane) === 'qa' || /^(qa_row|qa_retest|business_proof|route_probe|issue_class_probe)$/.test(activeStepType)) {
         return makeDecision('run_business_proof_qa', 'Run Business Proof QA', 'support_v5_business_assertion_required', {
             canRunAutonomously: true,
@@ -3694,7 +3980,7 @@ function buildResolveIOSupportV5MicrotaskPrompt(input) {
     };
 }
 function summarizeResolveIOSupportV5MicrotaskUsage(bundle) {
-    var e_8, _a, e_9, _b;
+    var e_10, _a, e_11, _b;
     var byMicrotask = new Map();
     var bySection = new Map();
     var totalPromptTokenEstimate = 0;
@@ -3709,17 +3995,17 @@ function summarizeResolveIOSupportV5MicrotaskUsage(bundle) {
             existing.calls += 1;
             byMicrotask.set(usage.microtaskId, existing);
             try {
-                for (var _e = (e_9 = void 0, __values(usage.promptSections || [])), _f = _e.next(); !_f.done; _f = _e.next()) {
+                for (var _e = (e_11 = void 0, __values(usage.promptSections || [])), _f = _e.next(); !_f.done; _f = _e.next()) {
                     var section = _f.value;
                     bySection.set(section.name, (bySection.get(section.name) || 0) + section.tokenEstimate);
                 }
             }
-            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            catch (e_11_1) { e_11 = { error: e_11_1 }; }
             finally {
                 try {
                     if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
                 }
-                finally { if (e_9) throw e_9.error; }
+                finally { if (e_11) throw e_11.error; }
             }
             var hardCap = usage.lane === 'qa' ? promptBudget.qaMicrotaskHardCap : promptBudget.buildMicrotaskHardCap;
             if ((usage.promptTokenEstimate || 0) > hardCap) {
@@ -3727,12 +4013,12 @@ function summarizeResolveIOSupportV5MicrotaskUsage(bundle) {
             }
         }
     }
-    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    catch (e_10_1) { e_10 = { error: e_10_1 }; }
     finally {
         try {
             if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
         }
-        finally { if (e_8) throw e_8.error; }
+        finally { if (e_10) throw e_10.error; }
     }
     return {
         totalPromptTokenEstimate: totalPromptTokenEstimate,