@resolveio/server-lib 22.3.190 → 22.3.192

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

@@ -1,4 +1,4 @@
-import { ResolveIOAIManagerHotfixContinuationDecision, ResolveIOAIManagerHotfixFirstReleasePolicy, ResolveIOAIManagerEvidenceStrength, ResolveIOAIManagerRecoveryCheckpoint, ResolveIOAIManagerRecoveryActionPacket, ResolveIOAIManagerRecoveryActionDispatchRecord, ResolveIOAIManagerRecoveryExecutionDirective, ResolveIOAIManagerRecoveryEvidenceProbe, ResolveIOAIManagerRecoveryPlan } from './ai-runner-manager-policy';
+import { ResolveIOAIManagerHotfixContinuationDecision, ResolveIOAIManagerHotfixDurabilityContract, ResolveIOAIManagerHotfixFirstReleasePolicy, ResolveIOAIManagerEvidenceStrength, ResolveIOAIManagerRecoveryCheckpoint, ResolveIOAIManagerRecoveryActionPacket, ResolveIOAIManagerRecoveryActionDispatchRecord, ResolveIOAIManagerRecoveryExecutionDirective, ResolveIOAIManagerRecoveryEvidenceProbe, ResolveIOAIManagerRecoveryPlan } from './ai-runner-manager-policy';
 export type ResolveIOSupportV5StepType = 'diagnosis_gate' | 'reproduction_probe' | 'issue_class_probe' | 'business_proof' | 'compile_check' | 'startup_check' | 'live_seed' | 'auth_bootstrap' | 'route_probe' | 'qa_row' | 'build_repair' | 'qa_retest' | 'pr_review' | 'artifact_package' | 'cleanup';
 export type ResolveIOSupportV5Outcome = 'pass' | 'needs_repair' | 'retry_same_step' | 'park_manual' | 'budget_stop' | 'infra_retry' | 'ready_for_merge';
 export type ResolveIOSupportV5Lane = 'build' | 'qa' | 'review' | 'supervisor';
@@ -239,6 +239,22 @@ export interface ResolveIOSupportCustomerReplyPolicyInput {
     releasePolicy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
     releaseGatePassed?: boolean;
 }
+export type ResolveIOSupportClarificationMissingField = 'reproduction_blocker' | 'expected_result' | 'observed_result' | 'account_customer_context' | 'example_record_or_action_path';
+export interface ResolveIOSupportClarificationContract {
+    contractId: string;
+    status: 'ready' | 'blocked';
+    missingField: ResolveIOSupportClarificationMissingField;
+    question: string;
+    sourceBlockers: string[];
+    oneQuestionOnly: boolean;
+    customerFacingDraftAllowed: boolean;
+    customerSendAllowed: boolean;
+    parksTicketUntilCustomerReply: boolean;
+    nextCommands: string[];
+    forbiddenActions: string[];
+    requiredEvidence: string[];
+    createdAt: string;
+}
 export interface ResolveIOSupportCustomerReplyPolicy {
     action: ResolveIOSupportCustomerReplyAction;
     canDraftCustomerReply: boolean;
@@ -248,6 +264,7 @@ export interface ResolveIOSupportCustomerReplyPolicy {
     reason: string;
     requiredEvidence: string[];
     clarificationQuestion?: string;
+    clarificationContract?: ResolveIOSupportClarificationContract;
     humanReviewPacket?: ResolveIOSupportHumanReviewPacket;
     draftBasis?: {
         issueClass: ResolveIOSupportIssueClass;
@@ -823,6 +840,7 @@ export interface ResolveIOSupportV5AutonomousDecision {
     humanReviewPacket: ResolveIOSupportHumanReviewPacket;
     humanDecisionRequest?: ResolveIOSupportHumanDecisionRequest;
     hotfixContinuation?: ResolveIOAIManagerHotfixContinuationDecision;
+    hotfixDurabilityContract?: ResolveIOAIManagerHotfixDurabilityContract;
     recordedAt: string;
 }
 export declare function evaluateResolveIOSupportPreflightGate(input?: ResolveIOSupportPreflightGateInput | ResolveIOSupportPreflightGate | any, nowValue?: Date | string): ResolveIOSupportPreflightGate;
@@ -835,6 +853,13 @@ export declare function validateResolveIOSupportDiagnosisGate(value: any, option
     maxOwnerFiles?: number;
 }): ResolveIOSupportDiagnosisGateValidation;
 export declare function evaluateResolveIOSupportBusinessProofReadiness(input?: ResolveIOSupportBusinessProofReadinessInput): ResolveIOSupportBusinessProofReadiness;
+export declare function buildResolveIOSupportClarificationContract(gate: ResolveIOSupportDiagnosisGate | undefined, blockers?: string[], now?: Date | string): ResolveIOSupportClarificationContract;
+export declare function validateResolveIOSupportClarificationContract(value: any): {
+    valid: boolean;
+    status: 'ready' | 'blocked';
+    blockers: string[];
+    normalized: ResolveIOSupportClarificationContract;
+};
 export declare function decideResolveIOSupportCustomerReplyPolicy(input?: ResolveIOSupportCustomerReplyPolicyInput): ResolveIOSupportCustomerReplyPolicy;
 export declare function buildResolveIOSupportIssueClassProbes(value: any): ResolveIOSupportIssueClassProbe[];
 export declare function validateResolveIOSupportIssueClassProbePlan(value: any, diagnosisGate?: any, now?: Date | string): ResolveIOSupportIssueClassProbePlanValidation;

package/util/support-runner-v5.js

@@ -55,6 +55,8 @@ exports.normalizeResolveIOSupportDiagnosisGate = normalizeResolveIOSupportDiagno
 exports.extractResolveIOSupportDiagnosisGateFromText = extractResolveIOSupportDiagnosisGateFromText;
 exports.validateResolveIOSupportDiagnosisGate = validateResolveIOSupportDiagnosisGate;
 exports.evaluateResolveIOSupportBusinessProofReadiness = evaluateResolveIOSupportBusinessProofReadiness;
+exports.buildResolveIOSupportClarificationContract = buildResolveIOSupportClarificationContract;
+exports.validateResolveIOSupportClarificationContract = validateResolveIOSupportClarificationContract;
 exports.decideResolveIOSupportCustomerReplyPolicy = decideResolveIOSupportCustomerReplyPolicy;
 exports.buildResolveIOSupportIssueClassProbes = buildResolveIOSupportIssueClassProbes;
 exports.validateResolveIOSupportIssueClassProbePlan = validateResolveIOSupportIssueClassProbePlan;
@@ -1628,6 +1630,105 @@ function buildSupportClarificationQuestion(gate, blockers) {
     }
     return 'Can you send one concrete example record, screen, or action path where this issue still occurs?';
 }
+function resolveSupportClarificationMissingField(gate, blockers) {
+    if ((gate === null || gate === void 0 ? void 0 : gate.issue_case.reproduction_status) === 'blocked' && gate.issue_case.reproduction_blocker) {
+        return 'reproduction_blocker';
+    }
+    if (blockers.some(function (blocker) { return /expected_result/.test(blocker); })) {
+        return 'expected_result';
+    }
+    if (blockers.some(function (blocker) { return /observed_result/.test(blocker); })) {
+        return 'observed_result';
+    }
+    if (blockers.some(function (blocker) { return /account_customer_context/.test(blocker); })) {
+        return 'account_customer_context';
+    }
+    return 'example_record_or_action_path';
+}
+function buildResolveIOSupportClarificationContract(gate, blockers, now) {
+    if (blockers === void 0) { blockers = []; }
+    var sourceBlockers = cleanList(blockers, 20, 500);
+    var missingField = resolveSupportClarificationMissingField(gate, sourceBlockers);
+    var question = buildSupportClarificationQuestion(gate, sourceBlockers);
+    var createdAt = isoNow(now);
+    return {
+        contractId: "support-clarification-".concat(hashResolveIOSupportV5Evidence({
+            missingField: missingField,
+            question: question,
+            sourceBlockers: sourceBlockers,
+            ticketRoute: gate === null || gate === void 0 ? void 0 : gate.issue_case.route_module,
+            createdAt: createdAt.slice(0, 16)
+        }).slice(0, 16)),
+        status: 'ready',
+        missingField: missingField,
+        question: question,
+        sourceBlockers: sourceBlockers,
+        oneQuestionOnly: (question.match(/\?/g) || []).length === 1,
+        customerFacingDraftAllowed: true,
+        customerSendAllowed: false,
+        parksTicketUntilCustomerReply: true,
+        nextCommands: ['review_customer_clarification', 'send_after_human_review', 'park_ticket_until_customer_reply'],
+        forbiddenActions: [
+            'Do not run product repair from a guessed reproduction path.',
+            'Do not ask multiple customer questions in one automated clarification.',
+            'Do not mark the ticket resolved from a clarification draft.'
+        ],
+        requiredEvidence: [
+            "missing_field=".concat(missingField),
+            'one customer-facing question',
+            'human approval before send',
+            'park_ticket_until_customer_reply'
+        ],
+        createdAt: createdAt
+    };
+}
+function validateResolveIOSupportClarificationContract(value) {
+    var source = cleanObject(value);
+    var missingField = cleanText(source.missingField || source.missing_field, 120);
+    var question = cleanText(source.question, 1000);
+    var sourceBlockers = cleanList(source.sourceBlockers || source.source_blockers, 20, 500);
+    var questionMarkCount = (question.match(/\?/g) || []).length;
+    var normalized = {
+        contractId: cleanText(source.contractId || source.contract_id, 160),
+        status: source.status === 'ready' ? 'ready' : 'blocked',
+        missingField: missingField,
+        question: question,
+        sourceBlockers: sourceBlockers,
+        oneQuestionOnly: source.oneQuestionOnly === true || source.one_question_only === true || questionMarkCount === 1,
+        customerFacingDraftAllowed: source.customerFacingDraftAllowed === true || source.customer_facing_draft_allowed === true,
+        customerSendAllowed: source.customerSendAllowed === true || source.customer_send_allowed === true,
+        parksTicketUntilCustomerReply: source.parksTicketUntilCustomerReply === true || source.parks_ticket_until_customer_reply === true,
+        nextCommands: cleanList(source.nextCommands || source.next_commands, 12, 200),
+        forbiddenActions: cleanList(source.forbiddenActions || source.forbidden_actions, 12, 500),
+        requiredEvidence: cleanList(source.requiredEvidence || source.required_evidence, 12, 500),
+        createdAt: cleanText(source.createdAt || source.created_at, 120)
+    };
+    var validMissingFields = [
+        'reproduction_blocker',
+        'expected_result',
+        'observed_result',
+        'account_customer_context',
+        'example_record_or_action_path'
+    ];
+    var blockers = [
+        normalized.contractId ? '' : 'Clarification contract is missing contractId.',
+        validMissingFields.includes(normalized.missingField) ? '' : 'Clarification contract is missing a valid missingField.',
+        question.length >= 20 && question.length <= 500 ? '' : 'Clarification question must be 20-500 characters.',
+        questionMarkCount === 1 && normalized.oneQuestionOnly ? '' : 'Clarification contract must contain exactly one customer question.',
+        normalized.customerFacingDraftAllowed === true ? '' : 'Clarification draft must be customer-facing so the operator can review it.',
+        normalized.customerSendAllowed === false ? '' : 'Clarification contract must never allow automatic customer send.',
+        normalized.parksTicketUntilCustomerReply === true ? '' : 'Clarification contract must park the ticket until customer reply.',
+        normalized.nextCommands.includes('park_ticket_until_customer_reply') ? '' : 'Clarification nextCommands must include park_ticket_until_customer_reply.',
+        normalized.forbiddenActions.length ? '' : 'Clarification contract must include forbiddenActions.'
+    ].filter(Boolean);
+    normalized.status = blockers.length ? 'blocked' : 'ready';
+    return {
+        valid: blockers.length === 0,
+        status: normalized.status,
+        blockers: blockers,
+        normalized: normalized
+    };
+}
 function buildResolveIOSupportHumanReviewPacket(input) {
     return {
         reviewType: input.reviewType,
@@ -1708,7 +1809,33 @@ function decideResolveIOSupportCustomerReplyPolicy(input) {
         var canAskCustomer = (gate === null || gate === void 0 ? void 0 : gate.issue_case.reproduction_status) === 'blocked'
             || diagnosisValidation.blockers.some(function (blocker) { return /expected_result|observed_result|account_customer_context/.test(blocker); });
         if (canAskCustomer) {
-            var clarificationQuestion = buildSupportClarificationQuestion(gate, diagnosisValidation.blockers);
+            var clarificationValidation = validateResolveIOSupportClarificationContract(buildResolveIOSupportClarificationContract(gate, diagnosisValidation.blockers));
+            var clarificationContract = clarificationValidation.normalized;
+            if (!clarificationValidation.valid) {
+                return {
+                    action: 'hold_internal',
+                    canDraftCustomerReply: false,
+                    canSendCustomerReply: false,
+                    confidenceLevel: confidenceLevel,
+                    safety: 'internal_hold',
+                    reason: 'support_reply_clarification_contract_invalid',
+                    requiredEvidence: requiredEvidence,
+                    clarificationContract: clarificationContract,
+                    humanReviewPacket: buildResolveIOSupportHumanReviewPacket({
+                        reviewType: 'internal_hold',
+                        title: 'Repair Clarification Contract',
+                        summary: 'Customer clarification is blocked until the one-question clarification contract validates.',
+                        primaryAction: 'repair_support_clarification_contract',
+                        safety: 'internal_hold',
+                        reason: 'support_reply_clarification_contract_invalid',
+                        blockers: clarificationValidation.blockers,
+                        requiredEvidence: requiredEvidence,
+                        nextCommands: ['repair_clarification_contract', 'rerun_reply_policy'],
+                        forbiddenActions: ['Do not send a malformed or multi-question clarification.'],
+                        costRisk: 'free_or_deterministic'
+                    })
+                };
+            }
             return {
                 action: 'ask_clarification',
                 canDraftCustomerReply: true,
@@ -1716,21 +1843,22 @@ function decideResolveIOSupportCustomerReplyPolicy(input) {
                 confidenceLevel: confidenceLevel,
                 safety: 'needs_clarification',
                 reason: 'support_reply_waiting_on_customer_reproduction_detail',
-                requiredEvidence: requiredEvidence,
-                clarificationQuestion: clarificationQuestion,
+                requiredEvidence: Array.from(new Set(__spreadArray(__spreadArray([], __read(requiredEvidence), false), __read(clarificationContract.requiredEvidence), false))),
+                clarificationQuestion: clarificationContract.question,
+                clarificationContract: clarificationContract,
                 humanReviewPacket: buildResolveIOSupportHumanReviewPacket({
                     reviewType: 'customer_clarification',
                     title: 'Review Customer Clarification',
                     summary: 'The runner needs one customer detail before it can reproduce or continue safely.',
                     primaryAction: 'review_customer_clarification',
-                    question: clarificationQuestion,
-                    customerFacingDraftAllowed: true,
+                    question: clarificationContract.question,
+                    customerFacingDraftAllowed: clarificationContract.customerFacingDraftAllowed,
                     safety: 'needs_clarification',
                     reason: 'support_reply_waiting_on_customer_reproduction_detail',
-                    blockers: diagnosisValidation.blockers,
-                    requiredEvidence: requiredEvidence,
-                    nextCommands: ['edit_clarification_question', 'send_after_human_review', 'park_ticket_until_customer_reply'],
-                    forbiddenActions: ['Do not run repair from a guessed reproduction path.'],
+                    blockers: clarificationContract.sourceBlockers,
+                    requiredEvidence: clarificationContract.requiredEvidence,
+                    nextCommands: clarificationContract.nextCommands,
+                    forbiddenActions: clarificationContract.forbiddenActions,
                     costRisk: 'release_or_customer_send'
                 })
             };
@@ -3673,6 +3801,7 @@ function decideResolveIOSupportV5AutonomousNextAction(input) {
             humanReviewPacket: humanReviewPacket,
             humanDecisionRequest: humanDecisionRequest,
             hotfixContinuation: fields.hotfixContinuation,
+            hotfixDurabilityContract: fields.hotfixDurabilityContract,
             recordedAt: isoNow(input.now)
         };
     };
@@ -3856,22 +3985,36 @@ function decideResolveIOSupportV5AutonomousNextAction(input) {
         var liveHotfixBlockedUntilCommit = hotfixContinuation.action === 'record_hotfix_evidence'
             || (hotfixGitGuard === null || hotfixGitGuard === void 0 ? void 0 : hotfixGitGuard.managerMustCommitBeforeHotfix) === true
             || ((hotfixGitGuard === null || hotfixGitGuard === void 0 ? void 0 : hotfixGitGuard.required) === true && (hotfixGitGuard === null || hotfixGitGuard === void 0 ? void 0 : hotfixGitGuard.passed) !== true);
-        var canPrepareHotfixPatch = hotfixContinuation.action !== 'park_manual';
+        var hotfixDurabilityContract = (0, ai_runner_manager_policy_1.buildResolveIOAIManagerHotfixDurabilityContract)({
+            action: 'run_release_repair',
+            reason: releaseBlocker,
+            evidence: input.hotfixEvidence,
+            policy: input.releasePolicy,
+            continuation: hotfixContinuation,
+            releaseGatePassed: input.releaseGatePassed,
+            source: 'support_v5_autonomous_decision',
+            now: input.now
+        });
         return makeDecision('repair_release_hotfix_first', 'Hotfix Release', 'support_v5_release_blocked_hotfix_first', {
             canRunAutonomously: hotfixContinuation.action !== 'park_manual',
             canRunModel: false,
             canEditProductCode: false,
-            canPrepareHotfixPatch: canPrepareHotfixPatch,
-            canHotfixBackend: canPrepareHotfixPatch && !liveHotfixBlockedUntilCommit,
-            liveHotfixBlockedUntilCommit: liveHotfixBlockedUntilCommit,
+            canPrepareHotfixPatch: hotfixDurabilityContract.canPrepareHotfixPatch,
+            canHotfixBackend: hotfixDurabilityContract.canHotfixBackend,
+            liveHotfixBlockedUntilCommit: hotfixDurabilityContract.liveHotfixBlockedUntilCommit || liveHotfixBlockedUntilCommit,
             lane: 'release',
             stepType: 'release_gate',
-            primaryCommand: hotfixPrimaryCommandByAction[hotfixContinuation.action] || 'record_hotfix_evidence',
+            primaryCommand: hotfixDurabilityContract.liveHotfixBlockedUntilCommit
+                ? 'record_hotfix_evidence'
+                : hotfixPrimaryCommandByAction[hotfixContinuation.action] || hotfixDurabilityContract.nextSafeAction || 'record_hotfix_evidence',
             nextCommands: hotfixNextCommands,
-            requiredEvidence: hotfixRequiredEvidence,
-            blockers: Array.from(new Set(__spreadArray(__spreadArray([], __read(cleanList(input.unresolvedBlockers, 20, 500)), false), __read(hotfixContinuation.blockers), false))),
-            forbiddenActions: hotfixForbiddenActions,
-            hotfixContinuation: hotfixContinuation
+            requiredEvidence: Array.from(new Set(__spreadArray(__spreadArray([], __read(hotfixRequiredEvidence), false), __read(hotfixDurabilityContract.requiredEvidence), false))).slice(0, 30),
+            blockers: Array.from(new Set(__spreadArray(__spreadArray(__spreadArray([], __read(cleanList(input.unresolvedBlockers, 20, 500)), false), __read(hotfixContinuation.blockers), false), __read((hotfixDurabilityContract.liveHotfixBlockedUntilCommit
+                ? ["Hotfix durability contract ".concat(hotfixDurabilityContract.contractId, " requires GitHub commit and push proof before live backend apply.")]
+                : [])), false))),
+            forbiddenActions: Array.from(new Set(__spreadArray(__spreadArray([], __read(hotfixForbiddenActions), false), __read(hotfixDurabilityContract.forbiddenActions), false))).slice(0, 20),
+            hotfixContinuation: hotfixContinuation,
+            hotfixDurabilityContract: hotfixDurabilityContract
         });
     }
     if (customerReplyPolicy.action === 'hold_internal' && customerReplyPolicy.reason === 'support_reply_blocked_until_release_or_hotfix_gate_finishes') {