@resolveio/server-lib 22.3.168 → 22.3.170

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

@@ -549,6 +549,45 @@ export interface ResolveIOSupportRootCauseReadiness {
     artifactFingerprint?: string;
     proofFreshness?: ResolveIOSupportBusinessProofReadiness['proofFreshness'];
 }
+export type ResolveIOSupportNextActionCostRisk = 'free_or_deterministic' | 'small_model_or_qa' | 'expensive_model' | 'release_or_customer_send' | 'manual_blocked';
+export interface ResolveIOSupportNextActionContract {
+    contractId: string;
+    action: ResolveIOSupportV5AutonomousNextAction;
+    label: string;
+    primaryCommand: string;
+    lane: ResolveIOSupportV5Lane | 'release' | 'customer';
+    stepType: ResolveIOSupportV5StepType | 'release_gate' | 'customer_reply';
+    safeToAutoRun: boolean;
+    requiresHumanApproval: boolean;
+    canRunWithoutCodexMonitor: boolean;
+    codexFallbackRequired: boolean;
+    codexFallbackReason: string;
+    costRisk: ResolveIOSupportNextActionCostRisk;
+    rootCauseFirstSatisfied: boolean;
+    decisionBasis: {
+        diagnosisValid: boolean;
+        ownerFilesReady: boolean;
+        proofPlanReady: boolean;
+        businessProofReady: boolean;
+        evidenceFreshnessStatus: ResolveIOSupportEvidenceFreshnessStatus;
+        evidenceStrength: ResolveIOAIManagerEvidenceStrength;
+        failureClass: string;
+        blockerFingerprint: string;
+        evidenceHash: string;
+        sameFailureCount: number;
+        hotfixCommitRequired: boolean;
+        liveHotfixBlockedUntilCommit: boolean;
+    };
+    preconditions: string[];
+    expectedStateTransition: string;
+    successEvidence: string[];
+    stopConditions: string[];
+    forbiddenActions: string[];
+    ownerFiles: string[];
+    blockers: string[];
+    nextCommands: string[];
+    createdAt: string;
+}
 export interface ResolveIOSupportV5AutonomousDecisionInput {
     bundle: ResolveIOSupportV5StateBundle;
     changedFiles?: any;
@@ -606,6 +645,7 @@ export interface ResolveIOSupportV5AutonomousDecision {
     evidenceFreshness: ResolveIOSupportEvidenceFreshness;
     rootCauseReadiness: ResolveIOSupportRootCauseReadiness;
     continuationProofCheckpoint: ResolveIOSupportContinuationProofCheckpoint;
+    nextActionContract: ResolveIOSupportNextActionContract;
     humanReviewPacket: ResolveIOSupportHumanReviewPacket;
     hotfixContinuation?: ResolveIOAIManagerHotfixContinuationDecision;
     recordedAt: string;

package/util/support-runner-v5.js

@@ -2512,6 +2512,138 @@ function decideResolveIOSupportV5AutonomousNextAction(input) {
             proofFreshness: businessProofReadiness.proofFreshness
         };
     };
+    var nextActionExpectedTransition = function (action, primaryCommand) {
+        if (action === 'run_diagnosis_gate') {
+            return 'SupportDiagnosisGate changes from missing/incomplete to passed, blocked with one clarification question, or rejected with explicit blockers; no source files are edited.';
+        }
+        if (action === 'ask_customer_clarification') {
+            return 'One customer clarification question is prepared for human review and the ticket parks until the missing reproduction/account context is supplied.';
+        }
+        if (action === 'repair_infra_only') {
+            return 'Infra/preflight evidence changes or passes without charging the failure as product-code repair.';
+        }
+        if (action === 'revise_diagnosis_scope') {
+            return 'SupportDiagnosisGate owner_files, failing_path, and proof_plan are revised together with new evidence before any broader edit.';
+        }
+        if (action === 'run_owner_scoped_repair') {
+            return 'Only diagnosis owner_files change, a compile/unit gate is recorded, and the next state is business proof QA rather than acceptance.';
+        }
+        if (action === 'run_business_proof_qa') {
+            return 'A fresh AIQaBusinessAssertion maps to the active proof_plan and records before/action/after DOM, data, or Mongo proof.';
+        }
+        if (action === 'repair_release_hotfix_first') {
+            return primaryCommand === 'record_hotfix_evidence'
+                ? 'Hotfix evidence is recorded with sourceCommitSha, githubCommitUrl, and passed gitPushStatus before any live backend apply or continuation.'
+                : 'The smallest release/hotfix gate changes state, with duplicate full deploy blocked unless force evidence is explicit.';
+        }
+        if (action === 'ready_for_release_gate') {
+            return 'Release gate records compile, business proof, and deployment readiness without treating route-only evidence as acceptance.';
+        }
+        if (action === 'draft_customer_reply') {
+            return 'A customer resolution draft is prepared from accepted business proof and remains unsent until human approval.';
+        }
+        if (action === 'collect_new_evidence') {
+            return 'The next run records a changed blocker fingerprint, changed evidence hash, fresh artifact path, or explicit business/infra/compile/release proof.';
+        }
+        return 'The runner stays parked until a human changes scope, budget, evidence, or autonomy policy.';
+    };
+    var buildNextActionContract = function (action, label, reason, fields, rootCauseReadiness, continuationProofCheckpoint, primaryCommand, nextCommands, requiredEvidence, forbiddenActions, blockers) {
+        var lane = (fields.lane || (activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.lane) || 'supervisor');
+        var stepType = (fields.stepType || activeStepType);
+        var liveHotfixBlockedUntilCommit = fields.liveHotfixBlockedUntilCommit === true;
+        var hotfixCommitRequired = action === 'repair_release_hotfix_first'
+            || liveHotfixBlockedUntilCommit
+            || fields.canHotfixBackend === true;
+        var requiresHumanApproval = action === 'park_manual'
+            || action === 'ask_customer_clarification'
+            || rootCauseReadiness.requiresHumanDecision === true;
+        var safeToAutoRun = fields.canRunAutonomously === true
+            && !requiresHumanApproval
+            && (action !== 'run_owner_scoped_repair' || (rootCauseReadiness.rootCauseFirstSatisfied === true && evidenceFreshness.mustCollectNewEvidence !== true))
+            && (action !== 'repair_release_hotfix_first' || primaryCommand !== 'apply_backend_hotfix_only_after_commit_proof' || liveHotfixBlockedUntilCommit !== true);
+        var costRisk = requiresHumanApproval
+            ? 'manual_blocked'
+            : (fields.canHotfixBackend === true || action === 'draft_customer_reply')
+                ? 'release_or_customer_send'
+                : fields.canRunModel === true
+                    ? 'expensive_model'
+                    : fields.canRunQa === true
+                        ? 'small_model_or_qa'
+                        : 'free_or_deterministic';
+        var canRunWithoutCodexMonitor = safeToAutoRun
+            && continuationProofCheckpoint.required === true
+            && forbiddenActions.length > 0
+            && (requiredEvidence.length > 0 || action === 'repair_infra_only' || action === 'run_diagnosis_gate');
+        var codexFallbackRequired = !canRunWithoutCodexMonitor && !requiresHumanApproval;
+        var codexFallbackReason = codexFallbackRequired
+            ? (blockers[0] || continuationProofCheckpoint.reason || 'next_action_contract_missing_required_evidence')
+            : requiresHumanApproval
+                ? 'human_decision_required_not_codex_fallback'
+                : !canRunWithoutCodexMonitor
+                    ? 'structured_contract_blocks_auto_run_without_requesting_codex_monitor'
+                    : 'structured_next_action_contract_allows_manager_execution_without_external_codex_monitor';
+        var preconditions = Array.from(new Set(__spreadArray([
+            action !== 'run_diagnosis_gate' ? 'SupportDiagnosisGate validation checked before action.' : 'Diagnosis is read-only and cannot edit source files.',
+            action === 'run_owner_scoped_repair' ? 'Root-cause-first gate is satisfied and owner_files are the only editable product files.' : '',
+            action === 'run_business_proof_qa' ? 'Business proof QA must use the diagnosis proof_plan and generated issue-class probe.' : '',
+            action === 'repair_release_hotfix_first' ? 'Live backend hotfix is blocked until GitHub commit proof is recorded and passed.' : '',
+            evidenceFreshness.mustCollectNewEvidence === true ? 'Current failure is stale or repeated; only evidence collection is allowed until proof changes.' : ''
+        ], __read(requiredEvidence), false).filter(Boolean))).slice(0, 24);
+        var stopConditions = Array.from(new Set(__spreadArray([
+            'Stop if the same failure class, blocker fingerprint, and evidence hash repeat without material evidence.',
+            'Stop if the action would edit outside diagnosis owner_files without a revised diagnosis gate.',
+            'Stop if route-load, screenshot-only, scorecard-only, or model-claim proof is the only acceptance evidence.',
+            liveHotfixBlockedUntilCommit ? 'Stop before live backend hotfix until sourceCommitSha, githubCommitUrl, and passed gitPushStatus are recorded.' : ''
+        ], __read(continuationProofCheckpoint.requiredResetEvidence.map(function (entry) { return "Reset requires: ".concat(entry); })), false).filter(Boolean))).slice(0, 24);
+        var createdAt = isoNow(input.now);
+        return {
+            contractId: "support-next-action-".concat(hashResolveIOSupportV5Evidence({
+                action: action,
+                primaryCommand: primaryCommand,
+                reason: reason,
+                blockers: blockers,
+                requiredEvidence: requiredEvidence,
+                evidenceFreshness: evidenceFreshness.evidenceHash,
+                blockerFingerprint: evidenceFreshness.blockerFingerprint,
+                createdAt: createdAt.slice(0, 16)
+            }).slice(0, 16)),
+            action: action,
+            label: label,
+            primaryCommand: primaryCommand,
+            lane: lane,
+            stepType: stepType,
+            safeToAutoRun: safeToAutoRun,
+            requiresHumanApproval: requiresHumanApproval,
+            canRunWithoutCodexMonitor: canRunWithoutCodexMonitor,
+            codexFallbackRequired: codexFallbackRequired,
+            codexFallbackReason: codexFallbackReason,
+            costRisk: costRisk,
+            rootCauseFirstSatisfied: rootCauseReadiness.rootCauseFirstSatisfied === true,
+            decisionBasis: {
+                diagnosisValid: rootCauseReadiness.diagnosisValid === true,
+                ownerFilesReady: rootCauseReadiness.ownerFilesReady === true,
+                proofPlanReady: rootCauseReadiness.proofPlanReady === true,
+                businessProofReady: businessProofReadiness.ready === true,
+                evidenceFreshnessStatus: evidenceFreshness.status,
+                evidenceStrength: evidenceFreshness.evidenceStrength,
+                failureClass: evidenceFreshness.failureClass,
+                blockerFingerprint: evidenceFreshness.blockerFingerprint,
+                evidenceHash: evidenceFreshness.evidenceHash,
+                sameFailureCount: evidenceFreshness.sameFailureCount,
+                hotfixCommitRequired: hotfixCommitRequired,
+                liveHotfixBlockedUntilCommit: liveHotfixBlockedUntilCommit
+            },
+            preconditions: preconditions,
+            expectedStateTransition: nextActionExpectedTransition(action, primaryCommand),
+            successEvidence: Array.from(new Set(requiredEvidence.length ? requiredEvidence : continuationProofCheckpoint.requiredEvidence)).slice(0, 24),
+            stopConditions: stopConditions,
+            forbiddenActions: forbiddenActions.slice(0, 24),
+            ownerFiles: ownerFiles.slice(0, 24),
+            blockers: blockers.slice(0, 24),
+            nextCommands: nextCommands.slice(0, 24),
+            createdAt: createdAt
+        };
+    };
     var makeDecision = function (action, label, reason, fields) {
         var _a;
         var primaryCommand = fields.primaryCommand || action;
@@ -2532,6 +2664,7 @@ function decideResolveIOSupportV5AutonomousNextAction(input) {
             requiredResetEvidence: fields.requiredEvidence,
             blocksProductRepair: evidenceFreshness.mustCollectNewEvidence === true
         });
+        var nextActionContract = buildNextActionContract(action, label, reason, fields, rootCauseReadiness, continuationProofCheckpoint, primaryCommand, nextCommands, requiredEvidence, forbiddenActions, blockers);
         var humanReviewPacket = fields.humanReviewPacket
             || (action === 'draft_customer_reply' && customerReplyPolicy.humanReviewPacket ? customerReplyPolicy.humanReviewPacket : undefined)
             || buildResolveIOSupportHumanReviewPacket({
@@ -2590,6 +2723,7 @@ function decideResolveIOSupportV5AutonomousNextAction(input) {
             evidenceFreshness: evidenceFreshness,
             rootCauseReadiness: rootCauseReadiness,
             continuationProofCheckpoint: continuationProofCheckpoint,
+            nextActionContract: nextActionContract,
             humanReviewPacket: humanReviewPacket,
             hotfixContinuation: fields.hotfixContinuation,
             recordedAt: isoNow(input.now)