@resolveio/server-lib 22.3.137 → 22.3.139

package/package.json

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

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

@@ -114,6 +114,82 @@ export interface ResolveIOAIManagerRecoveryActionPacket {
     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 type ResolveIOAIManagerRecoveryExecutionPhase = 'evidence' | 'diagnosis' | 'infra' | 'compile' | 'journey' | 'business_proof' | 'release' | 'product_repair' | 'advance' | 'manual';
+export interface ResolveIOAIManagerRecoveryExecutionDirectiveInput {
+    action?: ResolveIOAIManagerRecoveryActionPacket;
+    dispatchDecision?: ResolveIOAIManagerRecoveryActionDispatchDecision;
+    current?: ResolveIOAIManagerFailureRecord;
+    surface?: string;
+    now?: Date | string;
+}
+export interface ResolveIOAIManagerRecoveryExecutionDirective {
+    directiveId: string;
+    surface: string;
+    dispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
+    phase: ResolveIOAIManagerRecoveryExecutionPhase;
+    allowed: boolean;
+    status: ResolveIOAIManagerRecoveryActionDispatchStatus;
+    reason: string;
+    lane: string;
+    stepType: string;
+    nextActionLabel: string;
+    rerunReason: string;
+    evidenceOnly: boolean;
+    autoRunnable: boolean;
+    productRepairAllowed: boolean;
+    expensiveModelAllowed: boolean;
+    canRunProductRepair: boolean;
+    canRunExpensiveModel: boolean;
+    canResetLoopAfterEvidence: boolean;
+    requiresNewEvidence: boolean;
+    newEvidence: boolean;
+    maxAttemptsBeforePark: number;
+    requiredArtifacts: string[];
+    nextCommands: string[];
+    successCriteria: string[];
+    forbiddenActions: string[];
+    dispatchRecord?: ResolveIOAIManagerRecoveryActionDispatchRecord;
+    createdAt: string;
+}
 export interface ResolveIOAIManagerRecoveryCheckpointInput {
     plan: ResolveIOAIManagerRecoveryPlan;
     current?: ResolveIOAIManagerFailureRecord;
@@ -198,6 +274,9 @@ export declare function hashResolveIOAIManagerEvidence(record: ResolveIOAIManage
 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 buildResolveIOAIManagerRecoveryExecutionDirective(input: ResolveIOAIManagerRecoveryExecutionDirectiveInput): ResolveIOAIManagerRecoveryExecutionDirective;
 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

@@ -53,6 +53,9 @@ exports.hashResolveIOAIManagerEvidence = hashResolveIOAIManagerEvidence;
 exports.buildResolveIOAIManagerRecoveryCheckpoint = buildResolveIOAIManagerRecoveryCheckpoint;
 exports.buildResolveIOAIManagerRecoveryEvidenceProbe = buildResolveIOAIManagerRecoveryEvidenceProbe;
 exports.buildResolveIOAIManagerRecoveryActionPacket = buildResolveIOAIManagerRecoveryActionPacket;
+exports.decideResolveIOAIManagerRecoveryActionDispatch = decideResolveIOAIManagerRecoveryActionDispatch;
+exports.appendResolveIOAIManagerRecoveryActionDispatch = appendResolveIOAIManagerRecoveryActionDispatch;
+exports.buildResolveIOAIManagerRecoveryExecutionDirective = buildResolveIOAIManagerRecoveryExecutionDirective;
 exports.decideResolveIOAIManagerRecoveryGate = decideResolveIOAIManagerRecoveryGate;
 exports.buildResolveIOAIManagerRecoveryPlan = buildResolveIOAIManagerRecoveryPlan;
 exports.decideResolveIOAIManagerPolicy = decideResolveIOAIManagerPolicy;
@@ -417,6 +420,202 @@ function buildResolveIOAIManagerRecoveryActionPacket(input) {
             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 recoveryExecutionPhaseForDispatch(dispatchAction) {
+    var map = {
+        run_evidence_probe: 'evidence',
+        run_read_only_diagnosis: 'diagnosis',
+        run_infra_repair: 'infra',
+        run_compile_repair: 'compile',
+        run_journey_contract_repair: 'journey',
+        run_business_assertion_repair: 'business_proof',
+        run_release_repair: 'release',
+        run_targeted_product_repair: 'product_repair',
+        advance: 'advance',
+        continue_gate: 'advance',
+        park_manual: 'manual'
+    };
+    return map[dispatchAction] || 'manual';
+}
+function recoveryDirectiveReason(action, decision, current) {
+    var blocker = cleanText((current === null || current === void 0 ? void 0 : current.blocker) || (current === null || current === void 0 ? void 0 : current.summary) || '', 260);
+    var label = cleanText(action === null || action === void 0 ? void 0 : action.label, 120) || decision.dispatchAction;
+    var objective = cleanText(action === null || action === void 0 ? void 0 : action.objective, 260);
+    return [
+        "MANAGER_RECOVERY:".concat(decision.dispatchAction),
+        "label=".concat(label),
+        decision.reason ? "reason=".concat(decision.reason) : '',
+        blocker ? "blocker=".concat(blocker) : '',
+        objective ? "objective=".concat(objective) : ''
+    ].filter(Boolean).join(' | ');
+}
+function buildResolveIOAIManagerRecoveryExecutionDirective(input) {
+    var _a, _b, _c, _d;
+    var action = input.action;
+    var dispatchDecision = input.dispatchDecision || decideResolveIOAIManagerRecoveryActionDispatch({
+        action: action,
+        current: input.current,
+        now: input.now
+    });
+    var dispatchAction = dispatchDecision.dispatchAction;
+    var now = isoNow(input.now);
+    var phase = recoveryExecutionPhaseForDispatch(dispatchAction);
+    var lane = cleanText((action === null || action === void 0 ? void 0 : action.lane) || ((_a = input.current) === null || _a === void 0 ? void 0 : _a.lane) || '', 120);
+    var stepType = cleanText((action === null || action === void 0 ? void 0 : action.stepType) || ((_b = input.current) === null || _b === void 0 ? void 0 : _b.stepType) || '', 120);
+    var rerunReason = recoveryDirectiveReason(action, dispatchDecision, input.current);
+    var surface = cleanText(input.surface || 'runner', 120);
+    return __assign(__assign({ directiveId: stableHash('mgr-directive', {
+            surface: surface,
+            actionId: (action === null || action === void 0 ? void 0 : action.actionId) || '',
+            dispatchAction: dispatchAction,
+            reason: dispatchDecision.reason,
+            evidenceHash: ((_c = dispatchDecision.dispatchRecord) === null || _c === void 0 ? void 0 : _c.evidenceHash) || ((_d = input.current) === null || _d === void 0 ? void 0 : _d.evidenceHash) || ''
+        }), surface: surface, dispatchAction: dispatchAction, phase: phase, allowed: dispatchDecision.allowed, status: dispatchDecision.status, reason: dispatchDecision.reason, lane: lane, stepType: stepType, nextActionLabel: cleanText(action === null || action === void 0 ? void 0 : action.label, 160) || dispatchAction, rerunReason: rerunReason, evidenceOnly: (action === null || action === void 0 ? void 0 : action.evidenceOnly) !== false || dispatchAction === 'run_evidence_probe', autoRunnable: (action === null || action === void 0 ? void 0 : action.autoRunnable) === true, productRepairAllowed: (action === null || action === void 0 ? void 0 : action.productRepairAllowed) === true, expensiveModelAllowed: (action === null || action === void 0 ? void 0 : action.expensiveModelAllowed) === true, canRunProductRepair: dispatchDecision.canRunProductRepair, canRunExpensiveModel: dispatchDecision.canRunExpensiveModel, canResetLoopAfterEvidence: (action === null || action === void 0 ? void 0 : action.canResetLoopAfterEvidence) === true, requiresNewEvidence: dispatchDecision.requiresNewEvidence, newEvidence: dispatchDecision.newEvidence, maxAttemptsBeforePark: Math.max(1, Number((action === null || action === void 0 ? void 0 : action.maxAttemptsBeforePark) || 1) || 1), requiredArtifacts: cleanList(action === null || action === void 0 ? void 0 : action.requiredArtifacts, 20, 500), nextCommands: cleanList(action === null || action === void 0 ? void 0 : action.nextCommands, 20, 500), successCriteria: cleanList(action === null || action === void 0 ? void 0 : action.successCriteria, 20, 500), forbiddenActions: (action === null || action === void 0 ? void 0 : action.productRepairAllowed) === true
+            ? []
+            : ['Do not run product-code repair from this directive unless canRunProductRepair is true.'] }, (dispatchDecision.dispatchRecord ? { dispatchRecord: dispatchDecision.dispatchRecord } : {})), { createdAt: now });
+}
 function listHasNewEntry(current, previous) {
     var existing = new Set(previous.map(function (entry) { return cleanText(entry, 500); }).filter(Boolean));
     return current.some(function (entry) {