@resolveio/server-lib 22.3.199 → 22.3.201

package/util/ai-run-evidence.js

@@ -353,6 +353,7 @@ function addGateOnce(gates, gate) {
 }
 function classifyAIRunOutcome(input) {
     var e_4, _a;
+    var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
     if (input === void 0) { input = {}; }
     var now = isoNow(input.now);
     var gates = Array.isArray(input.gates) ? __spreadArray([], __read(input.gates), false) : [];
@@ -360,19 +361,91 @@ function classifyAIRunOutcome(input) {
     var qa = normalizeQaRun(input.qa);
     if (qa) {
         try {
-            for (var _b = __values(qa.gateResults), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var gate = _c.value;
+            for (var _z = __values(qa.gateResults), _0 = _z.next(); !_0.done; _0 = _z.next()) {
+                var gate = _0.value;
                 addGateOnce(gates, gate);
             }
         }
         catch (e_4_1) { e_4 = { error: e_4_1 }; }
         finally {
             try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                if (_0 && !_0.done && (_a = _z.return)) _a.call(_z);
             }
             finally { if (e_4) throw e_4.error; }
         }
     }
+    var supportParkedByStatus = input.source === 'support_ticket'
+        && (input.manualHandoff === true || input.stopped === true || /stop|stopped|cancel|cancelled|paused|handoff/i.test("".concat(input.status || '', " ").concat(input.phase || '')));
+    if (supportParkedByStatus) {
+        var blockedSupportAutoloopNoProgressGate_1 = gates.find(function (gate) { return gate.key === 'support_autoloop_no_progress' && gate.status === 'blocked'; });
+        if (blockedSupportAutoloopNoProgressGate_1) {
+            return {
+                outcome: 'manual_handoff',
+                reason: "Support autoloop parked before another repair loop because no new evidence was recorded: ".concat(blockedSupportAutoloopNoProgressGate_1.reason),
+                nextAction: 'Collect new material evidence, rerun read-only diagnosis or issue-class proof, then resume only if the blocker fingerprint changes.',
+                gates: gates,
+                warnings: warnings,
+                recordedAt: now
+            };
+        }
+        var blockedSupportAutoloopApprovalGate_1 = gates.find(function (gate) { return gate.key === 'support_autoloop_approval_block' && gate.status === 'blocked'; });
+        if (blockedSupportAutoloopApprovalGate_1) {
+            var nextAction = cleanText((_b = blockedSupportAutoloopApprovalGate_1.metadata) === null || _b === void 0 ? void 0 : _b.nextAction, 160)
+                || cleanText((_c = blockedSupportAutoloopApprovalGate_1.metadata) === null || _c === void 0 ? void 0 : _c.action, 160);
+            var elapsedReapproval = ((_d = blockedSupportAutoloopApprovalGate_1.metadata) === null || _d === void 0 ? void 0 : _d.requiresElapsedReapproval) === true;
+            return {
+                outcome: 'manual_handoff',
+                reason: "Support autoloop parked before another repair loop because approval/scope is blocked: ".concat(blockedSupportAutoloopApprovalGate_1.reason),
+                nextAction: elapsedReapproval
+                    ? 'Approve continued runtime beyond the current wall-clock boundary or park the ticket for manual review; do not run another model/code/QA continuation until that decision is recorded.'
+                    : nextAction
+                        ? "Run ".concat(nextAction, " or revise the blocked scope, then resume the approved autoloop toward A-grade QA/business proof.")
+                        : 'Approve the blocked support autonomy scope or revise the diagnosis, owner files, planned change, estimate, or classification before the autoloop continues.',
+                gates: gates,
+                warnings: warnings,
+                recordedAt: now
+            };
+        }
+        var blockedSupportAutonomyApprovalGate_1 = gates.find(function (gate) { return gate.key === 'support_autonomy_approval' && gate.status === 'blocked'; });
+        if (blockedSupportAutonomyApprovalGate_1) {
+            return {
+                outcome: 'manual_handoff',
+                reason: "Support autonomy is waiting on operator approval or revised intake/diagnosis scope: ".concat(blockedSupportAutonomyApprovalGate_1.reason),
+                nextAction: ((_e = blockedSupportAutonomyApprovalGate_1.metadata) === null || _e === void 0 ? void 0 : _e.approvalAction)
+                    ? "Use ".concat(blockedSupportAutonomyApprovalGate_1.metadata.approvalAction, " or revise the blocked scope, then allow the runner to continue until A-grade QA/business proof.")
+                    : 'Approve the bounded support autonomy request or revise classification, estimate, owner files, or diagnosis scope before product-code repair.',
+                gates: gates,
+                warnings: warnings,
+                recordedAt: now
+            };
+        }
+        var blockedSupportProductRepairDispatchGate_1 = gates.find(function (gate) { return gate.key === 'support_product_repair_dispatch_guard' && gate.status === 'blocked'; });
+        if (blockedSupportProductRepairDispatchGate_1) {
+            return {
+                outcome: 'manual_handoff',
+                reason: "Support product-code repair dispatch is blocked by the approval/scope guard: ".concat(blockedSupportProductRepairDispatchGate_1.reason),
+                nextAction: ((_f = blockedSupportProductRepairDispatchGate_1.metadata) === null || _f === void 0 ? void 0 : _f.nextAction)
+                    ? "Run ".concat(blockedSupportProductRepairDispatchGate_1.metadata.nextAction, " before product-code repair continues.")
+                    : 'Approve the current support autonomy scope or revise the diagnosis/owner-file set before product-code repair continues.',
+                gates: gates,
+                warnings: warnings,
+                recordedAt: now
+            };
+        }
+        var blockedSupportHumanDecisionGate_1 = gates.find(function (gate) { return gate.key === 'support_human_decision_request' && gate.status === 'blocked'; });
+        if (blockedSupportHumanDecisionGate_1) {
+            return {
+                outcome: 'manual_handoff',
+                reason: "Support run is waiting on a specific operator decision: ".concat(blockedSupportHumanDecisionGate_1.reason),
+                nextAction: ((_g = blockedSupportHumanDecisionGate_1.metadata) === null || _g === void 0 ? void 0 : _g.preferredChoiceId)
+                    ? "Choose ".concat(blockedSupportHumanDecisionGate_1.metadata.preferredChoiceId, " or an equivalent safe console action, then resume the runner.")
+                    : 'Answer the requested support runner decision, then resume the runner.',
+                gates: gates,
+                warnings: warnings,
+                recordedAt: now
+            };
+        }
+    }
     if (input.manualHandoff === true) {
         return {
             outcome: 'manual_handoff',
@@ -425,6 +498,17 @@ function classifyAIRunOutcome(input) {
             recordedAt: now
         };
     }
+    var blockedSupportAutoloopNoProgressGate = gates.find(function (gate) { return gate.key === 'support_autoloop_no_progress' && gate.status === 'blocked'; });
+    if (input.source === 'support_ticket' && blockedSupportAutoloopNoProgressGate) {
+        return {
+            outcome: 'manual_handoff',
+            reason: "Support autoloop parked before another repair loop because no new evidence was recorded: ".concat(blockedSupportAutoloopNoProgressGate.reason),
+            nextAction: 'Collect new material evidence, rerun read-only diagnosis or issue-class proof, then resume only if the blocker fingerprint changes.',
+            gates: gates,
+            warnings: warnings,
+            recordedAt: now
+        };
+    }
     var blockedSupportDiagnosisBeforeRepairGate = gates.find(function (gate) { return gate.key === 'support_diagnosis_before_repair' && gate.status === 'blocked'; });
     if (blockedSupportDiagnosisBeforeRepairGate) {
         return {
@@ -447,6 +531,110 @@ function classifyAIRunOutcome(input) {
             recordedAt: now
         };
     }
+    var blockedSupportIntakeRevisionGate = gates.find(function (gate) { return gate.key === 'support_intake_revision_contract' && gate.status === 'blocked'; });
+    if (input.source === 'support_ticket' && blockedSupportIntakeRevisionGate) {
+        var requiredOperatorAction = cleanText((_h = blockedSupportIntakeRevisionGate.metadata) === null || _h === void 0 ? void 0 : _h.requiredOperatorAction, 160);
+        return {
+            outcome: 'manual_handoff',
+            reason: "Support intake/classification changed after approval: ".concat(blockedSupportIntakeRevisionGate.reason),
+            nextAction: requiredOperatorAction
+                ? "Run ".concat(requiredOperatorAction, " to approve the revised intake/scope before product-code repair continues.")
+                : 'Approve the revised support intake/scope before product-code repair continues.',
+            gates: gates,
+            warnings: warnings,
+            recordedAt: now
+        };
+    }
+    var blockedSupportAutoloopApprovalGate = gates.find(function (gate) { return gate.key === 'support_autoloop_approval_block' && gate.status === 'blocked'; });
+    if (input.source === 'support_ticket' && blockedSupportAutoloopApprovalGate) {
+        var nextAction = cleanText((_j = blockedSupportAutoloopApprovalGate.metadata) === null || _j === void 0 ? void 0 : _j.nextAction, 160)
+            || cleanText((_k = blockedSupportAutoloopApprovalGate.metadata) === null || _k === void 0 ? void 0 : _k.action, 160);
+        var elapsedReapproval = ((_l = blockedSupportAutoloopApprovalGate.metadata) === null || _l === void 0 ? void 0 : _l.requiresElapsedReapproval) === true;
+        return {
+            outcome: 'manual_handoff',
+            reason: "Support autoloop parked before another repair loop because approval/scope is blocked: ".concat(blockedSupportAutoloopApprovalGate.reason),
+            nextAction: elapsedReapproval
+                ? 'Approve continued runtime beyond the current wall-clock boundary or park the ticket for manual review; do not run another model/code/QA continuation until that decision is recorded.'
+                : nextAction
+                    ? "Run ".concat(nextAction, " or revise the blocked scope, then resume the approved autoloop toward A-grade QA/business proof.")
+                    : 'Approve the blocked support autonomy scope or revise the diagnosis, owner files, planned change, estimate, or classification before the autoloop continues.',
+            gates: gates,
+            warnings: warnings,
+            recordedAt: now
+        };
+    }
+    var blockedSupportAutonomyApprovalGate = gates.find(function (gate) { return gate.key === 'support_autonomy_approval' && gate.status === 'blocked'; });
+    if (input.source === 'support_ticket' && blockedSupportAutonomyApprovalGate) {
+        return {
+            outcome: 'manual_handoff',
+            reason: "Support autonomy is waiting on operator approval or revised intake/diagnosis scope: ".concat(blockedSupportAutonomyApprovalGate.reason),
+            nextAction: ((_m = blockedSupportAutonomyApprovalGate.metadata) === null || _m === void 0 ? void 0 : _m.approvalAction)
+                ? "Use ".concat(blockedSupportAutonomyApprovalGate.metadata.approvalAction, " or revise the blocked scope, then allow the runner to continue until A-grade QA/business proof.")
+                : 'Approve the bounded support autonomy request or revise classification, estimate, owner files, or diagnosis scope before product-code repair.',
+            gates: gates,
+            warnings: warnings,
+            recordedAt: now
+        };
+    }
+    var blockedSupportProductRepairDispatchGate = gates.find(function (gate) { return gate.key === 'support_product_repair_dispatch_guard' && gate.status === 'blocked'; });
+    if (input.source === 'support_ticket' && blockedSupportProductRepairDispatchGate) {
+        return {
+            outcome: 'manual_handoff',
+            reason: "Support product-code repair dispatch is blocked by the approval/scope guard: ".concat(blockedSupportProductRepairDispatchGate.reason),
+            nextAction: ((_o = blockedSupportProductRepairDispatchGate.metadata) === null || _o === void 0 ? void 0 : _o.nextAction)
+                ? "Run ".concat(blockedSupportProductRepairDispatchGate.metadata.nextAction, " before product-code repair continues.")
+                : 'Approve the current support autonomy scope or revise the diagnosis/owner-file set before product-code repair continues.',
+            gates: gates,
+            warnings: warnings,
+            recordedAt: now
+        };
+    }
+    var blockedSupportHumanDecisionGate = gates.find(function (gate) { return gate.key === 'support_human_decision_request' && gate.status === 'blocked'; });
+    if (input.source === 'support_ticket' && blockedSupportHumanDecisionGate) {
+        return {
+            outcome: 'manual_handoff',
+            reason: "Support run is waiting on a specific operator decision: ".concat(blockedSupportHumanDecisionGate.reason),
+            nextAction: ((_p = blockedSupportHumanDecisionGate.metadata) === null || _p === void 0 ? void 0 : _p.preferredChoiceId)
+                ? "Choose ".concat(blockedSupportHumanDecisionGate.metadata.preferredChoiceId, " or an equivalent safe console action, then resume the runner.")
+                : 'Answer the requested support runner decision, then resume the runner.',
+            gates: gates,
+            warnings: warnings,
+            recordedAt: now
+        };
+    }
+    var blockedSupportPostApprovalResumeAttemptGate = gates.find(function (gate) { return gate.key === 'support_post_approval_resume_attempt' && gate.status === 'blocked'; });
+    if (input.source === 'support_ticket' && blockedSupportPostApprovalResumeAttemptGate) {
+        var nextAction = cleanText((_q = blockedSupportPostApprovalResumeAttemptGate.metadata) === null || _q === void 0 ? void 0 : _q.nextAction, 160);
+        var failureClass = cleanText((_r = blockedSupportPostApprovalResumeAttemptGate.metadata) === null || _r === void 0 ? void 0 : _r.failureClass, 160);
+        return {
+            outcome: 'manual_handoff',
+            reason: "Approved support autoloop resume did not start: ".concat(blockedSupportPostApprovalResumeAttemptGate.reason),
+            nextAction: nextAction
+                ? "Review ".concat(failureClass || 'resume blocker', " and run ").concat(nextAction, " only after the blocker fingerprint changes; product repair and customer reply remain blocked.")
+                : 'Review the approved autoloop resume blocker and require a changed blocker fingerprint before another retry.',
+            gates: gates,
+            warnings: warnings,
+            recordedAt: now
+        };
+    }
+    var blockedSupportPostApprovalAutostartGate = gates.find(function (gate) { return gate.key === 'support_post_approval_autostart' && gate.status === 'blocked'; });
+    if (input.source === 'support_ticket' && blockedSupportPostApprovalAutostartGate) {
+        var nextAction = cleanText((_s = blockedSupportPostApprovalAutostartGate.metadata) === null || _s === void 0 ? void 0 : _s.nextAction, 160);
+        var canRetryWithoutReapproval = ((_t = blockedSupportPostApprovalAutostartGate.metadata) === null || _t === void 0 ? void 0 : _t.canRetryWithoutReapproval) === true;
+        var safeRetryAction = cleanText((_u = blockedSupportPostApprovalAutostartGate.metadata) === null || _u === void 0 ? void 0 : _u.safeRetryAction, 160);
+        return {
+            outcome: 'manual_handoff',
+            reason: "Support autonomy was approved, but the post-approval autostart did not begin: ".concat(blockedSupportPostApprovalAutostartGate.reason),
+            nextAction: canRetryWithoutReapproval && safeRetryAction === 'run_autoloop'
+                ? 'Retry the approved auto-improve loop under the same approval/scope fingerprint; no product repair or customer reply is allowed until the loop starts and records proof.'
+                : nextAction === 'resolve_autostart_blocker'
+                    ? 'Resolve the autostart blocker or clear the active run, then rerun runSupportTicketAutoImproveLoopManual under the approved scope until A-grade PR proof.'
+                    : 'Review the post-approval autostart result, then resume the approved auto-improve loop without changing scope.',
+            gates: gates,
+            warnings: warnings,
+            recordedAt: now
+        };
+    }
     if ((qa === null || qa === void 0 ? void 0 : qa.outcome) === 'infra_failed') {
         return {
             outcome: 'qa_infra_failed',
@@ -582,6 +770,62 @@ function classifyAIRunOutcome(input) {
             recordedAt: now
         };
     }
+    var failedSupportPrCreationGate = gates.find(function (gate) { return gate.key === 'support_pr_creation_result' && (gate.status === 'fail' || gate.status === 'blocked'); });
+    if (input.source === 'support_ticket' && failedSupportPrCreationGate) {
+        return {
+            outcome: 'release_blocked',
+            reason: "Support PR creation is blocked after proof-ready work: ".concat(failedSupportPrCreationGate.reason),
+            nextAction: ((_v = failedSupportPrCreationGate.metadata) === null || _v === void 0 ? void 0 : _v.nextAction) === 'repair_pr_creation_blocker'
+                ? 'Repair the PR creation/release-safety blocker or route to platform repair; do not rerun product-code repair unless new issue evidence changes.'
+                : 'Check PR creation status before another repair loop.',
+            gates: gates,
+            warnings: warnings,
+            recordedAt: now
+        };
+    }
+    var blockedSupportAutopilotCompletionGate = gates.find(function (gate) { return gate.key === 'support_autopilot_completion_contract' && gate.status === 'blocked'; });
+    if (input.source === 'support_ticket' && blockedSupportAutopilotCompletionGate) {
+        var nextAction = cleanText((_w = blockedSupportAutopilotCompletionGate.metadata) === null || _w === void 0 ? void 0 : _w.nextAction, 160);
+        var missingEvidence = Array.isArray((_x = blockedSupportAutopilotCompletionGate.metadata) === null || _x === void 0 ? void 0 : _x.missingCompletionEvidence)
+            ? blockedSupportAutopilotCompletionGate.metadata.missingCompletionEvidence
+                .map(function (entry) { return cleanText(entry, 240); })
+                .filter(Boolean)
+            : [];
+        var outcome = nextAction === 'create_pr'
+            ? 'release_blocked'
+            : (input.explicitAccepted === true || scorecardPassed || statusLooksPassed("".concat(input.status || '', " ").concat(input.phase || '')) || hasBusinessPass)
+                ? 'false_pass'
+                : 'qa_incomplete';
+        return {
+            outcome: outcome,
+            reason: "Approved support autopilot has not reached A-grade PR proof: ".concat(blockedSupportAutopilotCompletionGate.reason),
+            nextAction: nextAction === 'create_pr'
+                ? 'Create the proof-backed support PR; merge, release, deploy, and customer reply remain separately gated.'
+                : nextAction === 'run_business_proof_qa'
+                    ? 'Run issue-specific business proof QA until AIQaBusinessAssertion, before/action/after proof, and screenshot/trace evidence pass.'
+                    : nextAction === 'run_a_grade_pr_review'
+                        ? 'Run strict A-grade PR review; do not merge, release, deploy, or send the customer reply until execution, artifact, pull_request, business-proof, and screenshot/trace evidence pass.'
+                        : 'Continue only the bounded owner-scoped support workflow until PR readiness or a new blocker/scope change.',
+            gates: gates,
+            warnings: missingEvidence.length
+                ? __spreadArray(__spreadArray([], __read(warnings), false), __read(missingEvidence.map(function (entry) { return "missing_completion_evidence:".concat(entry); })), false) : warnings,
+            recordedAt: now
+        };
+    }
+    var blockedSupportReleaseCustomerGate = gates.find(function (gate) { return gate.key === 'support_release_customer_acceptance' && (gate.status === 'blocked' || gate.status === 'fail'); });
+    if (input.source === 'support_ticket' && blockedSupportReleaseCustomerGate) {
+        var nextAction = cleanText((_y = blockedSupportReleaseCustomerGate.metadata) === null || _y === void 0 ? void 0 : _y.nextAction, 160);
+        return {
+            outcome: 'release_blocked',
+            reason: "Support PR proof is ready, but release/customer acceptance is incomplete: ".concat(blockedSupportReleaseCustomerGate.reason),
+            nextAction: nextAction === 'draft_or_review_proof_backed_customer_reply'
+                ? 'Draft or review the proof-backed customer reply from the accepted QA/release evidence; do not rerun product-code repair unless new issue evidence appears.'
+                : 'Complete the release/hotfix gate for the A-grade PR, then generate or review the proof-backed customer reply.',
+            gates: gates,
+            warnings: warnings,
+            recordedAt: now
+        };
+    }
     var blockedAICoderNextActionContractGate = gates.find(function (gate) { return gate.key === 'aicoder_next_action_contract' && (gate.status === 'blocked' || gate.status === 'fail'); });
     if (input.source === 'aicoder_app' && blockedAICoderNextActionContractGate) {
         var claimedSuccess = input.explicitAccepted === true