@resolveio/server-lib 22.3.190 → 22.3.191

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

@@ -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;
@@ -835,6 +852,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'
                 })
             };