@resolveio/server-lib 22.3.182 → 22.3.183

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resolveio/server-lib",
-  "version": "22.3.182",
+  "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;
@@ -725,6 +761,7 @@ export interface ResolveIOSupportV5AutonomousDecision {
     continuationProofCheckpoint: ResolveIOSupportContinuationProofCheckpoint;
     nextActionContract: ResolveIOSupportNextActionContract;
     humanReviewPacket: ResolveIOSupportHumanReviewPacket;
+    humanDecisionRequest?: ResolveIOSupportHumanDecisionRequest;
     hotfixContinuation?: ResolveIOAIManagerHotfixContinuationDecision;
     recordedAt: string;
 }

package/util/support-runner-v5.js

@@ -3246,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;
@@ -3291,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,
@@ -3329,6 +3452,7 @@ function decideResolveIOSupportV5AutonomousNextAction(input) {
             continuationProofCheckpoint: continuationProofCheckpoint,
             nextActionContract: nextActionContract,
             humanReviewPacket: humanReviewPacket,
+            humanDecisionRequest: humanDecisionRequest,
             hotfixContinuation: fields.hotfixContinuation,
             recordedAt: isoNow(input.now)
         };