@resolveio/server-lib 22.3.181 → 22.3.182

package/package.json

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

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

@@ -198,6 +198,10 @@ export interface ResolveIOSupportCustomerReplyPolicyInput {
     previousArtifactFingerprint?: string;
     unresolvedBlockers?: any[];
     releaseStatus?: string;
+    releaseEvidence?: any;
+    hotfixEvidence?: any;
+    releasePolicy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
+    releaseGatePassed?: boolean;
 }
 export interface ResolveIOSupportCustomerReplyPolicy {
     action: ResolveIOSupportCustomerReplyAction;

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,
@@ -3376,6 +3520,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 +3856,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 +3871,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 +3889,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,