@resolveio/server-lib 22.3.156 → 22.3.158

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

@@ -374,6 +374,52 @@ export interface ResolveIOSupportV5ContinuationDecision {
     recoveryEvidenceProbe: ResolveIOAIManagerRecoveryEvidenceProbe;
     recoveryAction: ResolveIOAIManagerRecoveryActionPacket;
 }
+export type ResolveIOSupportV5AutonomousNextAction = 'run_diagnosis_gate' | 'repair_infra_only' | 'revise_diagnosis_scope' | 'run_owner_scoped_repair' | 'run_business_proof_qa' | 'repair_release_hotfix_first' | 'collect_new_evidence' | 'draft_customer_reply' | 'ready_for_release_gate' | 'park_manual';
+export interface ResolveIOSupportV5AutonomousDecisionInput {
+    bundle: ResolveIOSupportV5StateBundle;
+    changedFiles?: any;
+    failureClass?: ResolveIOSupportV5FailureClass | string;
+    blocker?: any;
+    evidence?: any;
+    evidenceHash?: string;
+    outcomeLabel?: string;
+    confidence?: any;
+    businessAssertionStatus?: string;
+    businessProofArtifacts?: any[];
+    unresolvedBlockers?: any[];
+    releaseStatus?: string;
+    maxOwnerFiles?: number;
+    now?: Date | string;
+}
+export interface ResolveIOSupportV5AutonomousDecision {
+    action: ResolveIOSupportV5AutonomousNextAction;
+    label: string;
+    reason: string;
+    canRunAutonomously: boolean;
+    canEditProductCode: boolean;
+    canRunModel: boolean;
+    canRunQa: boolean;
+    canHotfixBackend: boolean;
+    canDraftCustomerReply: boolean;
+    canSendCustomerReply: boolean;
+    lane: ResolveIOSupportV5Lane | 'release' | 'customer';
+    stepType: ResolveIOSupportV5StepType | 'release_gate' | 'customer_reply';
+    microtaskId?: string;
+    primaryCommand: string;
+    nextCommands: string[];
+    requiredEvidence: string[];
+    forbiddenActions: string[];
+    blockers: string[];
+    ownerFiles: string[];
+    issueClass?: ResolveIOSupportIssueClass;
+    expectedProof?: string;
+    activeMicrotask?: ResolveIOSupportV5Microtask;
+    diagnosisValidation: ResolveIOSupportDiagnosisGateValidation;
+    repairGate: ResolveIOSupportV5RepairGateDecision;
+    continuation: ResolveIOSupportV5ContinuationDecision;
+    customerReplyPolicy: ResolveIOSupportCustomerReplyPolicy;
+    recordedAt: string;
+}
 export declare function evaluateResolveIOSupportDiagnosisEvidenceQuality(value: any): ResolveIOSupportDiagnosisEvidenceQuality;
 export declare function normalizeResolveIOSupportDiagnosisGate(value: any, now?: Date | string): ResolveIOSupportDiagnosisGate | undefined;
 export declare function extractResolveIOSupportDiagnosisGateFromText(value: string, now?: Date | string): ResolveIOSupportDiagnosisGate | undefined;
@@ -411,6 +457,7 @@ export declare function initializeResolveIOSupportV5State(input: ResolveIOSuppor
 export declare function recordResolveIOSupportV5Step(bundle: ResolveIOSupportV5StateBundle, step: ResolveIOSupportV5StepInput): ResolveIOSupportV5StateBundle;
 export declare function recordResolveIOSupportV5MicrotaskUsage(bundle: ResolveIOSupportV5StateBundle, usage: Omit<ResolveIOSupportV5MicrotaskUsage, 'recordedAt'>): ResolveIOSupportV5StateBundle;
 export declare function decideResolveIOSupportV5Continuation(bundle: ResolveIOSupportV5StateBundle): ResolveIOSupportV5ContinuationDecision;
+export declare function decideResolveIOSupportV5AutonomousNextAction(input: ResolveIOSupportV5AutonomousDecisionInput): ResolveIOSupportV5AutonomousDecision;
 export declare function buildResolveIOSupportV5DiagnoseFirstPrompt(lines: {
     goal?: string;
     approvedScope?: string[];

package/util/support-runner-v5.js

@@ -68,6 +68,7 @@ exports.initializeResolveIOSupportV5State = initializeResolveIOSupportV5State;
 exports.recordResolveIOSupportV5Step = recordResolveIOSupportV5Step;
 exports.recordResolveIOSupportV5MicrotaskUsage = recordResolveIOSupportV5MicrotaskUsage;
 exports.decideResolveIOSupportV5Continuation = decideResolveIOSupportV5Continuation;
+exports.decideResolveIOSupportV5AutonomousNextAction = decideResolveIOSupportV5AutonomousNextAction;
 exports.buildResolveIOSupportV5DiagnoseFirstPrompt = buildResolveIOSupportV5DiagnoseFirstPrompt;
 exports.buildResolveIOSupportV5MicrotaskPrompt = buildResolveIOSupportV5MicrotaskPrompt;
 exports.summarizeResolveIOSupportV5MicrotaskUsage = summarizeResolveIOSupportV5MicrotaskUsage;
@@ -1510,6 +1511,230 @@ function decideResolveIOSupportV5Continuation(bundle) {
     var recoveryPlan = recoveryPlanFor('continue', 'support_v5_continue');
     return __assign({ action: 'continue', reason: 'support_v5_continue', nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || bundle.supportV5SupervisorState.activeStep, repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, recoveryFieldsFor(recoveryPlan));
 }
+function decideResolveIOSupportV5AutonomousNextAction(input) {
+    var _a, _b, _c;
+    var bundle = input.bundle;
+    var activeMicrotask = selectResolveIOSupportV5ActiveMicrotask(bundle.supportV5MicrotaskLedger || [], bundle.supportV5ActiveMicrotaskId);
+    var diagnosisValidation = validateResolveIOSupportDiagnosisGate(bundle.supportV5DiagnosisGate, {
+        maxOwnerFiles: input.maxOwnerFiles
+    });
+    var activeStepType = cleanText((activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.type) || (!diagnosisValidation.valid ? bundle.supportV5SupervisorState.activeStep : 'cleanup') || 'diagnosis_gate', 80);
+    var repairGate = decideResolveIOSupportV5RepairGate({
+        diagnosisGate: bundle.supportV5DiagnosisGate,
+        activeStepType: activeStepType,
+        changedFiles: input.changedFiles,
+        failureClass: input.failureClass,
+        blocker: input.blocker,
+        evidence: input.evidence,
+        evidenceHash: input.evidenceHash,
+        history: bundle.supportV5StepHistory,
+        maxOwnerFiles: input.maxOwnerFiles,
+        allowTestsOutsideOwnerFiles: true
+    });
+    var continuation = decideResolveIOSupportV5Continuation(bundle);
+    var customerReplyPolicy = decideResolveIOSupportCustomerReplyPolicy({
+        diagnosisGate: bundle.supportV5DiagnosisGate,
+        outcomeLabel: input.outcomeLabel,
+        confidence: input.confidence,
+        businessAssertionStatus: input.businessAssertionStatus,
+        businessProofArtifacts: input.businessProofArtifacts,
+        unresolvedBlockers: input.unresolvedBlockers,
+        releaseStatus: input.releaseStatus
+    });
+    var ownerFiles = ((_a = diagnosisValidation.normalized) === null || _a === void 0 ? void 0 : _a.owner_files) || repairGate.ownerFiles || [];
+    var proofContract = (_b = diagnosisValidation.normalized) === null || _b === void 0 ? void 0 : _b.proof_plan.business_proof_contract;
+    var expectedProof = (proofContract === null || proofContract === void 0 ? void 0 : proofContract.data_or_dom_assertion)
+        || ((_c = diagnosisValidation.normalized) === null || _c === void 0 ? void 0 : _c.proof_plan.business_assertion)
+        || (activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.acceptanceProof)
+        || '';
+    var makeDecision = function (action, label, reason, fields) {
+        var _a;
+        return ({
+            action: action,
+            label: label,
+            reason: reason,
+            canRunAutonomously: fields.canRunAutonomously === true,
+            canEditProductCode: fields.canEditProductCode === true,
+            canRunModel: fields.canRunModel === true,
+            canRunQa: fields.canRunQa === true,
+            canHotfixBackend: fields.canHotfixBackend === true,
+            canDraftCustomerReply: fields.canDraftCustomerReply === true,
+            canSendCustomerReply: false,
+            lane: fields.lane || (activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.lane) || 'supervisor',
+            stepType: fields.stepType || activeStepType,
+            microtaskId: activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.microtaskId,
+            primaryCommand: fields.primaryCommand || action,
+            nextCommands: fields.nextCommands || [fields.primaryCommand || action],
+            requiredEvidence: fields.requiredEvidence || [],
+            forbiddenActions: Array.from(new Set(__spreadArray([
+                'Do not send customer email without explicit human approval.',
+                'Do not broaden owner_files without revised diagnosis evidence.',
+                'Do not accept route-load, screenshot-only, scorecard-only, or model-claim proof.'
+            ], __read((fields.forbiddenActions || [])), false))),
+            blockers: fields.blockers || [],
+            ownerFiles: ownerFiles,
+            issueClass: ((_a = diagnosisValidation.normalized) === null || _a === void 0 ? void 0 : _a.issue_class) || repairGate.issueClass,
+            expectedProof: expectedProof,
+            activeMicrotask: activeMicrotask,
+            diagnosisValidation: diagnosisValidation,
+            repairGate: repairGate,
+            continuation: continuation,
+            customerReplyPolicy: customerReplyPolicy,
+            recordedAt: isoNow(input.now)
+        });
+    };
+    if (continuation.action === 'park' && continuation.reason === 'support_v5_budget_guard') {
+        return makeDecision('park_manual', 'Park Manual', continuation.reason, {
+            canRunAutonomously: false,
+            lane: 'supervisor',
+            stepType: 'cleanup',
+            primaryCommand: 'park_support_ticket_for_manual_budget_review',
+            requiredEvidence: ['budget summary', 'latest blocker', 'operator decision'],
+            blockers: ['Support V5 budget guard is active.']
+        });
+    }
+    if (continuation.action === 'park') {
+        return makeDecision('collect_new_evidence', 'Collect New Evidence', continuation.reason, {
+            canRunAutonomously: true,
+            canRunModel: false,
+            canRunQa: true,
+            lane: (activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.lane) || 'qa',
+            stepType: activeStepType,
+            primaryCommand: 'run_support_v5_recovery_evidence_probe',
+            nextCommands: continuation.recoveryAction.nextCommands,
+            requiredEvidence: continuation.recoveryAction.requiredArtifacts,
+            blockers: [continuation.reason],
+            forbiddenActions: ['Do not run another product-code repair until blockerFingerprint or evidenceHash changes.']
+        });
+    }
+    if (repairGate.action === 'diagnose_only' || (activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.type) === 'diagnosis_gate' || !diagnosisValidation.valid) {
+        return makeDecision('run_diagnosis_gate', 'Run Diagnosis Gate', 'support_v5_root_cause_first_required', {
+            canRunAutonomously: true,
+            canRunModel: true,
+            canEditProductCode: false,
+            lane: 'build',
+            stepType: 'diagnosis_gate',
+            primaryCommand: 'run_support_v5_read_only_diagnosis_gate',
+            nextCommands: ['retrieve_similar_tickets_and_commits', 'run_reproduction_or_classification_probe', 'write_support_diagnosis_gate_json'],
+            requiredEvidence: [
+                'issue_case expected/observed/account context',
+                'accepted falsifiable hypothesis',
+                'rejected alternatives',
+                'failing path',
+                'small owner_files set',
+                'before/action/after business proof plan'
+            ],
+            blockers: repairGate.blockers,
+            forbiddenActions: ['No source edits during diagnosis.']
+        });
+    }
+    if (repairGate.action === 'infra_repair_only') {
+        return makeDecision('repair_infra_only', 'Repair Infra Only', 'support_v5_infra_failure_before_product_repair', {
+            canRunAutonomously: true,
+            canRunModel: false,
+            canEditProductCode: false,
+            canRunQa: true,
+            lane: 'qa',
+            stepType: activeStepType,
+            primaryCommand: 'run_support_v5_infra_repair',
+            nextCommands: ['rerun_puppeteer_compile_startup_preflight', 'repair_harness_or_cache_only', 'record_infra_artifact'],
+            requiredEvidence: ['preflight log', 'compile/startup/browser status', 'new infra blocker hash or pass'],
+            blockers: repairGate.blockers,
+            forbiddenActions: ['Do not charge infra failures as product-code repair failures.']
+        });
+    }
+    if (repairGate.action === 'reject_out_of_scope') {
+        return makeDecision('revise_diagnosis_scope', 'Revise Diagnosis Scope', 'support_v5_owner_scope_block', {
+            canRunAutonomously: true,
+            canRunModel: true,
+            canEditProductCode: false,
+            lane: 'build',
+            stepType: 'diagnosis_gate',
+            primaryCommand: 'revise_support_diagnosis_gate_with_new_owner_file_evidence',
+            nextCommands: ['attach_out_of_scope_diff', 'prove_new_owner_file_is_required', 'update_support_diagnosis_gate'],
+            requiredEvidence: ['new root-cause evidence for each added owner file'],
+            blockers: repairGate.blockers,
+            forbiddenActions: ['Do not edit files outside owner_files before diagnosis is revised.']
+        });
+    }
+    if (repairGate.action === 'park_repeated_failure') {
+        return makeDecision('collect_new_evidence', 'Collect New Evidence', 'support_v5_repeated_failure_needs_new_evidence', {
+            canRunAutonomously: true,
+            canRunModel: false,
+            canRunQa: true,
+            lane: (activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.lane) || 'qa',
+            stepType: activeStepType,
+            primaryCommand: 'run_support_v5_recovery_evidence_probe',
+            nextCommands: repairGate.recoveryAction.nextCommands,
+            requiredEvidence: repairGate.recoveryAction.requiredArtifacts,
+            blockers: repairGate.blockers,
+            forbiddenActions: ['Do not run another repair loop until new material evidence exists.']
+        });
+    }
+    if (supportReleaseLooksBlocked(input.releaseStatus)) {
+        return makeDecision('repair_release_hotfix_first', 'Hotfix Release', 'support_v5_release_blocked_hotfix_first', {
+            canRunAutonomously: true,
+            canRunModel: false,
+            canEditProductCode: false,
+            canHotfixBackend: true,
+            lane: 'release',
+            stepType: 'release_gate',
+            primaryCommand: 'run_support_release_hotfix_first_gate',
+            nextCommands: ['classify_release_blocker', 'hotfix_backend_or_release_artifact', 'record_github_commit_for_hotfix', 'rerun_release_gate_once'],
+            requiredEvidence: ['hotfix evidence', 'sourceCommitSha and githubCommitUrl', 'health/self-test pass', 'release gate result'],
+            blockers: cleanList(input.unresolvedBlockers, 20, 500)
+        });
+    }
+    if ((activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.lane) === 'qa' || /^(qa_row|qa_retest|business_proof|route_probe|issue_class_probe)$/.test(activeStepType)) {
+        return makeDecision('run_business_proof_qa', 'Run Business Proof QA', 'support_v5_business_assertion_required', {
+            canRunAutonomously: true,
+            canRunQa: true,
+            canRunModel: false,
+            canEditProductCode: false,
+            lane: 'qa',
+            stepType: /^(qa_row|qa_retest|business_proof|route_probe|issue_class_probe)$/.test(activeStepType) ? activeStepType : 'qa_row',
+            primaryCommand: 'run_support_v5_business_proof_qa_row',
+            nextCommands: ['start_local_stack_if_needed', 'execute_issue_class_probe', 'record_before_action_after_artifacts', 'write_aiqa_business_assertion'],
+            requiredEvidence: ['AIQaBusinessAssertion pass', 'DOM/data proof', 'artifact path', 'Mongo delta when data-changing'],
+            forbiddenActions: ['Route probe pass alone remains route evidence only.']
+        });
+    }
+    if (!activeMicrotask && customerReplyPolicy.action === 'draft_resolution_reply') {
+        return makeDecision('draft_customer_reply', 'Draft Customer Reply', customerReplyPolicy.reason, {
+            canRunAutonomously: true,
+            canRunModel: true,
+            canDraftCustomerReply: true,
+            lane: 'customer',
+            stepType: 'customer_reply',
+            primaryCommand: 'draft_support_customer_resolution_reply',
+            nextCommands: ['summarize_business_proof', 'draft_customer_reply_for_human_review'],
+            requiredEvidence: customerReplyPolicy.requiredEvidence,
+            forbiddenActions: ['Draft only; do not send.']
+        });
+    }
+    if (!activeMicrotask && supportBusinessAssertionPassed(input.businessAssertionStatus || input.outcomeLabel)) {
+        return makeDecision('ready_for_release_gate', 'Run Release Gate', 'support_v5_business_proof_complete_release_gate_ready', {
+            canRunAutonomously: true,
+            canRunQa: true,
+            lane: 'release',
+            stepType: 'release_gate',
+            primaryCommand: 'run_support_release_gate_once',
+            nextCommands: ['verify_compile_and_business_proof_artifacts', 'run_release_gate_once', 'record_release_status'],
+            requiredEvidence: ['compile pass', 'business assertion artifact', 'release status']
+        });
+    }
+    return makeDecision('run_owner_scoped_repair', 'Run Owner-Scoped Repair', 'support_v5_product_repair_allowed_after_diagnosis', {
+        canRunAutonomously: true,
+        canRunModel: true,
+        canEditProductCode: true,
+        lane: (activeMicrotask === null || activeMicrotask === void 0 ? void 0 : activeMicrotask.lane) || 'build',
+        stepType: activeStepType || 'build_repair',
+        primaryCommand: 'run_support_v5_owner_scoped_repair',
+        nextCommands: ['load_owner_files_only', 'apply_smallest_fix', 'run_smallest_compile_or_unit_gate', 'handoff_to_business_proof_qa'],
+        requiredEvidence: ['changed files within owner_files', 'compile/unit proof', 'next QA row'],
+        forbiddenActions: ['Do not edit outside owner_files unless diagnosis is revised with new evidence.']
+    });
+}
 function buildResolveIOSupportV5DiagnoseFirstPrompt(lines) {
     var _a, _b;
     return [