@resolveio/server-lib 22.3.150 → 22.3.151

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

@@ -1,434 +0,0 @@
-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)
-	};
-}