@resolveio/server-lib 22.3.148 → 22.3.150

package/src/util/ai-runner-manager-autopilot.ts

@@ -0,0 +1,434 @@
+import {
+	assessResolveIOAIManagerEvidenceChange,
+	ResolveIOAIManagerFailureRecord,
+	ResolveIOAIManagerRecoveryActionDispatchRecord,
+	ResolveIOAIManagerRecoveryActionPacket,
+	ResolveIOAIManagerRecoveryCheckpoint,
+	ResolveIOAIManagerRecoveryExecutionDirective,
+	ResolveIOAIManagerRecoveryEvidenceProbe,
+	ResolveIOAIManagerRecoveryPlan
+} from './ai-runner-manager-policy';
+
+export type ResolveIOAIManagerAutopilotSafetyLevel = 'low' | 'medium' | 'high' | 'blocked';
+
+export interface ResolveIOAIManagerAutopilotRecommendedAction {
+	action: string;
+	label: string;
+	reason: string;
+	safety: ResolveIOAIManagerAutopilotSafetyLevel;
+	enabled: boolean;
+	autoRunnable: boolean;
+	expectedResult: string;
+	requiresNewEvidence: boolean;
+	canRunProductRepair: boolean;
+	canRunExpensiveModel: boolean;
+	canResetLoopAfterEvidence: boolean;
+	dispatchAction?: string;
+}
+
+export interface ResolveIOAIManagerAutopilotLoopGuard {
+	state: 'clear' | 'collecting_evidence' | 'parked' | 'manual_handoff' | 'complete';
+	blocked: boolean;
+	reason: string;
+	failureClass: string;
+	blocker: string;
+	blockerFingerprint: string;
+	evidenceHash: string;
+	materialEvidence: boolean;
+	evidenceStrength: string;
+	evidenceSignals: string[];
+	sameEvidenceDispatchCount: number;
+	sameEvidenceAlreadyAttempted: boolean;
+	loopCount: number;
+	maxLoopCount: number;
+	attempts: number;
+	maxAttemptsBeforePark: number;
+	canResetLoopAfterEvidence: boolean;
+	resetRequires: string[];
+}
+
+export interface ResolveIOAIManagerAutopilotRecentDispatch {
+	dispatchId: string;
+	actionId: string;
+	checkpointId: string;
+	probeId: string;
+	mode: string;
+	dispatchAction: string;
+	status: string;
+	reason: string;
+	evidenceHash: string;
+	blockerFingerprint: string;
+	artifactPaths: string[];
+	startedAt: string;
+	completedAt: string;
+	createdAt: string;
+}
+
+export interface ResolveIOAIManagerAutopilotSnapshot {
+	surface: string;
+	runId: string;
+	title: string;
+	status: string;
+	phase: string;
+	lane: string;
+	stepType: string;
+	runKind: string;
+	recommendedAction: ResolveIOAIManagerAutopilotRecommendedAction;
+	loopGuard: ResolveIOAIManagerAutopilotLoopGuard;
+	recovery: {
+		checkpointId: string;
+		recoveryClass: string;
+		dispatchAction: string;
+		directiveAllowed: boolean;
+		evidenceOnly: boolean;
+		productRepairAllowed: boolean;
+		expensiveModelAllowed: boolean;
+		requiredArtifacts: string[];
+		nextCommands: string[];
+		successCriteria: string[];
+		forbiddenActions: string[];
+	};
+	recentDispatches: ResolveIOAIManagerAutopilotRecentDispatch[];
+	cost: {
+		currentRunUsd: number;
+		totalUsd: number;
+		currentRunTokens: number;
+		totalTokens: number;
+		untrackedWarning: string;
+	};
+	updatedAt: string;
+}
+
+export interface ResolveIOAIManagerAutopilotSnapshotInput {
+	surface: string;
+	runId?: string;
+	title?: string;
+	status?: string;
+	phase?: string;
+	lane?: string;
+	stepType?: string;
+	runKind?: string;
+	current?: ResolveIOAIManagerFailureRecord;
+	recoveryPlan?: ResolveIOAIManagerRecoveryPlan;
+	recoveryCheckpoint?: ResolveIOAIManagerRecoveryCheckpoint;
+	recoveryEvidenceProbe?: ResolveIOAIManagerRecoveryEvidenceProbe;
+	recoveryAction?: ResolveIOAIManagerRecoveryActionPacket;
+	recoveryDirective?: ResolveIOAIManagerRecoveryExecutionDirective;
+	recoveryDispatchHistory?: ResolveIOAIManagerRecoveryActionDispatchRecord[];
+	loopCount?: number;
+	maxLoopCount?: number;
+	currentRunUsd?: number;
+	totalUsd?: number;
+	currentRunTokens?: number;
+	totalTokens?: number;
+	untrackedCostWarning?: string;
+	updatedAt?: Date | string;
+}
+
+function cleanText(value: any, max = 1000): string {
+	return String(value || '').replace(/\s+/g, ' ').trim().slice(0, max);
+}
+
+function cleanList(value: any, limit = 20, max = 500): string[] {
+	const raw = Array.isArray(value) ? value : [];
+	const output: string[] = [];
+	for (const entry of raw) {
+		const cleaned = cleanText(entry, max);
+		if (cleaned && !output.includes(cleaned)) {
+			output.push(cleaned);
+		}
+		if (output.length >= limit) {
+			break;
+		}
+	}
+	return output;
+}
+
+function cleanNumber(value: any): number {
+	const parsed = Number(value);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+}
+
+function isoNow(value?: Date | string): string {
+	if (value instanceof Date) {
+		return value.toISOString();
+	}
+	const parsed = value ? new Date(value) : new Date();
+	return Number.isFinite(parsed.getTime()) ? parsed.toISOString() : new Date().toISOString();
+}
+
+function defaultLabelForAction(action: string): string {
+	switch (action) {
+		case 'run_evidence_probe':
+			return 'Collect New Evidence';
+		case 'run_read_only_diagnosis':
+			return 'Run Diagnosis';
+		case 'run_infra_repair':
+			return 'Repair Infra';
+		case 'run_compile_repair':
+			return 'Repair Compile';
+		case 'run_journey_contract_repair':
+			return 'Repair Journey';
+		case 'run_business_assertion_repair':
+			return 'Repair Business Proof';
+		case 'run_release_repair':
+			return 'Repair Release';
+		case 'run_targeted_product_repair':
+			return 'Run Targeted Repair';
+		case 'advance':
+			return 'Advance';
+		case 'continue_gate':
+			return 'Continue Gate';
+		case 'park_manual':
+			return 'Attach New Evidence';
+		default:
+			return action ? cleanText(action.replace(/_/g, ' '), 120) : 'Review Manager State';
+	}
+}
+
+function expectedResultForAction(action: string, evidenceOnly: boolean): string {
+	if (action === 'park_manual') {
+		return 'Runner stays parked until new evidence, operator approval, or a changed blocker is recorded.';
+	}
+	if (evidenceOnly || action === 'run_evidence_probe' || action === 'run_read_only_diagnosis') {
+		return 'Runner records a new artifact path or changed evidence hash before any more product repair.';
+	}
+	if (action === 'run_infra_repair' || action === 'run_compile_repair' || action === 'run_release_repair') {
+		return 'Runner repairs only the named deterministic gate and reruns that gate.';
+	}
+	if (action === 'run_targeted_product_repair') {
+		return 'Runner performs one bounded owner-scope repair and then returns to deterministic proof.';
+	}
+	return 'Runner advances only after the current gate has proof.';
+}
+
+function safetyFor(input: {
+	action: string;
+	enabled: boolean;
+	evidenceOnly: boolean;
+	productRepairAllowed: boolean;
+	expensiveModelAllowed: boolean;
+}): ResolveIOAIManagerAutopilotSafetyLevel {
+	if (!input.enabled || input.action === 'park_manual') {
+		return 'blocked';
+	}
+	if (input.evidenceOnly || input.action === 'run_evidence_probe' || input.action === 'run_read_only_diagnosis') {
+		return 'low';
+	}
+	if (input.expensiveModelAllowed || input.action === 'run_targeted_product_repair') {
+		return 'high';
+	}
+	if (input.productRepairAllowed) {
+		return 'medium';
+	}
+	return 'medium';
+}
+
+function resolveDispatchAction(input: ResolveIOAIManagerAutopilotSnapshotInput): string {
+	const directiveAction = cleanText(input.recoveryDirective?.dispatchAction, 120);
+	if (directiveAction) {
+		return directiveAction;
+	}
+	const actionMode = cleanText(input.recoveryAction?.mode, 120);
+	switch (actionMode) {
+		case 'collect_evidence':
+			return 'run_evidence_probe';
+		case 'read_only_diagnosis':
+			return 'run_read_only_diagnosis';
+		case 'repair_infra':
+			return 'run_infra_repair';
+		case 'repair_compile':
+			return 'run_compile_repair';
+		case 'repair_journey_contract':
+			return 'run_journey_contract_repair';
+		case 'repair_business_assertion':
+			return 'run_business_assertion_repair';
+		case 'repair_release':
+			return 'run_release_repair';
+		case 'targeted_product_repair':
+			return 'run_targeted_product_repair';
+		case 'advance':
+			return 'advance';
+		case 'continue_gate':
+			return 'continue_gate';
+		case 'manual_review':
+			return 'park_manual';
+		default:
+			return input.recoveryCheckpoint?.status === 'parked' ? 'run_evidence_probe' : 'continue_gate';
+	}
+}
+
+function countSameEvidenceDispatches(input: ResolveIOAIManagerAutopilotSnapshotInput, dispatchAction: string): number {
+	const checkpointId = cleanText(input.recoveryCheckpoint?.checkpointId || input.recoveryAction?.checkpointId, 160);
+	const actionId = cleanText(input.recoveryAction?.actionId, 160);
+	const evidenceHash = cleanText(input.current?.evidenceHash || input.recoveryCheckpoint?.evidenceHash, 160);
+	const blockerFingerprint = cleanText(input.current?.blockerFingerprint || input.recoveryCheckpoint?.blockerFingerprint, 160);
+	const history = Array.isArray(input.recoveryDispatchHistory) ? input.recoveryDispatchHistory : [];
+	return history.filter((entry) => {
+		const sameCheckpoint = checkpointId && cleanText(entry?.checkpointId, 160) === checkpointId;
+		const sameAction = actionId && cleanText(entry?.actionId, 160) === actionId;
+		const sameEvidence = !evidenceHash || cleanText(entry?.evidenceHash, 160) === evidenceHash;
+		const sameBlocker = !blockerFingerprint || cleanText(entry?.blockerFingerprint, 160) === blockerFingerprint;
+		const sameDispatchAction = !dispatchAction
+			|| dispatchAction === 'park_manual'
+			|| cleanText(entry?.dispatchAction, 120) === dispatchAction
+			|| cleanText(entry?.dispatchAction, 120) === 'park_manual';
+		return (sameCheckpoint || sameAction) && sameEvidence && sameBlocker && sameDispatchAction;
+	}).length;
+}
+
+function normalizeRecentDispatches(history: ResolveIOAIManagerRecoveryActionDispatchRecord[] | undefined): ResolveIOAIManagerAutopilotRecentDispatch[] {
+	const source = Array.isArray(history) ? history.filter(Boolean) : [];
+	return source.slice(-5).reverse().map((entry) => ({
+		dispatchId: cleanText(entry?.dispatchId, 160),
+		actionId: cleanText(entry?.actionId, 160),
+		checkpointId: cleanText(entry?.checkpointId, 160),
+		probeId: cleanText(entry?.probeId, 160),
+		mode: cleanText(entry?.mode, 120),
+		dispatchAction: cleanText(entry?.dispatchAction, 120),
+		status: cleanText(entry?.status, 80),
+		reason: cleanText(entry?.reason, 500),
+		evidenceHash: cleanText(entry?.evidenceHash, 160),
+		blockerFingerprint: cleanText(entry?.blockerFingerprint, 160),
+		artifactPaths: cleanList(entry?.artifactPaths, 8, 500),
+		startedAt: cleanText(entry?.startedAt, 80),
+		completedAt: cleanText(entry?.completedAt, 80),
+		createdAt: cleanText(entry?.createdAt, 80)
+	}));
+}
+
+export function buildResolveIOAIManagerAutopilotSnapshot(
+	input: ResolveIOAIManagerAutopilotSnapshotInput
+): ResolveIOAIManagerAutopilotSnapshot {
+	const dispatchAction = resolveDispatchAction(input);
+	const directiveAllowed = input.recoveryDirective
+		? input.recoveryDirective.allowed === true
+		: input.recoveryAction?.autoRunnable === true;
+	const evidenceOnly = input.recoveryDirective?.evidenceOnly === true
+		|| input.recoveryAction?.evidenceOnly === true
+		|| input.recoveryEvidenceProbe?.evidenceOnly === true
+		|| input.recoveryCheckpoint?.status === 'parked';
+	const productRepairAllowed = (input.recoveryDirective?.canRunProductRepair ?? input.recoveryDirective?.productRepairAllowed ?? input.recoveryAction?.productRepairAllowed ?? input.recoveryCheckpoint?.productRepairAllowed) === true;
+	const expensiveModelAllowed = (input.recoveryDirective?.canRunExpensiveModel ?? input.recoveryDirective?.expensiveModelAllowed ?? input.recoveryAction?.expensiveModelAllowed ?? input.recoveryCheckpoint?.expensiveModelAllowed) === true;
+	const requiresNewEvidence = input.recoveryDirective?.requiresNewEvidence === true
+		|| input.recoveryAction?.retryPolicy?.requireNewEvidence === true
+		|| input.recoveryCheckpoint?.status === 'parked';
+	const sameEvidenceDispatchCount = countSameEvidenceDispatches(input, dispatchAction);
+	const sameEvidenceAlreadyAttempted = requiresNewEvidence && sameEvidenceDispatchCount > 0 && input.recoveryDirective?.newEvidence !== true;
+	const checkpointStatus = cleanText(input.recoveryCheckpoint?.status, 80);
+	const evidenceAssessment = input.recoveryCheckpoint && input.current
+		? assessResolveIOAIManagerEvidenceChange(input.recoveryCheckpoint, input.current, input.recoveryCheckpoint.objective)
+		: {
+			changed: false,
+			material: false,
+			strength: 'none',
+			signals: [] as string[]
+		};
+	const loopState = checkpointStatus === 'manual_handoff'
+		? 'manual_handoff'
+		: checkpointStatus === 'complete'
+			? 'complete'
+			: sameEvidenceAlreadyAttempted || input.recoveryDirective?.allowed === false
+				? 'parked'
+				: evidenceOnly && requiresNewEvidence
+					? 'collecting_evidence'
+					: 'clear';
+	const enabled = directiveAllowed && !sameEvidenceAlreadyAttempted && loopState !== 'manual_handoff';
+	const recommendedAction = sameEvidenceAlreadyAttempted || input.recoveryDirective?.allowed === false
+		? 'park_manual'
+		: dispatchAction;
+	const label = cleanText(
+		sameEvidenceAlreadyAttempted
+			? 'Attach New Evidence'
+			: input.recoveryDirective?.nextActionLabel || input.recoveryAction?.label || defaultLabelForAction(recommendedAction),
+		140
+	);
+	const reason = cleanText(
+		sameEvidenceAlreadyAttempted
+			? 'The same recovery action already ran against the same evidence; a new artifact path or changed evidence hash is required.'
+			: input.recoveryDirective?.reason || input.recoveryAction?.blockedReason || input.recoveryPlan?.objective || input.current?.blocker || 'Manager can continue the current gate.',
+		1000
+	);
+	const canResetLoopAfterEvidence = input.recoveryDirective?.canResetLoopAfterEvidence === true
+		|| input.recoveryAction?.canResetLoopAfterEvidence === true
+		|| cleanList(input.recoveryCheckpoint?.loopResetEvidence, 20, 500).length > 0;
+	const resetRequires = cleanList(
+		input.recoveryAction?.retryPolicy?.resetLoopWhen?.length
+			? input.recoveryAction.retryPolicy.resetLoopWhen
+			: input.recoveryCheckpoint?.loopResetEvidence,
+		20,
+		500
+	);
+	return {
+		surface: cleanText(input.surface || 'unknown', 120),
+		runId: cleanText(input.runId, 160),
+		title: cleanText(input.title, 240),
+		status: cleanText(input.status || input.recoveryCheckpoint?.status, 80),
+		phase: cleanText(input.phase || input.recoveryDirective?.phase, 80),
+		lane: cleanText(input.lane || input.recoveryDirective?.lane || input.recoveryCheckpoint?.lane || input.current?.lane, 120),
+		stepType: cleanText(input.stepType || input.recoveryDirective?.stepType || input.recoveryCheckpoint?.stepType || input.current?.stepType, 120),
+		runKind: cleanText(input.runKind, 120),
+		recommendedAction: {
+			action: recommendedAction,
+			label,
+			reason,
+			safety: safetyFor({
+				action: recommendedAction,
+				enabled,
+				evidenceOnly,
+				productRepairAllowed,
+				expensiveModelAllowed
+			}),
+			enabled,
+			autoRunnable: enabled && input.recoveryAction?.autoRunnable !== false,
+			expectedResult: expectedResultForAction(recommendedAction, evidenceOnly),
+			requiresNewEvidence,
+			canRunProductRepair: enabled && productRepairAllowed,
+			canRunExpensiveModel: enabled && expensiveModelAllowed,
+			canResetLoopAfterEvidence,
+			dispatchAction
+		},
+		loopGuard: {
+			state: loopState,
+			blocked: loopState === 'parked' || loopState === 'manual_handoff',
+			reason,
+			failureClass: cleanText(input.current?.failureClass, 120),
+			blocker: cleanText(input.current?.blocker || input.current?.summary, 1000),
+			blockerFingerprint: cleanText(input.current?.blockerFingerprint || input.recoveryCheckpoint?.blockerFingerprint, 160),
+			evidenceHash: cleanText(input.current?.evidenceHash || input.recoveryCheckpoint?.evidenceHash, 160),
+			materialEvidence: evidenceAssessment.material === true,
+			evidenceStrength: cleanText(evidenceAssessment.strength, 40),
+			evidenceSignals: cleanList(evidenceAssessment.signals, 12, 120),
+			sameEvidenceDispatchCount,
+			sameEvidenceAlreadyAttempted,
+			loopCount: cleanNumber(input.loopCount),
+			maxLoopCount: cleanNumber(input.maxLoopCount),
+			attempts: cleanNumber(input.recoveryCheckpoint?.attempts),
+			maxAttemptsBeforePark: cleanNumber(input.recoveryCheckpoint?.maxAttemptsBeforePark),
+			canResetLoopAfterEvidence,
+			resetRequires
+		},
+		recovery: {
+			checkpointId: cleanText(input.recoveryCheckpoint?.checkpointId || input.recoveryAction?.checkpointId, 160),
+			recoveryClass: cleanText(input.recoveryCheckpoint?.recoveryClass || input.recoveryAction?.recoveryClass || input.recoveryPlan?.recoveryClass, 120),
+			dispatchAction,
+			directiveAllowed,
+			evidenceOnly,
+			productRepairAllowed,
+			expensiveModelAllowed,
+			requiredArtifacts: cleanList(input.recoveryDirective?.requiredArtifacts?.length ? input.recoveryDirective.requiredArtifacts : input.recoveryAction?.requiredArtifacts, 20, 500),
+			nextCommands: cleanList(input.recoveryDirective?.nextCommands?.length ? input.recoveryDirective.nextCommands : input.recoveryAction?.nextCommands, 20, 500),
+			successCriteria: cleanList(input.recoveryDirective?.successCriteria?.length ? input.recoveryDirective.successCriteria : input.recoveryAction?.successCriteria, 20, 500),
+			forbiddenActions: cleanList(input.recoveryDirective?.forbiddenActions?.length ? input.recoveryDirective.forbiddenActions : input.recoveryAction?.retryPolicy?.stopWhen, 20, 500)
+		},
+		recentDispatches: normalizeRecentDispatches(input.recoveryDispatchHistory),
+		cost: {
+			currentRunUsd: cleanNumber(input.currentRunUsd),
+			totalUsd: cleanNumber(input.totalUsd),
+			currentRunTokens: cleanNumber(input.currentRunTokens),
+			totalTokens: cleanNumber(input.totalTokens),
+			untrackedWarning: cleanText(input.untrackedCostWarning || 'Manual Codex sessions outside this runner are not included unless recorded in the usage ledger.', 500)
+		},
+		updatedAt: isoNow(input.updatedAt)
+	};
+}