@resolveio/server-lib 22.3.136 → 22.3.138

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resolveio/server-lib",
-  "version": "22.3.136",
+  "version": "22.3.138",
   "description": "",
   "scripts": {
     "package": "./build_package.sh",

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

@@ -83,6 +83,76 @@ export interface ResolveIOAIManagerRecoveryEvidenceProbe {
     loopResetEvidence: string[];
     createdAt: string;
 }
+export type ResolveIOAIManagerRecoveryAutomationMode = 'advance' | 'collect_evidence' | 'read_only_diagnosis' | 'repair_infra' | 'repair_compile' | 'repair_journey_contract' | 'repair_business_assertion' | 'repair_release' | 'targeted_product_repair' | 'manual_review' | 'continue_gate';
+export interface ResolveIOAIManagerRecoveryActionRetryPolicy {
+    allowImmediateRetry: boolean;
+    requireNewEvidence: boolean;
+    resetLoopWhen: string[];
+    stopWhen: string[];
+}
+export interface ResolveIOAIManagerRecoveryActionPacket {
+    actionId: string;
+    checkpointId: string;
+    probeId: string;
+    recoveryClass: ResolveIOAIManagerRecoveryClass;
+    mode: ResolveIOAIManagerRecoveryAutomationMode;
+    label: string;
+    lane: string;
+    stepType: string;
+    primaryStepKind: ResolveIOAIManagerRecoveryEvidenceProbeStepKind | 'none';
+    objective: string;
+    evidenceOnly: boolean;
+    autoRunnable: boolean;
+    productRepairAllowed: boolean;
+    expensiveModelAllowed: boolean;
+    canResetLoopAfterEvidence: boolean;
+    maxAttemptsBeforePark: number;
+    requiredArtifacts: string[];
+    nextCommands: string[];
+    successCriteria: string[];
+    retryPolicy: ResolveIOAIManagerRecoveryActionRetryPolicy;
+    blockedReason?: string;
+    createdAt: string;
+}
+export type ResolveIOAIManagerRecoveryActionDispatchAction = 'run_evidence_probe' | 'run_read_only_diagnosis' | 'run_infra_repair' | 'run_compile_repair' | 'run_journey_contract_repair' | 'run_business_assertion_repair' | 'run_release_repair' | 'run_targeted_product_repair' | 'advance' | 'continue_gate' | 'park_manual';
+export type ResolveIOAIManagerRecoveryActionDispatchStatus = 'queued' | 'started' | 'completed' | 'failed' | 'parked';
+export interface ResolveIOAIManagerRecoveryActionDispatchRecord {
+    dispatchId: string;
+    actionId: string;
+    checkpointId: string;
+    probeId: string;
+    mode: ResolveIOAIManagerRecoveryAutomationMode;
+    dispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
+    status: ResolveIOAIManagerRecoveryActionDispatchStatus;
+    evidenceHash: string;
+    blockerFingerprint: string;
+    productRepairAllowed: boolean;
+    expensiveModelAllowed: boolean;
+    reason: string;
+    artifactPaths: string[];
+    startedAt?: string;
+    completedAt?: string;
+    createdAt: string;
+}
+export interface ResolveIOAIManagerRecoveryActionDispatchInput {
+    action?: ResolveIOAIManagerRecoveryActionPacket;
+    history?: ResolveIOAIManagerRecoveryActionDispatchRecord[];
+    current?: ResolveIOAIManagerFailureRecord;
+    operatorApproved?: boolean;
+    now?: Date | string;
+}
+export interface ResolveIOAIManagerRecoveryActionDispatchDecision {
+    dispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
+    allowed: boolean;
+    reason: string;
+    status: ResolveIOAIManagerRecoveryActionDispatchStatus;
+    canRunProductRepair: boolean;
+    canRunExpensiveModel: boolean;
+    shouldRecordDispatch: boolean;
+    requiresNewEvidence: boolean;
+    newEvidence: boolean;
+    dispatchRecord?: ResolveIOAIManagerRecoveryActionDispatchRecord;
+}
 export interface ResolveIOAIManagerRecoveryCheckpointInput {
     plan: ResolveIOAIManagerRecoveryPlan;
     current?: ResolveIOAIManagerFailureRecord;
@@ -115,6 +185,13 @@ export interface ResolveIOAIManagerRecoveryEvidenceProbeInput {
     current?: ResolveIOAIManagerFailureRecord;
     now?: Date | string;
 }
+export interface ResolveIOAIManagerRecoveryActionPacketInput {
+    plan?: ResolveIOAIManagerRecoveryPlan;
+    checkpoint: ResolveIOAIManagerRecoveryCheckpoint;
+    probe?: ResolveIOAIManagerRecoveryEvidenceProbe;
+    current?: ResolveIOAIManagerFailureRecord;
+    now?: Date | string;
+}
 export interface ResolveIOAIManagerRecoveryPlanInput {
     action?: ResolveIOAIManagerAction | string;
     reason?: string;
@@ -152,12 +229,16 @@ export interface ResolveIOAIManagerPolicyDecision {
     recoveryPlan: ResolveIOAIManagerRecoveryPlan;
     recoveryCheckpoint: ResolveIOAIManagerRecoveryCheckpoint;
     recoveryEvidenceProbe: ResolveIOAIManagerRecoveryEvidenceProbe;
+    recoveryAction: ResolveIOAIManagerRecoveryActionPacket;
 }
 export declare function normalizeResolveIOAIManagerFailureClass(value: any): string;
 export declare function fingerprintResolveIOAIManagerBlocker(value: any): string;
 export declare function hashResolveIOAIManagerEvidence(record: ResolveIOAIManagerFailureRecord | undefined): string;
 export declare function buildResolveIOAIManagerRecoveryCheckpoint(input: ResolveIOAIManagerRecoveryCheckpointInput): ResolveIOAIManagerRecoveryCheckpoint;
 export declare function buildResolveIOAIManagerRecoveryEvidenceProbe(input: ResolveIOAIManagerRecoveryEvidenceProbeInput): ResolveIOAIManagerRecoveryEvidenceProbe;
+export declare function buildResolveIOAIManagerRecoveryActionPacket(input: ResolveIOAIManagerRecoveryActionPacketInput): ResolveIOAIManagerRecoveryActionPacket;
+export declare function decideResolveIOAIManagerRecoveryActionDispatch(input: ResolveIOAIManagerRecoveryActionDispatchInput): ResolveIOAIManagerRecoveryActionDispatchDecision;
+export declare function appendResolveIOAIManagerRecoveryActionDispatch(history: ResolveIOAIManagerRecoveryActionDispatchRecord[] | undefined, record: ResolveIOAIManagerRecoveryActionDispatchRecord | undefined, limit?: number): ResolveIOAIManagerRecoveryActionDispatchRecord[];
 export declare function decideResolveIOAIManagerRecoveryGate(input: ResolveIOAIManagerRecoveryGateInput): ResolveIOAIManagerRecoveryGateDecision;
 export declare function buildResolveIOAIManagerRecoveryPlan(input?: ResolveIOAIManagerRecoveryPlanInput): ResolveIOAIManagerRecoveryPlan;
 export declare function decideResolveIOAIManagerPolicy(input: ResolveIOAIManagerPolicyInput): ResolveIOAIManagerPolicyDecision;

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

@@ -52,6 +52,9 @@ exports.fingerprintResolveIOAIManagerBlocker = fingerprintResolveIOAIManagerBloc
 exports.hashResolveIOAIManagerEvidence = hashResolveIOAIManagerEvidence;
 exports.buildResolveIOAIManagerRecoveryCheckpoint = buildResolveIOAIManagerRecoveryCheckpoint;
 exports.buildResolveIOAIManagerRecoveryEvidenceProbe = buildResolveIOAIManagerRecoveryEvidenceProbe;
+exports.buildResolveIOAIManagerRecoveryActionPacket = buildResolveIOAIManagerRecoveryActionPacket;
+exports.decideResolveIOAIManagerRecoveryActionDispatch = decideResolveIOAIManagerRecoveryActionDispatch;
+exports.appendResolveIOAIManagerRecoveryActionDispatch = appendResolveIOAIManagerRecoveryActionDispatch;
 exports.decideResolveIOAIManagerRecoveryGate = decideResolveIOAIManagerRecoveryGate;
 exports.buildResolveIOAIManagerRecoveryPlan = buildResolveIOAIManagerRecoveryPlan;
 exports.decideResolveIOAIManagerPolicy = decideResolveIOAIManagerPolicy;
@@ -314,6 +317,251 @@ function buildResolveIOAIManagerRecoveryEvidenceProbe(input) {
         createdAt: now
     };
 }
+function recoveryAutomationModeFor(checkpoint) {
+    if (checkpoint.status === 'manual_handoff' || checkpoint.recoveryClass === 'manual_handoff') {
+        return 'manual_review';
+    }
+    if (checkpoint.status === 'complete' || checkpoint.recoveryClass === 'advance_after_proof') {
+        return 'advance';
+    }
+    if (checkpoint.status === 'parked' || checkpoint.recoveryClass === 'blocked_until_new_evidence') {
+        return 'collect_evidence';
+    }
+    if (checkpoint.recoveryClass === 'diagnosis_only' || checkpoint.recoveryClass === 'diagnosis_revision') {
+        return 'read_only_diagnosis';
+    }
+    if (checkpoint.recoveryClass === 'infra_repair') {
+        return 'repair_infra';
+    }
+    if (checkpoint.recoveryClass === 'compile_repair') {
+        return 'repair_compile';
+    }
+    if (checkpoint.recoveryClass === 'journey_contract_repair') {
+        return 'repair_journey_contract';
+    }
+    if (checkpoint.recoveryClass === 'business_proof_repair') {
+        return 'repair_business_assertion';
+    }
+    if (checkpoint.recoveryClass === 'release_repair') {
+        return 'repair_release';
+    }
+    if (checkpoint.recoveryClass === 'product_code_repair') {
+        return 'targeted_product_repair';
+    }
+    return 'continue_gate';
+}
+function recoveryActionLabelFor(mode, checkpoint) {
+    var explicit = cleanText(checkpoint.nextActionLabel, 120);
+    if (explicit && mode !== 'collect_evidence') {
+        return explicit;
+    }
+    var labels = {
+        advance: 'Advance To Next Gate',
+        collect_evidence: 'Collect New Evidence',
+        read_only_diagnosis: 'Run Diagnosis Evidence Pass',
+        repair_infra: 'Repair Infra Gate',
+        repair_compile: 'Repair Compile Gate',
+        repair_journey_contract: 'Repair Journey Contract',
+        repair_business_assertion: 'Repair Business Proof',
+        repair_release: 'Repair Release Gate',
+        targeted_product_repair: 'Run Targeted Repair',
+        manual_review: 'Manual Review',
+        continue_gate: 'Continue Current Gate'
+    };
+    return labels[mode];
+}
+function recoveryActionAutoRunnable(mode, probe) {
+    if (mode === 'manual_review') {
+        return false;
+    }
+    if (mode === 'advance' || mode === 'continue_gate') {
+        return true;
+    }
+    if (mode === 'targeted_product_repair' || mode === 'read_only_diagnosis' || mode === 'repair_journey_contract' || mode === 'repair_business_assertion') {
+        return true;
+    }
+    return probe.steps.some(function (step) { return step.commandHint || step.kind === 'rerun_same_gate' || step.kind === 'release_status' || step.kind === 'diff_scope_check'; });
+}
+function buildResolveIOAIManagerRecoveryActionPacket(input) {
+    var checkpoint = input.checkpoint;
+    var probe = input.probe || buildResolveIOAIManagerRecoveryEvidenceProbe({
+        checkpoint: checkpoint,
+        current: input.current,
+        now: input.now
+    });
+    var mode = recoveryAutomationModeFor(checkpoint);
+    var primaryStep = probe.steps.find(function (step) { return step.required && step.id !== 'snapshot_current_blocker'; })
+        || probe.steps.find(function (step) { return step.required; })
+        || probe.steps[0];
+    var evidenceOnly = probe.evidenceOnly || mode === 'collect_evidence' || mode === 'repair_infra' || mode === 'repair_compile' || mode === 'repair_release';
+    var requireNewEvidence = mode === 'collect_evidence'
+        || checkpoint.status === 'parked'
+        || checkpoint.attempts >= checkpoint.maxAttemptsBeforePark;
+    var stopWhen = Array.from(new Set(__spreadArray(__spreadArray([], __read(probe.stopConditions), false), __read((requireNewEvidence ? ['same blocker fingerprint and same evidence hash after probe'] : [])), false).map(function (entry) { return cleanText(entry, 500); }).filter(Boolean))).slice(0, 30);
+    var resetLoopWhen = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray([], __read(checkpoint.loopResetEvidence), false), __read(probe.loopResetEvidence), false), __read((requireNewEvidence ? ['changed evidence hash', 'new artifact path'] : [])), false).map(function (entry) { return cleanText(entry, 500); }).filter(Boolean))).slice(0, 30);
+    var nextCommands = probe.steps
+        .map(function (step) { return cleanText(step.commandHint || "".concat(step.kind, ":").concat(step.id), 500); })
+        .filter(Boolean)
+        .slice(0, 12);
+    var now = isoNow(input.now);
+    return __assign(__assign({ actionId: stableHash('mgr-action', {
+            checkpointId: checkpoint.checkpointId,
+            probeId: probe.probeId,
+            mode: mode,
+            evidenceHash: checkpoint.evidenceHash,
+            blockerFingerprint: checkpoint.blockerFingerprint
+        }), checkpointId: checkpoint.checkpointId, probeId: probe.probeId, recoveryClass: checkpoint.recoveryClass, mode: mode, label: recoveryActionLabelFor(mode, checkpoint), lane: checkpoint.lane, stepType: checkpoint.stepType, primaryStepKind: (primaryStep === null || primaryStep === void 0 ? void 0 : primaryStep.kind) || 'none', objective: mode === 'collect_evidence'
+            ? probe.objective
+            : cleanText(checkpoint.objective || probe.objective, 1000), evidenceOnly: evidenceOnly, autoRunnable: recoveryActionAutoRunnable(mode, probe), productRepairAllowed: checkpoint.productRepairAllowed && !evidenceOnly && checkpoint.status !== 'parked', expensiveModelAllowed: checkpoint.expensiveModelAllowed && checkpoint.status !== 'parked', canResetLoopAfterEvidence: resetLoopWhen.length > 0, maxAttemptsBeforePark: checkpoint.maxAttemptsBeforePark, requiredArtifacts: probe.requiredArtifacts.slice(0, 20), nextCommands: nextCommands, successCriteria: probe.acceptanceEvidence.slice(0, 20), retryPolicy: {
+            allowImmediateRetry: checkpoint.status !== 'parked' && mode !== 'manual_review',
+            requireNewEvidence: requireNewEvidence,
+            resetLoopWhen: resetLoopWhen,
+            stopWhen: stopWhen
+        } }, (mode === 'collect_evidence' ? { blockedReason: 'Manager parked this loop until the recovery action records new evidence.' } : {})), { createdAt: now });
+}
+function dispatchActionForMode(mode) {
+    var map = {
+        advance: 'advance',
+        collect_evidence: 'run_evidence_probe',
+        read_only_diagnosis: 'run_read_only_diagnosis',
+        repair_infra: 'run_infra_repair',
+        repair_compile: 'run_compile_repair',
+        repair_journey_contract: 'run_journey_contract_repair',
+        repair_business_assertion: 'run_business_assertion_repair',
+        repair_release: 'run_release_repair',
+        targeted_product_repair: 'run_targeted_product_repair',
+        manual_review: 'park_manual',
+        continue_gate: 'continue_gate'
+    };
+    return map[mode] || 'park_manual';
+}
+function buildRecoveryDispatchRecord(action, dispatchAction, status, reason, current, now) {
+    var evidenceHash = (current === null || current === void 0 ? void 0 : current.evidenceHash) || action.checkpointId || action.actionId;
+    var blockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(current, action.objective);
+    var artifactPaths = cleanList(current === null || current === void 0 ? void 0 : current.artifactPaths, 20, 500);
+    var createdAt = isoNow(now);
+    return __assign(__assign(__assign({ dispatchId: stableHash('mgr-dispatch', {
+            actionId: action.actionId,
+            dispatchAction: dispatchAction,
+            evidenceHash: evidenceHash,
+            blockerFingerprint: blockerFingerprint,
+            status: status
+        }), actionId: action.actionId, checkpointId: action.checkpointId, probeId: action.probeId, mode: action.mode, dispatchAction: dispatchAction, status: status, evidenceHash: evidenceHash, blockerFingerprint: blockerFingerprint, productRepairAllowed: action.productRepairAllowed && dispatchAction === 'run_targeted_product_repair', expensiveModelAllowed: action.expensiveModelAllowed && dispatchAction !== 'run_evidence_probe', reason: reason, artifactPaths: artifactPaths }, (status === 'started' ? { startedAt: createdAt } : {})), (status === 'completed' ? { completedAt: createdAt } : {})), { createdAt: createdAt });
+}
+function decideResolveIOAIManagerRecoveryActionDispatch(input) {
+    var action = input.action;
+    var history = Array.isArray(input.history) ? input.history.filter(Boolean).slice(-50) : [];
+    var current = input.current || {};
+    if (!action) {
+        return {
+            dispatchAction: 'park_manual',
+            allowed: false,
+            reason: 'recovery_dispatch_missing_action',
+            status: 'parked',
+            canRunProductRepair: false,
+            canRunExpensiveModel: false,
+            shouldRecordDispatch: false,
+            requiresNewEvidence: true,
+            newEvidence: false
+        };
+    }
+    var dispatchAction = dispatchActionForMode(action.mode);
+    var evidenceHash = current.evidenceHash || action.checkpointId || action.actionId;
+    var blockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(current, action.objective);
+    var sameActionHistory = history.filter(function (entry) { return entry.actionId === action.actionId; });
+    var sameEvidenceHistory = sameActionHistory.filter(function (entry) { return entry.evidenceHash === evidenceHash
+        && entry.blockerFingerprint === blockerFingerprint; });
+    var activeDispatch = sameEvidenceHistory.find(function (entry) { return entry.status === 'queued' || entry.status === 'started'; });
+    var completedDispatch = sameEvidenceHistory.find(function (entry) { return entry.status === 'completed' || entry.status === 'failed'; });
+    var newEvidence = sameActionHistory.length > 0 && sameEvidenceHistory.length === 0;
+    var requiresNewEvidence = action.retryPolicy.requireNewEvidence === true;
+    var manualOnly = action.mode === 'manual_review' || !action.autoRunnable;
+    var productDispatch = dispatchAction === 'run_targeted_product_repair';
+    var expensiveDispatch = !['run_evidence_probe', 'advance', 'continue_gate', 'park_manual'].includes(dispatchAction);
+    if (manualOnly && input.operatorApproved !== true) {
+        var record_1 = buildRecoveryDispatchRecord(action, 'park_manual', 'parked', 'recovery_dispatch_requires_manual_review', current, input.now);
+        return {
+            dispatchAction: 'park_manual',
+            allowed: false,
+            reason: record_1.reason,
+            status: 'parked',
+            canRunProductRepair: false,
+            canRunExpensiveModel: false,
+            shouldRecordDispatch: true,
+            requiresNewEvidence: requiresNewEvidence,
+            newEvidence: newEvidence,
+            dispatchRecord: record_1
+        };
+    }
+    if (productDispatch && action.productRepairAllowed !== true) {
+        var record_2 = buildRecoveryDispatchRecord(action, 'park_manual', 'parked', 'recovery_dispatch_product_repair_not_allowed', current, input.now);
+        return {
+            dispatchAction: 'park_manual',
+            allowed: false,
+            reason: record_2.reason,
+            status: 'parked',
+            canRunProductRepair: false,
+            canRunExpensiveModel: false,
+            shouldRecordDispatch: true,
+            requiresNewEvidence: true,
+            newEvidence: newEvidence,
+            dispatchRecord: record_2
+        };
+    }
+    if (activeDispatch) {
+        return {
+            dispatchAction: 'park_manual',
+            allowed: false,
+            reason: 'recovery_dispatch_already_running_for_same_evidence',
+            status: 'parked',
+            canRunProductRepair: false,
+            canRunExpensiveModel: false,
+            shouldRecordDispatch: false,
+            requiresNewEvidence: true,
+            newEvidence: false
+        };
+    }
+    if (completedDispatch && requiresNewEvidence && !newEvidence) {
+        var record_3 = buildRecoveryDispatchRecord(action, 'park_manual', 'parked', 'recovery_dispatch_same_evidence_already_attempted', current, input.now);
+        return {
+            dispatchAction: 'park_manual',
+            allowed: false,
+            reason: record_3.reason,
+            status: 'parked',
+            canRunProductRepair: false,
+            canRunExpensiveModel: false,
+            shouldRecordDispatch: true,
+            requiresNewEvidence: true,
+            newEvidence: false,
+            dispatchRecord: record_3
+        };
+    }
+    var status = dispatchAction === 'advance' || dispatchAction === 'continue_gate'
+        ? 'completed'
+        : 'started';
+    var record = buildRecoveryDispatchRecord(action, dispatchAction, status, 'recovery_dispatch_allowed', current, input.now);
+    return {
+        dispatchAction: dispatchAction,
+        allowed: true,
+        reason: 'recovery_dispatch_allowed',
+        status: status,
+        canRunProductRepair: productDispatch && action.productRepairAllowed === true,
+        canRunExpensiveModel: expensiveDispatch && action.expensiveModelAllowed === true,
+        shouldRecordDispatch: true,
+        requiresNewEvidence: requiresNewEvidence,
+        newEvidence: newEvidence,
+        dispatchRecord: record
+    };
+}
+function appendResolveIOAIManagerRecoveryActionDispatch(history, record, limit) {
+    if (limit === void 0) { limit = 50; }
+    var existing = Array.isArray(history) ? history.filter(Boolean) : [];
+    if (!record) {
+        return existing.slice(-limit);
+    }
+    var deduped = existing.filter(function (entry) { return entry.dispatchId !== record.dispatchId; });
+    return __spreadArray(__spreadArray([], __read(deduped), false), [record], false).slice(-limit);
+}
 function listHasNewEntry(current, previous) {
     var existing = new Set(previous.map(function (entry) { return cleanText(entry, 500); }).filter(Boolean));
     return current.some(function (entry) {
@@ -651,8 +899,14 @@ function decideResolveIOAIManagerPolicy(input) {
             plan: recoveryPlan,
             current: current
         });
-        return __assign(__assign({}, merged), { action: action, reason: reason, recoveryPlan: recoveryPlan, recoveryCheckpoint: recoveryCheckpoint, recoveryEvidenceProbe: buildResolveIOAIManagerRecoveryEvidenceProbe({
+        var recoveryEvidenceProbe = buildResolveIOAIManagerRecoveryEvidenceProbe({
+            checkpoint: recoveryCheckpoint,
+            current: current
+        });
+        return __assign(__assign({}, merged), { action: action, reason: reason, recoveryPlan: recoveryPlan, recoveryCheckpoint: recoveryCheckpoint, recoveryEvidenceProbe: recoveryEvidenceProbe, recoveryAction: buildResolveIOAIManagerRecoveryActionPacket({
+                plan: recoveryPlan,
                 checkpoint: recoveryCheckpoint,
+                probe: recoveryEvidenceProbe,
                 current: current
             }) });
     };