@resolveio/server-lib 22.3.190 → 22.3.192

package/util/ai-runner-manager-policy.d.ts

@@ -321,6 +321,71 @@ export interface ResolveIOAIManagerHotfixEvidenceRecord {
     readyForReleaseGate: boolean;
     readyForContinuation: boolean;
 }
+export type ResolveIOAIManagerHotfixDurabilityStatus = 'not_required' | 'waiting_for_commit_proof' | 'ready_for_live_hotfix' | 'ready_for_release_gate' | 'ready_for_continuation';
+export interface ResolveIOAIManagerHotfixDurabilityContractInput {
+    action?: string;
+    reason?: string;
+    evidence?: any;
+    policy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
+    continuation?: Partial<ResolveIOAIManagerHotfixContinuationDecision> | null;
+    existing?: any;
+    source?: string;
+    releaseGatePassed?: boolean;
+    now?: Date | string;
+}
+export interface ResolveIOAIManagerHotfixDurabilityContract {
+    contractId: string;
+    contract_id: string;
+    createdAt: string;
+    created_at: string;
+    updatedAt: string;
+    updated_at: string;
+    source: string;
+    required: boolean;
+    action: string;
+    status: ResolveIOAIManagerHotfixDurabilityStatus;
+    reason: string;
+    canPrepareHotfixPatch: boolean;
+    can_prepare_hotfix_patch: boolean;
+    canHotfixBackend: boolean;
+    can_hotfix_backend: boolean;
+    liveHotfixBlockedUntilCommit: boolean;
+    live_hotfix_blocked_until_commit: boolean;
+    commitProofPassed: boolean;
+    commit_proof_passed: boolean;
+    commitProofStatus: ResolveIOAIManagerHotfixGitProofStatus | 'missing';
+    commit_proof_status: ResolveIOAIManagerHotfixGitProofStatus | 'missing';
+    sourceCommitSha: string;
+    source_commit_sha: string;
+    githubCommitUrl: string;
+    github_commit_url: string;
+    gitCommitStatus: string;
+    git_commit_status: string;
+    gitPushStatus: string;
+    git_push_status: string;
+    missingCommitProofFields: string[];
+    missing_commit_proof_fields: string[];
+    nextSafeAction: string;
+    next_safe_action: string;
+    phaseOrder: string[];
+    phase_order: string[];
+    requiredFields: string[];
+    required_fields: string[];
+    requiredEvidence: string[];
+    required_evidence: string[];
+    successCriteria: string[];
+    success_criteria: string[];
+    forbiddenActions: string[];
+    forbidden_actions: string[];
+    hotfixCommitGuard: Record<string, any>;
+    hotfix_commit_guard: Record<string, any>;
+    githubCommitGuard: ResolveIOAIManagerHotfixGitProof;
+    github_commit_guard: ResolveIOAIManagerHotfixGitProof;
+    validation: ResolveIOAIManagerHotfixEvidenceValidation;
+    continuation?: Partial<ResolveIOAIManagerHotfixContinuationDecision> | null;
+    extraRequest: string;
+    extra_request: string;
+}
 export interface ResolveIOAIManagerRecoveryActionPacket {
     actionId: string;
     checkpointId: string;
@@ -634,6 +699,7 @@ export declare function validateResolveIOAIManagerHotfixEvidence(value: any, opt
     policy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
 }): ResolveIOAIManagerHotfixEvidenceValidation;
 export declare function buildResolveIOAIManagerHotfixEvidenceRecord(input?: ResolveIOAIManagerHotfixEvidenceRecordInput): ResolveIOAIManagerHotfixEvidenceRecord;
+export declare function buildResolveIOAIManagerHotfixDurabilityContract(input?: ResolveIOAIManagerHotfixDurabilityContractInput): ResolveIOAIManagerHotfixDurabilityContract;
 export declare function decideResolveIOAIManagerHotfixContinuation(input?: ResolveIOAIManagerHotfixContinuationInput): ResolveIOAIManagerHotfixContinuationDecision;
 export declare function decideResolveIOAIManagerHotfixCommitGuard(input?: ResolveIOAIManagerHotfixContinuationInput): ResolveIOAIManagerHotfixCommitGuardDecision;
 export declare function buildResolveIOAIManagerHotfixFirstReleasePolicy(input?: ResolveIOAIManagerHotfixFirstReleasePolicyInput): ResolveIOAIManagerHotfixFirstReleasePolicy;

package/util/ai-runner-manager-policy.js

@@ -53,6 +53,7 @@ exports.normalizeResolveIOAIManagerHotfixEvidence = normalizeResolveIOAIManagerH
 exports.evaluateResolveIOAIManagerHotfixGitProof = evaluateResolveIOAIManagerHotfixGitProof;
 exports.validateResolveIOAIManagerHotfixEvidence = validateResolveIOAIManagerHotfixEvidence;
 exports.buildResolveIOAIManagerHotfixEvidenceRecord = buildResolveIOAIManagerHotfixEvidenceRecord;
+exports.buildResolveIOAIManagerHotfixDurabilityContract = buildResolveIOAIManagerHotfixDurabilityContract;
 exports.decideResolveIOAIManagerHotfixContinuation = decideResolveIOAIManagerHotfixContinuation;
 exports.decideResolveIOAIManagerHotfixCommitGuard = decideResolveIOAIManagerHotfixCommitGuard;
 exports.buildResolveIOAIManagerHotfixFirstReleasePolicy = buildResolveIOAIManagerHotfixFirstReleasePolicy;
@@ -939,8 +940,250 @@ function buildResolveIOAIManagerHotfixEvidenceRecord(input) {
         readyForContinuation: validation.valid === true && validation.hotfixSatisfied === true && hotfixStatusPassed(normalized === null || normalized === void 0 ? void 0 : normalized.releaseGateStatus)
     };
 }
+function pickFirstHotfixText(sources, keys, max, seen) {
+    var e_4, _a, e_5, _b, e_6, _c;
+    if (max === void 0) { max = 500; }
+    if (seen === void 0) { seen = new WeakSet(); }
+    try {
+        for (var sources_1 = __values(sources), sources_1_1 = sources_1.next(); !sources_1_1.done; sources_1_1 = sources_1.next()) {
+            var source = sources_1_1.value;
+            var record = cleanObject(source);
+            if (!Object.keys(record).length || seen.has(record)) {
+                continue;
+            }
+            seen.add(record);
+            try {
+                for (var keys_1 = (e_5 = void 0, __values(keys)), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+                    var key = keys_1_1.value;
+                    var value = cleanText(record[key], max);
+                    if (value) {
+                        return value;
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (keys_1_1 && !keys_1_1.done && (_b = keys_1.return)) _b.call(keys_1);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+            try {
+                for (var _d = (e_6 = void 0, __values(['evidence', 'hotfixEvidence', 'hotfix_evidence', 'hotfixCommitProof', 'hotfix_commit_proof', 'hotfixCommitGuard', 'hotfix_commit_guard', 'githubCommitGuard', 'github_commit_guard'])), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    var nestedKey = _e.value;
+                    var nestedValue = pickFirstHotfixText([record[nestedKey]], keys, max, seen);
+                    if (nestedValue) {
+                        return nestedValue;
+                    }
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (_e && !_e.done && (_c = _d.return)) _c.call(_d);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (sources_1_1 && !sources_1_1.done && (_a = sources_1.return)) _a.call(sources_1);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return '';
+}
+function hotfixDurabilityExtraRequest(contract) {
+    if (!contract.required) {
+        return '';
+    }
+    return [
+        'Manager hotfix durability contract:',
+        "- Contract id: ".concat(contract.contractId),
+        "- Live backend hotfix blocked until commit proof: ".concat(contract.liveHotfixBlockedUntilCommit ? 'yes' : 'no'),
+        "- GitHub commit proof passed: ".concat(contract.commitProofPassed ? 'yes' : 'no'),
+        contract.missingCommitProofFields.length ? "- Missing commit proof fields: ".concat(contract.missingCommitProofFields.join(', ')) : '',
+        contract.phaseOrder.length ? "- Required phase order: ".concat(contract.phaseOrder.join(' -> ')) : '',
+        contract.requiredFields.length ? "- Required evidence fields: ".concat(contract.requiredFields.join(', ')) : '',
+        contract.successCriteria.length ? "- Success criteria: ".concat(contract.successCriteria.join(' | ')) : '',
+        contract.forbiddenActions.length ? "- Forbidden actions: ".concat(contract.forbiddenActions.join(' | ')) : '',
+        '- Prepare the hotfix patch and GitHub commit proof before any live backend apply/restart.',
+        '- After commit proof exists, apply the backend hotfix only through the existing hotfix path, record restart/checksum evidence, run the runner-manager self-test, and rerun the smallest release gate.'
+    ].filter(Boolean).join('\n').slice(0, 3600);
+}
+function buildResolveIOAIManagerHotfixDurabilityContract(input) {
+    var _a, _b, _c, _d, _e;
+    if (input === void 0) { input = {}; }
+    var existing = cleanObject(input.existing);
+    var evidence = Object.keys(cleanObject(input.evidence)).length ? input.evidence : existing.evidence || existing.hotfixEvidence || existing.hotfix_evidence || existing;
+    var validation = validateResolveIOAIManagerHotfixEvidence(evidence, { policy: input.policy });
+    var continuation = input.continuation || undefined;
+    var githubCommitGuard = validation.githubCommitGuard || evaluateResolveIOAIManagerHotfixGitProof(evidence, validation.channel);
+    var sources = [evidence, existing, continuation, continuation === null || continuation === void 0 ? void 0 : continuation.githubCommitGuard, continuation === null || continuation === void 0 ? void 0 : continuation.github_commit_guard, githubCommitGuard];
+    var action = cleanText(input.action || existing.action || existing.dispatchAction || existing.dispatch_action || 'run_release_repair', 160);
+    var actionRequiresHotfix = /release_repair|hotfix|apply.*backend|deploy|publish/i.test(action);
+    var required = existing.required === true
+        || actionRequiresHotfix
+        || githubCommitGuard.required === true
+        || ((_a = validation.githubCommitGuard) === null || _a === void 0 ? void 0 : _a.required) === true
+        || ((_b = continuation === null || continuation === void 0 ? void 0 : continuation.githubCommitGuard) === null || _b === void 0 ? void 0 : _b.required) === true
+        || ((_c = continuation === null || continuation === void 0 ? void 0 : continuation.github_commit_guard) === null || _c === void 0 ? void 0 : _c.required) === true
+        || ((_d = input.policy) === null || _d === void 0 ? void 0 : _d.hotfixPreferred) === true;
+    var sourceCommitSha = githubCommitGuard.sourceCommitSha || pickFirstHotfixText(sources, ['sourceCommitSha', 'source_commit_sha', 'commitSha', 'commit_sha'], 120);
+    var githubCommitUrl = githubCommitGuard.githubCommitUrl || pickFirstHotfixText(sources, ['githubCommitUrl', 'github_commit_url', 'commitUrl', 'commit_url'], 500);
+    var gitCommitStatus = githubCommitGuard.gitCommitStatus || pickFirstHotfixText(sources, ['gitCommitStatus', 'git_commit_status', 'commitStatus', 'commit_status'], 160);
+    var gitPushStatus = githubCommitGuard.gitPushStatus || pickFirstHotfixText(sources, ['gitPushStatus', 'git_push_status', 'pushStatus', 'push_status'], 160);
+    var commitPassed = hotfixStatusPassed(gitCommitStatus);
+    var pushPassed = hotfixStatusPassed(gitPushStatus);
+    var sourceShaPassed = isFullGitCommitSha(sourceCommitSha);
+    var githubUrlSha = extractGithubCommitSha(githubCommitUrl);
+    var githubUrlPassed = !!githubUrlSha && (!sourceShaPassed || githubUrlSha === sourceCommitSha.toLowerCase());
+    var missingCommitProofFields = [
+        sourceShaPassed ? '' : 'sourceCommitSha',
+        githubUrlPassed ? '' : 'githubCommitUrl',
+        commitPassed ? '' : 'gitCommitStatus=passed',
+        pushPassed ? '' : 'gitPushStatus=passed'
+    ].filter(Boolean);
+    var commitProofPassed = required ? missingCommitProofFields.length === 0 : githubCommitGuard.passed === true;
+    var liveHotfixBlockedUntilCommit = required && commitProofPassed !== true;
+    var releaseGatePassed = input.releaseGatePassed === true
+        || hotfixStatusPassed((_e = validation.normalized) === null || _e === void 0 ? void 0 : _e.releaseGateStatus)
+        || (continuation === null || continuation === void 0 ? void 0 : continuation.canContinueRun) === true;
+    var canPrepareHotfixPatch = required && (existing.canPrepareHotfixPatch === true || existing.can_prepare_hotfix_patch === true || actionRequiresHotfix || (continuation === null || continuation === void 0 ? void 0 : continuation.action) === 'record_hotfix_evidence');
+    var canHotfixBackend = required && commitProofPassed === true && canPrepareHotfixPatch === true;
+    var status = 'not_required';
+    if (required && liveHotfixBlockedUntilCommit) {
+        status = 'waiting_for_commit_proof';
+    }
+    else if (required && validation.valid && releaseGatePassed) {
+        status = 'ready_for_continuation';
+    }
+    else if (required && validation.valid) {
+        status = 'ready_for_release_gate';
+    }
+    else if (required) {
+        status = 'ready_for_live_hotfix';
+    }
+    var phaseOrder = Array.from(new Set(cleanList(existing.phaseOrder || existing.phase_order, 12, 200).concat([
+        'prepare_hotfix_patch_without_live_apply',
+        'commit_and_push_hotfix_to_github',
+        'record_hotfix_evidence',
+        'apply_backend_hotfix_only_after_commit_proof',
+        'run_runner_manager_self_test',
+        'rerun_smallest_release_gate'
+    ]))).slice(0, 12);
+    var requiredFields = Array.from(new Set(cleanList(existing.requiredFields || existing.required_fields, 20, 200).concat([
+        'sourceCommitSha',
+        'githubCommitUrl',
+        'gitCommitStatus=passed',
+        'gitPushStatus=passed',
+        'hotfixPatchDiff',
+        'restartOrChecksumEvidence',
+        'releaseGateResult'
+    ]))).slice(0, 20);
+    var requiredEvidence = Array.from(new Set(cleanList(existing.requiredEvidence || existing.required_evidence, 24, 300).concat(requiredFields, validation.requiredEvidence || []))).slice(0, 24);
+    var successCriteria = Array.from(new Set(cleanList(existing.successCriteria || existing.success_criteria, 14, 300).concat([
+        'Hotfix patch exists without live apply side effects.',
+        'GitHub commit and push proof are recorded before live hotfix.',
+        'Backend restart/checksum evidence and runner-manager self-test pass.',
+        'Only the smallest relevant release gate is rerun after hotfix evidence.'
+    ]))).slice(0, 14);
+    var forbiddenActions = Array.from(new Set(cleanList(existing.forbiddenActions || existing.forbidden_actions, 14, 500).concat([
+        'Do not apply or restart a live backend before sourceCommitSha, githubCommitUrl, passed gitCommitStatus, and passed gitPushStatus are recorded.',
+        'Do not run a full server deploy as a substitute for a targeted backend hotfix.',
+        'Do not continue the ticket from route-only or release-status-only evidence.'
+    ]))).slice(0, 14);
+    var now = cleanDateString(input.now || new Date());
+    var createdAt = cleanDateString(existing.createdAt || existing.created_at || now);
+    var reason = cleanText(input.reason || existing.reason || (continuation === null || continuation === void 0 ? void 0 : continuation.reason) || validation.blockers.join('; '), 1000);
+    var contractId = cleanText(existing.contractId || existing.contract_id, 160)
+        || "hotfix-durability-".concat(fingerprintResolveIOAIManagerBlocker([
+            action,
+            reason,
+            phaseOrder.join('|'),
+            createdAt.slice(0, 16)
+        ].join('\n')).slice(0, 16));
+    var nextSafeAction = !required
+        ? 'continue'
+        : liveHotfixBlockedUntilCommit
+            ? 'commit_and_push_hotfix_to_github'
+            : validation.valid
+                ? (releaseGatePassed ? 'continue_current_runner' : 'rerun_smallest_release_gate')
+                : 'apply_backend_hotfix_only_after_commit_proof';
+    var hotfixCommitGuard = {
+        required: required,
+        blocks_live_hotfix: liveHotfixBlockedUntilCommit,
+        passed: commitProofPassed,
+        status: commitProofPassed ? 'passed' : 'missing',
+        sourceCommitSha: sourceCommitSha,
+        githubCommitUrl: githubCommitUrl,
+        gitCommitStatus: gitCommitStatus,
+        gitPushStatus: gitPushStatus,
+        missingFields: missingCommitProofFields,
+        required_fields: ['sourceCommitSha', 'githubCommitUrl', 'gitCommitStatus=passed', 'gitPushStatus=passed'],
+        next_action: liveHotfixBlockedUntilCommit ? 'commit_and_push_hotfix_to_github' : 'record_hotfix_evidence'
+    };
+    var contract = {
+        contractId: contractId,
+        contract_id: contractId,
+        createdAt: createdAt,
+        created_at: createdAt,
+        updatedAt: now,
+        updated_at: now,
+        source: cleanText(input.source || existing.source || 'ai_manager_hotfix_durability', 160),
+        required: required,
+        action: action,
+        status: status,
+        reason: reason,
+        canPrepareHotfixPatch: canPrepareHotfixPatch,
+        can_prepare_hotfix_patch: canPrepareHotfixPatch,
+        canHotfixBackend: canHotfixBackend,
+        can_hotfix_backend: canHotfixBackend,
+        liveHotfixBlockedUntilCommit: liveHotfixBlockedUntilCommit,
+        live_hotfix_blocked_until_commit: liveHotfixBlockedUntilCommit,
+        commitProofPassed: commitProofPassed,
+        commit_proof_passed: commitProofPassed,
+        commitProofStatus: commitProofPassed ? 'passed' : 'missing',
+        commit_proof_status: commitProofPassed ? 'passed' : 'missing',
+        sourceCommitSha: sourceCommitSha,
+        source_commit_sha: sourceCommitSha,
+        githubCommitUrl: githubCommitUrl,
+        github_commit_url: githubCommitUrl,
+        gitCommitStatus: gitCommitStatus,
+        git_commit_status: gitCommitStatus,
+        gitPushStatus: gitPushStatus,
+        git_push_status: gitPushStatus,
+        missingCommitProofFields: missingCommitProofFields,
+        missing_commit_proof_fields: missingCommitProofFields,
+        nextSafeAction: nextSafeAction,
+        next_safe_action: nextSafeAction,
+        phaseOrder: phaseOrder,
+        phase_order: phaseOrder,
+        requiredFields: requiredFields,
+        required_fields: requiredFields,
+        requiredEvidence: requiredEvidence,
+        required_evidence: requiredEvidence,
+        successCriteria: successCriteria,
+        success_criteria: successCriteria,
+        forbiddenActions: forbiddenActions,
+        forbidden_actions: forbiddenActions,
+        hotfixCommitGuard: hotfixCommitGuard,
+        hotfix_commit_guard: hotfixCommitGuard,
+        githubCommitGuard: __assign(__assign({}, githubCommitGuard), { required: required, passed: commitProofPassed, status: commitProofPassed ? 'passed' : (required ? 'missing' : githubCommitGuard.status), managerMustCommitBeforeHotfix: liveHotfixBlockedUntilCommit, sourceCommitSha: sourceCommitSha, githubCommitUrl: githubCommitUrl, gitCommitStatus: gitCommitStatus, gitPushStatus: gitPushStatus }),
+        github_commit_guard: __assign(__assign({}, githubCommitGuard), { required: required, passed: commitProofPassed, status: commitProofPassed ? 'passed' : (required ? 'missing' : githubCommitGuard.status), managerMustCommitBeforeHotfix: liveHotfixBlockedUntilCommit, sourceCommitSha: sourceCommitSha, githubCommitUrl: githubCommitUrl, gitCommitStatus: gitCommitStatus, gitPushStatus: gitPushStatus }),
+        validation: validation,
+        continuation: continuation,
+        extraRequest: '',
+        extra_request: ''
+    };
+    contract.extraRequest = hotfixDurabilityExtraRequest(contract);
+    contract.extra_request = contract.extraRequest;
+    return contract;
+}
 function decideResolveIOAIManagerHotfixContinuation(input) {
-    var e_4, _a;
+    var e_7, _a;
     var _b, _c;
     if (input === void 0) { input = {}; }
     var validation = validateResolveIOAIManagerHotfixEvidence(input.evidence, { policy: input.policy });
@@ -975,12 +1218,12 @@ function decideResolveIOAIManagerHotfixContinuation(input) {
                 }
             }
         }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
         finally {
             try {
                 if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
             }
-            finally { if (e_4) throw e_4.error; }
+            finally { if (e_7) throw e_7.error; }
         }
     }
     else if (!validation.valid || validation.status === 'missing' || validation.status === 'incomplete') {