@resolveio/server-lib 22.3.176 → 22.3.178

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

@@ -1,4193 +0,0 @@
-export type ResolveIOAIManagerAction =
-	| 'continue'
-	| 'retry_infra'
-	| 'reset_loop_budget'
-	| 'park_repeated_failure'
-	| 'park_ping_pong'
-	| 'manual_handoff';
-
-export interface ResolveIOAIManagerFailureRecord {
-	outcome?: string;
-	lane?: string;
-	stepType?: string;
-	failureClass?: string;
-	blocker?: string;
-	blockerFingerprint?: string;
-	evidenceHash?: string;
-	changedFiles?: string[];
-	artifactPaths?: string[];
-	summary?: string;
-	recordedAt?: Date | string;
-}
-
-export type ResolveIOAIManagerEvidenceStrength = 'none' | 'weak' | 'material' | 'proof';
-
-export interface ResolveIOAIManagerEvidenceAssessment {
-	changed: boolean;
-	material: boolean;
-	strength: ResolveIOAIManagerEvidenceStrength;
-	signals: string[];
-	evidenceHash: string;
-	blockerFingerprint: string;
-}
-
-export type ResolveIOAIManagerRecoveryClass =
-	| 'advance_after_proof'
-	| 'diagnosis_only'
-	| 'diagnosis_revision'
-	| 'infra_repair'
-	| 'compile_repair'
-	| 'journey_contract_repair'
-	| 'business_proof_repair'
-	| 'release_repair'
-	| 'product_code_repair'
-	| 'blocked_until_new_evidence'
-	| 'manual_handoff'
-	| 'continue';
-
-export interface ResolveIOAIManagerRecoveryPlan {
-	recoveryClass: ResolveIOAIManagerRecoveryClass;
-	lane: string;
-	stepType: string;
-	nextActionLabel: string;
-	objective: string;
-	allowedAction: string;
-	productRepairAllowed: boolean;
-	expensiveModelAllowed: boolean;
-	maxAttemptsBeforePark: number;
-	finiteSteps: string[];
-	requiredEvidence: string[];
-	loopResetEvidence: string[];
-	forbiddenActions: string[];
-	notes: string[];
-}
-
-export type ResolveIOAIManagerRecoveryCheckpointStatus =
-	| 'active'
-	| 'parked'
-	| 'manual_handoff'
-	| 'complete';
-
-export interface ResolveIOAIManagerRecoveryCheckpoint {
-	checkpointId: string;
-	recoveryClass: ResolveIOAIManagerRecoveryClass;
-	status: ResolveIOAIManagerRecoveryCheckpointStatus;
-	lane: string;
-	stepType: string;
-	allowedAction: string;
-	productRepairAllowed: boolean;
-	expensiveModelAllowed: boolean;
-	attempts: number;
-	maxAttemptsBeforePark: number;
-	blockerFingerprint: string;
-	evidenceHash: string;
-	changedFiles: string[];
-	artifactPaths: string[];
-	requiredEvidence: string[];
-	loopResetEvidence: string[];
-	forbiddenActions: string[];
-	objective: string;
-	nextActionLabel: string;
-	createdAt: string;
-	updatedAt: string;
-}
-
-export type ResolveIOAIManagerRecoveryEvidenceProbeStepKind =
-	| 'read_only_diagnosis'
-	| 'rerun_same_gate'
-	| 'infra_preflight'
-	| 'compile_check'
-	| 'route_probe'
-	| 'business_assertion'
-	| 'journey_validation'
-	| 'release_status'
-	| 'diff_scope_check'
-	| 'operator_review';
-
-export interface ResolveIOAIManagerRecoveryEvidenceProbeStep {
-	id: string;
-	kind: ResolveIOAIManagerRecoveryEvidenceProbeStepKind;
-	label: string;
-	objective: string;
-	required: boolean;
-	commandHint?: string;
-	artifactExpectation: string;
-	successSignal: string;
-}
-
-export interface ResolveIOAIManagerRecoveryEvidenceProbe {
-	probeId: string;
-	checkpointId: string;
-	recoveryClass: ResolveIOAIManagerRecoveryClass;
-	lane: string;
-	stepType: string;
-	objective: string;
-	evidenceOnly: boolean;
-	productRepairAllowed: boolean;
-	expensiveModelAllowed: boolean;
-	evidenceHashBefore: string;
-	blockerFingerprint: string;
-	steps: ResolveIOAIManagerRecoveryEvidenceProbeStep[];
-	requiredArtifacts: string[];
-	acceptanceEvidence: string[];
-	stopConditions: string[];
-	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 type ResolveIOAIManagerHotfixFirstReleaseAction =
-	| 'wait_for_active_deploy'
-	| 'block_duplicate_deploy'
-	| 'block_duplicate_publish'
-	| 'review_force_deploy'
-	| 'hotfix_release_artifact'
-	| 'deploy_new_artifact_after_release_gate'
-	| 'build_artifact_first';
-
-export type ResolveIOAIManagerHotfixChannel =
-	| 'static_ui'
-	| 'backend_js'
-	| 'config'
-	| 'seed_data'
-	| 'cache_invalidation'
-	| 'service_restart'
-	| 'release_artifact'
-	| 'force_deploy_review'
-	| 'new_artifact_deploy'
-	| 'artifact_build';
-
-export interface ResolveIOAIManagerHotfixPlanStep {
-	id: string;
-	label: string;
-	channel: ResolveIOAIManagerHotfixChannel;
-	safeToAutoRun: boolean;
-	requiresFullDeploy: boolean;
-	requiredEvidence: string[];
-	successEvidence: string[];
-	blockedBy: string[];
-}
-
-export interface ResolveIOAIManagerHotfixPlan {
-	planId: string;
-	label: string;
-	recommendedChannel: ResolveIOAIManagerHotfixChannel;
-	reason: string;
-	fullDeployAvoided: boolean;
-	steps: ResolveIOAIManagerHotfixPlanStep[];
-	acceptanceEvidence: string[];
-	escalationTriggers: string[];
-}
-
-export interface ResolveIOAIManagerHotfixFirstReleasePolicyInput {
-	surface?: string;
-	activeDeploy?: boolean;
-	deployFingerprint?: string;
-	lastDeployFingerprint?: string;
-	publishFingerprint?: string;
-	lastPublishFingerprint?: string;
-	deployStatus?: string;
-	publishStatus?: string;
-	sampleDataStatus?: string;
-	forceDeploy?: boolean;
-	forcePublish?: boolean;
-	hasNewArtifact?: boolean;
-}
-
-export interface ResolveIOAIManagerHotfixFirstReleasePolicy {
-	policy: 'hotfix_first';
-	surface: string;
-	recommendedAction: ResolveIOAIManagerHotfixFirstReleaseAction;
-	label: string;
-	reason: string;
-	hotfixPreferred: boolean;
-	fullDeployAllowed: boolean;
-	duplicateDeployBlocked: boolean;
-	duplicatePublishBlocked: boolean;
-	forceDeployRequiredToRepeat: boolean;
-	forcePublishRequiredToRepeat: boolean;
-	statuses: {
-		deploy: string;
-		publish: string;
-		sampleData: string;
-	};
-	fingerprints: {
-		current: string;
-		last: string;
-		matchesLast: boolean;
-		publishCurrent: string;
-		publishLast: string;
-		publishMatchesLast: boolean;
-	};
-	hotfixPlan: ResolveIOAIManagerHotfixPlan;
-	allowedActions: string[];
-	forbiddenActions: string[];
-	requiredEvidence: string[];
-}
-
-export type ResolveIOAIManagerHotfixEvidenceStatus =
-	| 'missing'
-	| 'incomplete'
-	| 'passed'
-	| 'blocked';
-
-export interface ResolveIOAIManagerHotfixEvidenceTarget {
-	surface?: string;
-	host?: string;
-	path?: string;
-	artifactPath?: string;
-	bucket?: string;
-	distributionId?: string;
-	processName?: string;
-	configKey?: string;
-	cacheKey?: string;
-	seedKey?: string;
-}
-
-export interface ResolveIOAIManagerHotfixEvidence {
-	channel: ResolveIOAIManagerHotfixChannel;
-	status?: ResolveIOAIManagerHotfixEvidenceStatus | string;
-	target: ResolveIOAIManagerHotfixEvidenceTarget;
-	compiledArtifactPath?: string;
-	builtDistPath?: string;
-	remoteChecksumBefore?: string;
-	remoteChecksumAfter?: string;
-	remoteChecksum?: string;
-	restartEvidence?: string;
-	healthCheckStatus?: string;
-	selfTestStatus?: string;
-	releaseGateStatus?: string;
-	s3UploadResult?: string;
-	cloudfrontInvalidationId?: string;
-	publicProof?: string;
-	configChangeEvidence?: string;
-	seedDataEvidence?: string;
-	cacheInvalidationEvidence?: string;
-	serviceRestartEvidence?: string;
-	releaseArtifactFingerprint?: string;
-	lastReleaseArtifactFingerprint?: string;
-	sourceCommitSha?: string;
-	githubCommitUrl?: string;
-	gitCommitStatus?: string;
-	gitPushStatus?: string;
-	committedAt?: Date | string;
-	forceDeployReason?: string;
-	hotfixCannotResolveReason?: string;
-	fullDeployRequested?: boolean;
-	recordedAt?: Date | string;
-}
-
-export interface ResolveIOAIManagerHotfixEvidenceValidation {
-	valid: boolean;
-	status: ResolveIOAIManagerHotfixEvidenceStatus;
-	channel: ResolveIOAIManagerHotfixChannel | '';
-	blockers: string[];
-	warnings: string[];
-	fullDeployAllowed: boolean;
-	fullDeployBlocked: boolean;
-	hotfixSatisfied: boolean;
-	requiredEvidence: string[];
-	successEvidence: string[];
-	normalized?: ResolveIOAIManagerHotfixEvidence;
-	githubCommitGuard: ResolveIOAIManagerHotfixGitProof;
-	policy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
-	nextAction: 'record_hotfix_evidence' | 'rerun_release_gate' | 'request_force_deploy_reason' | 'allow_one_full_deploy' | 'park_manual';
-}
-
-export type ResolveIOAIManagerHotfixGitProofStatus =
-	| 'not_required'
-	| 'missing'
-	| 'invalid'
-	| 'passed';
-
-export interface ResolveIOAIManagerHotfixGitProof {
-	required: boolean;
-	status: ResolveIOAIManagerHotfixGitProofStatus;
-	passed: boolean;
-	managerMustCommitBeforeHotfix: boolean;
-	channel: ResolveIOAIManagerHotfixChannel | '';
-	sourceCommitSha: string;
-	githubCommitUrl: string;
-	githubCommitSha: string;
-	gitCommitStatus: string;
-	gitPushStatus: string;
-	blockers: string[];
-	nextCommands: string[];
-	requiredEvidence: string[];
-}
-
-export type ResolveIOAIManagerHotfixContinuationAction =
-	| 'record_hotfix_evidence'
-	| 'rerun_release_gate'
-	| 'continue_runner'
-	| 'request_force_deploy_reason'
-	| 'allow_one_full_deploy'
-	| 'park_manual';
-
-export interface ResolveIOAIManagerHotfixContinuationInput {
-	evidence?: any;
-	policy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
-	releaseGatePassed?: boolean;
-	repeatedFailure?: boolean;
-	failureClass?: string;
-	blocker?: string;
-	now?: Date | string;
-}
-
-export interface ResolveIOAIManagerHotfixContinuationDecision {
-	action: ResolveIOAIManagerHotfixContinuationAction;
-	canContinueRun: boolean;
-	canRunFullDeploy: boolean;
-	shouldRerunReleaseGate: boolean;
-	shouldPark: boolean;
-	reason: string;
-	blockers: string[];
-	warnings: string[];
-	requiredEvidence: string[];
-	successEvidence: string[];
-	nextCommands: string[];
-	failureClass: string;
-	blockerFingerprint: string;
-	githubCommitGuard: ResolveIOAIManagerHotfixGitProof;
-	validation: ResolveIOAIManagerHotfixEvidenceValidation;
-	recordedAt: string;
-}
-
-export interface ResolveIOAIManagerHotfixCommitGuardDecision {
-	active: boolean;
-	blocked: boolean;
-	reason: string;
-	nextAction: 'record_hotfix_evidence' | 'continue';
-	channel: ResolveIOAIManagerHotfixChannel | '';
-	blockers: string[];
-	nextCommands: string[];
-	requiredEvidence: string[];
-	githubCommitGuard: ResolveIOAIManagerHotfixGitProof;
-	validation: ResolveIOAIManagerHotfixEvidenceValidation;
-}
-
-export type ResolveIOAIManagerHotfixEvidenceRecordSource =
-	| 'manual'
-	| 'manager'
-	| 'runner_console'
-	| 'hotfix_script'
-	| 'deploy_script'
-	| 'unknown';
-
-export interface ResolveIOAIManagerHotfixEvidenceRecordInput extends Partial<ResolveIOAIManagerHotfixEvidence> {
-	evidence?: any;
-	policy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
-	recordId?: string;
-	reason?: string;
-	recordedBy?: string;
-	source?: ResolveIOAIManagerHotfixEvidenceRecordSource | string;
-	now?: Date | string;
-}
-
-export interface ResolveIOAIManagerHotfixEvidenceRecord {
-	recordId: string;
-	recordedAt: string;
-	recordedBy: string;
-	source: ResolveIOAIManagerHotfixEvidenceRecordSource | string;
-	reason: string;
-	channel: ResolveIOAIManagerHotfixChannel | '';
-	status: ResolveIOAIManagerHotfixEvidenceStatus;
-	nextAction: ResolveIOAIManagerHotfixEvidenceValidation['nextAction'];
-	valid: boolean;
-	hotfixSatisfied: boolean;
-	fullDeployAllowed: boolean;
-	fullDeployBlocked: boolean;
-	requiredFields: string[];
-	missingFields: string[];
-	evidence: ResolveIOAIManagerHotfixEvidence | undefined;
-	validation: ResolveIOAIManagerHotfixEvidenceValidation;
-	sourceCommitSha: string;
-	githubCommitUrl: string;
-	gitPushStatus: string;
-	githubCommitRequired: boolean;
-	githubCommitProofPassed: boolean;
-	commitProofStatus: 'not_required' | 'missing' | 'invalid' | 'passed';
-	managerMustCommitBeforeHotfix: boolean;
-	githubCommitGuard: ResolveIOAIManagerHotfixGitProof;
-	readyForReleaseGate: boolean;
-	readyForContinuation: boolean;
-}
-
-export interface ResolveIOAIManagerRecoveryActionPacket {
-	actionId: string;
-	checkpointId: string;
-	probeId: string;
-	recoveryClass: ResolveIOAIManagerRecoveryClass;
-	mode: ResolveIOAIManagerRecoveryAutomationMode;
-	singleActionOnly: boolean;
-	allowedDispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
-	label: string;
-	lane: string;
-	stepType: string;
-	primaryStepKind: ResolveIOAIManagerRecoveryEvidenceProbeStepKind | 'none';
-	objective: string;
-	evidenceOnly: boolean;
-	autoRunnable: boolean;
-	productRepairAllowed: boolean;
-	expensiveModelAllowed: boolean;
-	costCeilingUsd: number;
-	requiredStateTransition: string;
-	proofRequiredBeforeContinuation: boolean;
-	canResetLoopAfterEvidence: boolean;
-	maxAttemptsBeforePark: number;
-	requiredArtifacts: string[];
-	nextCommands: string[];
-	successCriteria: string[];
-	exitCriteria: string[];
-	retryPolicy: ResolveIOAIManagerRecoveryActionRetryPolicy;
-	releasePolicy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
-	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 interface ResolveIOAIManagerAutoDispatchPolicyInput {
-	dispatchAction?: ResolveIOAIManagerRecoveryActionDispatchAction | string;
-	directive?: Partial<ResolveIOAIManagerRecoveryExecutionDirective>;
-	action?: Partial<ResolveIOAIManagerRecoveryActionPacket>;
-	includeJourneyContractRepair?: boolean;
-	includeReleaseRepair?: boolean;
-	includeBusinessProofRepair?: boolean;
-	includeProductRepair?: boolean;
-}
-
-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;
-	autonomyPolicy?: ResolveIOAIManagerAutonomyPolicyInput;
-	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;
-	autonomyPolicy?: ResolveIOAIManagerAutonomyPolicyDecision;
-	dispatchRecord?: ResolveIOAIManagerRecoveryActionDispatchRecord;
-}
-
-export type ResolveIOAIManagerAutonomyMode =
-	| 'manual_only'
-	| 'monitor_only'
-	| 'auto_retry_within_budget';
-
-export interface ResolveIOAIManagerAutonomyPolicyInput {
-	mode?: ResolveIOAIManagerAutonomyMode | string;
-	currentSpendUsd?: number;
-	budgetSoftUsd?: number;
-	budgetHardUsd?: number;
-	projectedActionCostUsd?: number;
-	dispatchAction?: ResolveIOAIManagerRecoveryActionDispatchAction | string;
-	expectedValueScore?: number;
-	minExpectedValueScore?: number;
-	evidenceStrength?: ResolveIOAIManagerEvidenceStrength | string;
-	materialEvidence?: boolean;
-	newEvidence?: boolean;
-	evidenceSignals?: string[];
-	sameEvidenceAlreadyAttempted?: boolean;
-	allowEvidenceProbeWithoutExpectedValue?: boolean;
-	operatorApproved?: boolean;
-}
-
-export interface ResolveIOAIManagerRetryExpectedValueInput {
-	dispatchAction?: ResolveIOAIManagerRecoveryActionDispatchAction | string;
-	projectedActionCostUsd?: number;
-	currentSpendUsd?: number;
-	budgetHardUsd?: number;
-	failureClass?: string;
-	recoveryClass?: ResolveIOAIManagerRecoveryClass | string;
-	evidenceStrength?: ResolveIOAIManagerEvidenceStrength | string;
-	materialEvidence?: boolean;
-	newEvidence?: boolean;
-	evidenceSignals?: string[];
-	sameEvidenceAlreadyAttempted?: boolean;
-}
-
-export interface ResolveIOAIManagerRetryExpectedValueEstimate {
-	score: number;
-	minScore: number;
-	positive: boolean;
-	source: 'estimated';
-	confidence: 'low' | 'medium' | 'high';
-	reason: string;
-	signals: string[];
-}
-
-export interface ResolveIOAIManagerAutonomyPolicyDecision {
-	mode: ResolveIOAIManagerAutonomyMode;
-	canAutoDispatch: boolean;
-	canManualDispatch: boolean;
-	blocked: boolean;
-	requiresHumanApproval: boolean;
-	reason: string;
-	currentSpendUsd: number;
-	projectedActionCostUsd: number;
-	projectedSpendUsd: number;
-	budgetSoftUsd: number;
-	budgetHardUsd: number;
-	softBudgetExceeded: boolean;
-	hardBudgetExceeded: boolean;
-	dispatchAction: string;
-	expectedValueScore: number;
-	minExpectedValueScore: number;
-	expectedValueKnown: boolean;
-	expectedValueSource: 'provided' | 'estimated';
-	expectedValuePositive: boolean;
-	evidenceStrength: ResolveIOAIManagerEvidenceStrength;
-	materialEvidence: boolean;
-	newEvidence: boolean;
-	evidenceBacked: boolean;
-	evidenceSignals: string[];
-	recommendedControl: 'manual_only' | 'monitor_only' | 'auto_retry_within_budget' | 'increase_budget_or_manual';
-	forbiddenActions: string[];
-	requiredEvidence: string[];
-}
-
-export type ResolveIOAIManagerRecoveryExecutionPhase =
-	| 'evidence'
-	| 'diagnosis'
-	| 'infra'
-	| 'compile'
-	| 'journey'
-	| 'business_proof'
-	| 'release'
-	| 'product_repair'
-	| 'advance'
-	| 'manual';
-
-export interface ResolveIOAIManagerRecoveryExecutionDirectiveInput {
-	action?: ResolveIOAIManagerRecoveryActionPacket;
-	dispatchDecision?: ResolveIOAIManagerRecoveryActionDispatchDecision;
-	current?: ResolveIOAIManagerFailureRecord;
-	autonomyPolicy?: ResolveIOAIManagerAutonomyPolicyInput;
-	surface?: string;
-	now?: Date | string;
-}
-
-export interface ResolveIOAIManagerRecoveryExecutionDirective {
-	directiveId: string;
-	surface: string;
-	dispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
-	phase: ResolveIOAIManagerRecoveryExecutionPhase;
-	allowed: boolean;
-	status: ResolveIOAIManagerRecoveryActionDispatchStatus;
-	reason: string;
-	singleActionOnly: boolean;
-	allowedDispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
-	lane: string;
-	stepType: string;
-	nextActionLabel: string;
-	rerunReason: string;
-	evidenceOnly: boolean;
-	autoRunnable: boolean;
-	productRepairAllowed: boolean;
-	expensiveModelAllowed: boolean;
-	costCeilingUsd: number;
-	requiredStateTransition: string;
-	proofRequiredBeforeContinuation: boolean;
-	canRunProductRepair: boolean;
-	canRunExpensiveModel: boolean;
-	canResetLoopAfterEvidence: boolean;
-	requiresNewEvidence: boolean;
-	newEvidence: boolean;
-	autonomyPolicy?: ResolveIOAIManagerAutonomyPolicyDecision;
-	maxAttemptsBeforePark: number;
-	requiredArtifacts: string[];
-	nextCommands: string[];
-	successCriteria: string[];
-	exitCriteria: string[];
-	forbiddenActions: string[];
-	dispatchRecord?: ResolveIOAIManagerRecoveryActionDispatchRecord;
-	releasePolicy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
-	createdAt: string;
-}
-
-export interface ResolveIOAIManagerRecoveryCheckpointInput {
-	plan: ResolveIOAIManagerRecoveryPlan;
-	current?: ResolveIOAIManagerFailureRecord;
-	previousCheckpoint?: ResolveIOAIManagerRecoveryCheckpoint;
-	now?: Date | string;
-}
-
-export type ResolveIOAIManagerRecoveryGateAction =
-	| 'allow'
-	| 'collect_new_evidence'
-	| 'reject_action'
-	| 'manual_handoff'
-	| 'complete';
-
-export interface ResolveIOAIManagerRecoveryGateInput {
-	checkpoint: ResolveIOAIManagerRecoveryCheckpoint;
-	current?: ResolveIOAIManagerFailureRecord;
-	proposedAction?: string;
-	operatorApproved?: boolean;
-	now?: Date | string;
-}
-
-export interface ResolveIOAIManagerRecoveryGateDecision {
-	action: ResolveIOAIManagerRecoveryGateAction;
-	reason: string;
-	canRunProductRepair: boolean;
-	canRunExpensiveModel: boolean;
-	shouldResetLoopBudget: boolean;
-	shouldIncrementAttempt: boolean;
-	newEvidence: boolean;
-	materialEvidence: boolean;
-	evidenceStrength: ResolveIOAIManagerEvidenceStrength;
-	evidenceSignals: string[];
-	blockerFingerprint: string;
-	evidenceHash: string;
-	missingEvidence: string[];
-	checkpoint: ResolveIOAIManagerRecoveryCheckpoint;
-}
-
-export interface ResolveIOAIManagerRecoveryEvidenceProbeInput {
-	checkpoint: ResolveIOAIManagerRecoveryCheckpoint;
-	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;
-	failureClass?: string;
-	lane?: string;
-	stepType?: string;
-	blocker?: string;
-	sameFailureCount?: number;
-	pingPongCount?: number;
-	newEvidence?: boolean;
-	productRepairFailure?: boolean;
-	changedFiles?: string[];
-	artifactPaths?: string[];
-	maxSameFailureRepeats?: number;
-}
-
-export interface ResolveIOAIManagerPolicyInput {
-	history?: ResolveIOAIManagerFailureRecord[];
-	current?: ResolveIOAIManagerFailureRecord;
-	maxSameFailureRepeats?: number;
-	maxPingPongTransitions?: number;
-	infraFailureClasses?: string[];
-	ignoredFailureClasses?: string[];
-}
-
-export interface ResolveIOAIManagerPolicyDecision {
-	action: ResolveIOAIManagerAction;
-	reason: string;
-	failureClass: string;
-	blockerFingerprint: string;
-	evidenceHash: string;
-	sameFailureCount: number;
-	pingPongCount: number;
-	newEvidence: boolean;
-	materialEvidence: boolean;
-	evidenceStrength: ResolveIOAIManagerEvidenceStrength;
-	evidenceSignals: string[];
-	loopBudgetShouldReset: boolean;
-	productRepairFailure: boolean;
-	recoveryPlan: ResolveIOAIManagerRecoveryPlan;
-	recoveryCheckpoint: ResolveIOAIManagerRecoveryCheckpoint;
-	recoveryEvidenceProbe: ResolveIOAIManagerRecoveryEvidenceProbe;
-	recoveryAction: ResolveIOAIManagerRecoveryActionPacket;
-}
-
-export interface ResolveIOAIManagerRecoveryReplayMatrixInput {
-	surface?: string;
-	includeJourneyContractRepair?: boolean;
-	includeReleaseRepair?: boolean;
-	includeProductRepair?: boolean;
-	maxSameFailureRepeats?: number;
-}
-
-export interface ResolveIOAIManagerRecoveryReplayCase {
-	caseId: string;
-	surface: string;
-	pass: boolean;
-	action: string;
-	reason: string;
-	recoveryClass: string;
-	dispatchAction: string;
-	safeAutoDispatch: boolean;
-	expectedSafeAutoDispatch: boolean;
-	productRepairAllowed: boolean;
-	loopBudgetShouldReset: boolean;
-	materialEvidence: boolean;
-	evidenceStrength: ResolveIOAIManagerEvidenceStrength;
-	hotfixFirst?: boolean;
-	fullDeployAllowed?: boolean;
-	details?: Record<string, any>;
-}
-
-function cleanText(value: any, max = 2000): string {
-	return String(value || '').replace(/\s+/g, ' ').trim().slice(0, max);
-}
-
-function cleanList(values: any, limit = 40, max = 500): string[] {
-	if (!Array.isArray(values)) {
-		return [];
-	}
-	const result: string[] = [];
-	for (const value of values) {
-		const normalized = cleanText(value, max);
-		if (normalized && !result.includes(normalized)) {
-			result.push(normalized);
-		}
-		if (result.length >= limit) {
-			break;
-		}
-	}
-	return result;
-}
-
-const HOTFIX_CHANNELS = new Set<ResolveIOAIManagerHotfixChannel>([
-	'static_ui',
-	'backend_js',
-	'config',
-	'seed_data',
-	'cache_invalidation',
-	'service_restart',
-	'release_artifact',
-	'force_deploy_review',
-	'new_artifact_deploy',
-	'artifact_build'
-]);
-
-function cleanObject(value: any): Record<string, any> {
-	return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-}
-
-function normalizeAutonomyMode(value: any): ResolveIOAIManagerAutonomyMode {
-	const normalized = cleanText(value, 120).toLowerCase().replace(/[\s-]+/g, '_');
-	if (/^(monitor|monitor_only|watch|watch_only)$/.test(normalized)) {
-		return 'monitor_only';
-	}
-	if (/^(auto|auto_retry|auto_retry_within_budget|autonomous|within_budget)$/.test(normalized)) {
-		return 'auto_retry_within_budget';
-	}
-	return 'manual_only';
-}
-
-function normalizeManagerEvidenceStrength(value: any): ResolveIOAIManagerEvidenceStrength {
-	const normalized = cleanText(value, 40).toLowerCase().replace(/[\s-]+/g, '_');
-	if (normalized === 'proof') {
-		return 'proof';
-	}
-	if (normalized === 'material' || normalized === 'strong') {
-		return 'material';
-	}
-	if (normalized === 'weak') {
-		return 'weak';
-	}
-	return 'none';
-}
-
-function nonNegativeMoney(value: any): number {
-	const parsed = Number(value);
-	return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
-}
-
-function finiteNumber(value: any): number | undefined {
-	const parsed = Number(value);
-	return Number.isFinite(parsed) ? parsed : undefined;
-}
-
-function clampNumber(value: number, min: number, max: number): number {
-	return Math.min(max, Math.max(min, value));
-}
-
-function isCheapEvidenceAutonomyAction(value: any): boolean {
-	const action = cleanText(value, 120);
-	return !action || /^(run_evidence_probe|run_read_only_diagnosis|advance|continue_gate|park_manual)$/.test(action);
-}
-
-export function estimateResolveIOAIManagerRetryExpectedValue(
-	input: ResolveIOAIManagerRetryExpectedValueInput = {}
-): ResolveIOAIManagerRetryExpectedValueEstimate {
-	const dispatchAction = cleanText(input.dispatchAction, 120);
-	const failureClass = normalizeResolveIOAIManagerFailureClass(input.failureClass);
-	const recoveryClass = cleanText(input.recoveryClass, 120);
-	const evidenceStrength = normalizeManagerEvidenceStrength(input.evidenceStrength);
-	const evidenceSignals = cleanList(input.evidenceSignals, 12, 120);
-	const projectedActionCostUsd = nonNegativeMoney(input.projectedActionCostUsd);
-	const budgetHardUsd = nonNegativeMoney(input.budgetHardUsd);
-	const materialEvidence = input.materialEvidence === true || evidenceStrength === 'material' || evidenceStrength === 'proof';
-	const newEvidence = input.newEvidence === true;
-	const signals: string[] = [];
-	let score = 0.1;
-	if (dispatchAction === 'run_evidence_probe') {
-		score = 0.75;
-		signals.push('cheap_evidence_probe');
-	}
-	else if (dispatchAction === 'run_read_only_diagnosis') {
-		score = 0.65;
-		signals.push('read_only_diagnosis');
-	}
-	else if (dispatchAction === 'advance' || dispatchAction === 'continue_gate') {
-		score = 0.55;
-		signals.push('gate_continuation');
-	}
-	else if (dispatchAction === 'run_infra_repair') {
-		score = 0.4;
-		signals.push('bounded_infra_repair');
-	}
-	else if (dispatchAction === 'run_compile_repair') {
-		score = 0.4;
-		signals.push('bounded_compile_repair');
-	}
-	else if (dispatchAction === 'run_release_repair') {
-		score = 0.3;
-		signals.push('bounded_release_repair');
-	}
-	else if (dispatchAction === 'run_journey_contract_repair' || dispatchAction === 'run_business_assertion_repair') {
-		score = 0.25;
-		signals.push('bounded_workflow_or_proof_repair');
-	}
-	else if (dispatchAction === 'run_targeted_product_repair') {
-		score = 0.15;
-		signals.push('targeted_product_repair');
-	}
-	if (evidenceStrength === 'proof') {
-		score += 0.3;
-		signals.push('proof_evidence');
-	}
-	else if (materialEvidence) {
-		score += 0.2;
-		signals.push('material_evidence');
-	}
-	else if (newEvidence) {
-		score += 0.1;
-		signals.push('new_evidence');
-	}
-	else if (evidenceStrength === 'weak') {
-		score -= 0.15;
-		signals.push('weak_evidence');
-	}
-	else if (!isCheapEvidenceAutonomyAction(dispatchAction)) {
-		score -= 0.25;
-		signals.push('no_material_evidence');
-	}
-	if ((failureClass === 'infra' || /infra/i.test(recoveryClass)) && dispatchAction === 'run_infra_repair') {
-		score += 0.15;
-		signals.push('failure_matches_infra_repair');
-	}
-	if ((failureClass === 'compile' || /compile/i.test(recoveryClass)) && dispatchAction === 'run_compile_repair') {
-		score += 0.15;
-		signals.push('failure_matches_compile_repair');
-	}
-	if (/release|publish|deploy/i.test(`${failureClass} ${recoveryClass}`) && dispatchAction === 'run_release_repair') {
-		score += 0.1;
-		signals.push('failure_matches_release_repair');
-	}
-	if (projectedActionCostUsd >= 5) {
-		score -= 0.3;
-		signals.push('high_projected_cost');
-	}
-	else if (projectedActionCostUsd >= 2) {
-		score -= 0.18;
-		signals.push('medium_projected_cost');
-	}
-	else if (projectedActionCostUsd >= 1) {
-		score -= 0.08;
-		signals.push('low_projected_cost');
-	}
-	if (budgetHardUsd > 0 && projectedActionCostUsd > budgetHardUsd * 0.5) {
-		score -= 0.2;
-		signals.push('large_fraction_of_remaining_budget');
-	}
-	if (input.sameEvidenceAlreadyAttempted === true) {
-		score -= 0.35;
-		signals.push('same_evidence_already_attempted');
-	}
-	for (const signal of evidenceSignals) {
-		if (/passing_outcome|business|proof|diagnosis|compile|infra|release|artifact|fingerprint_changed|evidence_hash_changed/i.test(signal)) {
-			score += 0.03;
-			signals.push(`evidence_signal:${signal}`);
-		}
-	}
-	const rounded = Number(clampNumber(score, -1, 1).toFixed(2));
-	const minScore = 0;
-	return {
-		score: rounded,
-		minScore,
-		positive: rounded >= minScore,
-		source: 'estimated',
-		confidence: evidenceStrength === 'proof' || materialEvidence ? 'medium' : 'low',
-		reason: rounded >= minScore
-			? 'estimated_retry_value_is_non_negative'
-			: 'estimated_retry_value_is_negative',
-		signals: Array.from(new Set(signals)).slice(0, 16)
-	};
-}
-
-export function decideResolveIOAIManagerAutonomyPolicy(
-	input: ResolveIOAIManagerAutonomyPolicyInput = {}
-): ResolveIOAIManagerAutonomyPolicyDecision {
-	const mode = normalizeAutonomyMode(input.mode);
-	const currentSpendUsd = nonNegativeMoney(input.currentSpendUsd);
-	const projectedActionCostUsd = nonNegativeMoney(input.projectedActionCostUsd);
-	const projectedSpendUsd = currentSpendUsd + projectedActionCostUsd;
-	const budgetSoftUsd = nonNegativeMoney(input.budgetSoftUsd);
-	const budgetHardUsd = nonNegativeMoney(input.budgetHardUsd);
-	const softBudgetExceeded = budgetSoftUsd > 0 && projectedSpendUsd >= budgetSoftUsd;
-	const hardBudgetExceeded = budgetHardUsd > 0 && projectedSpendUsd > budgetHardUsd;
-	const dispatchAction = cleanText(input.dispatchAction, 120);
-	const evidenceStrength = normalizeManagerEvidenceStrength(input.evidenceStrength);
-	const evidenceSignals = cleanList(input.evidenceSignals, 12, 120);
-	const materialEvidence = input.materialEvidence === true || evidenceStrength === 'material' || evidenceStrength === 'proof';
-	const newEvidence = input.newEvidence === true;
-	const evidenceBacked = materialEvidence || newEvidence || evidenceSignals.some((signal) => /material|proof|business|compile|infra|release|diagnosis|journey|workflow|artifact|hash_changed|fingerprint_changed/i.test(signal));
-	const cheapEvidenceAction = isCheapEvidenceAutonomyAction(dispatchAction);
-	const expectedValueEstimate = estimateResolveIOAIManagerRetryExpectedValue({
-		dispatchAction,
-		projectedActionCostUsd,
-		currentSpendUsd,
-		budgetHardUsd,
-		evidenceStrength,
-		materialEvidence,
-		newEvidence,
-		evidenceSignals,
-		sameEvidenceAlreadyAttempted: input.sameEvidenceAlreadyAttempted === true
-	});
-	const providedExpectedValue = finiteNumber(input.expectedValueScore);
-	const expectedValueKnown = providedExpectedValue !== undefined;
-	const expectedValueScore = expectedValueKnown ? providedExpectedValue as number : expectedValueEstimate.score;
-	const minExpectedValue = finiteNumber(input.minExpectedValueScore) ?? expectedValueEstimate.minScore;
-	const expectedValuePositive = expectedValueScore >= minExpectedValue;
-	const expectedValueSource: ResolveIOAIManagerAutonomyPolicyDecision['expectedValueSource'] = expectedValueKnown ? 'provided' : 'estimated';
-	const requiredEvidence = [
-		'mode',
-		'projectedActionCostUsd',
-		...(budgetHardUsd > 0 ? ['budgetHardUsd'] : []),
-		...(budgetSoftUsd > 0 ? ['budgetSoftUsd'] : []),
-		...(dispatchAction ? ['dispatchAction'] : []),
-		...(cheapEvidenceAction ? [] : ['materialEvidence or newEvidence', 'expectedValueScore when available'])
-	];
-	const forbiddenActions: string[] = [];
-	let canAutoDispatch = false;
-	let canManualDispatch = true;
-	let blocked = false;
-	let requiresHumanApproval = true;
-	let reason = '';
-	let recommendedControl: ResolveIOAIManagerAutonomyPolicyDecision['recommendedControl'] = mode;
-	if (mode === 'monitor_only') {
-		canManualDispatch = false;
-		reason = 'monitor_only_blocks_runner_dispatch';
-		forbiddenActions.push('Do not run recovery, repair, QA, publish, deploy, or customer reply actions while in Monitor Only mode.');
-	}
-	else if (mode === 'manual_only') {
-		reason = 'manual_only_requires_operator_dispatch';
-		forbiddenActions.push('Do not auto-dispatch manager recovery actions in Manual Only mode.');
-	}
-	else if (hardBudgetExceeded) {
-		blocked = true;
-		canAutoDispatch = false;
-		canManualDispatch = input.operatorApproved === true;
-		reason = 'auto_retry_budget_hard_cap_would_be_exceeded';
-		recommendedControl = 'increase_budget_or_manual';
-		forbiddenActions.push('Do not auto-dispatch because projected spend exceeds the hard budget.');
-	}
-	else if (!cheapEvidenceAction && !evidenceBacked) {
-		canAutoDispatch = false;
-		requiresHumanApproval = true;
-		reason = 'auto_retry_requires_material_evidence';
-		forbiddenActions.push('Do not auto-dispatch repair work until a deterministic artifact, changed blocker fingerprint, or material proof is recorded.');
-	}
-	else if (!cheapEvidenceAction && !expectedValuePositive) {
-		canAutoDispatch = false;
-		requiresHumanApproval = true;
-		reason = 'auto_retry_expected_value_not_positive';
-		forbiddenActions.push('Do not auto-dispatch repair work when the expected value score is below the configured minimum.');
-	}
-	else {
-		canAutoDispatch = true;
-		requiresHumanApproval = softBudgetExceeded;
-		reason = softBudgetExceeded
-			? 'auto_retry_soft_budget_warning_requires_review'
-			: 'auto_retry_within_budget_allows_auto_dispatch';
-		if (softBudgetExceeded) {
-			forbiddenActions.push('Do not escalate to a more expensive model or broader repair without operator review after soft budget warning.');
-		}
-	}
-	return {
-		mode,
-		canAutoDispatch,
-		canManualDispatch,
-		blocked,
-		requiresHumanApproval,
-		reason,
-		currentSpendUsd,
-		projectedActionCostUsd,
-		projectedSpendUsd,
-		budgetSoftUsd,
-		budgetHardUsd,
-		softBudgetExceeded,
-		hardBudgetExceeded,
-		dispatchAction,
-		expectedValueScore,
-		minExpectedValueScore: minExpectedValue,
-		expectedValueKnown,
-		expectedValueSource,
-		expectedValuePositive,
-		evidenceStrength,
-		materialEvidence,
-		newEvidence,
-		evidenceBacked,
-		evidenceSignals,
-		recommendedControl,
-		forbiddenActions,
-		requiredEvidence
-	};
-}
-
-function cleanDateString(value: any): string {
-	const date = value instanceof Date ? value : new Date(value || Date.now());
-	return Number.isNaN(date.getTime()) ? new Date().toISOString() : date.toISOString();
-}
-
-function normalizeHotfixChannel(value: any): ResolveIOAIManagerHotfixChannel | '' {
-	const normalized = cleanText(value, 120).toLowerCase().replace(/[\s-]+/g, '_') as ResolveIOAIManagerHotfixChannel;
-	return HOTFIX_CHANNELS.has(normalized) ? normalized : '';
-}
-
-function normalizeHotfixStatus(value: any): ResolveIOAIManagerHotfixEvidenceStatus {
-	const normalized = cleanText(value, 120).toLowerCase().replace(/[\s-]+/g, '_');
-	if (/^(pass|passed|success|succeeded|complete|completed|accepted)$/.test(normalized)) {
-		return 'passed';
-	}
-	if (/^(block|blocked|failed|fail|error|denied)$/.test(normalized)) {
-		return 'blocked';
-	}
-	if (/^(missing|none)$/.test(normalized)) {
-		return 'missing';
-	}
-	return 'incomplete';
-}
-
-function hotfixStatusPassed(value: any): boolean {
-	return normalizeHotfixStatus(value) === 'passed';
-}
-
-function normalizeHotfixEvidenceTarget(value: any): ResolveIOAIManagerHotfixEvidenceTarget {
-	const source = cleanObject(value);
-	return {
-		surface: cleanText(source.surface, 160),
-		host: cleanText(source.host || source.hostname || source.domain, 240),
-		path: cleanText(source.path || source.remotePath || source.remote_path, 500),
-		artifactPath: cleanText(source.artifactPath || source.artifact_path || source.localPath || source.local_path, 500),
-		bucket: cleanText(source.bucket || source.s3Bucket || source.s3_bucket, 240),
-		distributionId: cleanText(source.distributionId || source.distribution_id || source.cloudfrontDistributionId || source.cloudfront_distribution_id, 240),
-		processName: cleanText(source.processName || source.process_name || source.service || source.serviceName, 160),
-		configKey: cleanText(source.configKey || source.config_key || source.key, 240),
-		cacheKey: cleanText(source.cacheKey || source.cache_key, 240),
-		seedKey: cleanText(source.seedKey || source.seed_key || source.fixture, 240)
-	};
-}
-
-export function normalizeResolveIOAIManagerHotfixEvidence(
-	value: any,
-	policy?: ResolveIOAIManagerHotfixFirstReleasePolicy
-): ResolveIOAIManagerHotfixEvidence | undefined {
-	const source = cleanObject(value);
-	if (!Object.keys(source).length) {
-		return undefined;
-	}
-	const channel = normalizeHotfixChannel(source.channel || source.hotfixChannel || source.hotfix_channel || policy?.hotfixPlan?.recommendedChannel);
-	if (!channel) {
-		return undefined;
-	}
-	const target = normalizeHotfixEvidenceTarget(source.target || source);
-	return {
-		channel,
-		status: normalizeHotfixStatus(source.status),
-		target,
-		compiledArtifactPath: cleanText(source.compiledArtifactPath || source.compiled_artifact_path || target.artifactPath, 500),
-		builtDistPath: cleanText(source.builtDistPath || source.built_dist_path || target.artifactPath, 500),
-		remoteChecksumBefore: cleanText(source.remoteChecksumBefore || source.remote_checksum_before || source.checksumBefore || source.checksum_before, 160),
-		remoteChecksumAfter: cleanText(source.remoteChecksumAfter || source.remote_checksum_after || source.checksumAfter || source.checksum_after, 160),
-		remoteChecksum: cleanText(source.remoteChecksum || source.remote_checksum || source.checksum, 160),
-		restartEvidence: cleanText(source.restartEvidence || source.restart_evidence, 1000),
-		healthCheckStatus: cleanText(source.healthCheckStatus || source.health_check_status || source.health, 160),
-		selfTestStatus: cleanText(source.selfTestStatus || source.self_test_status || source.selfTest || source.self_test, 160),
-		releaseGateStatus: cleanText(source.releaseGateStatus || source.release_gate_status || source.releaseGate || source.release_gate, 160),
-		s3UploadResult: cleanText(source.s3UploadResult || source.s3_upload_result || source.uploadResult || source.upload_result, 1000),
-		cloudfrontInvalidationId: cleanText(source.cloudfrontInvalidationId || source.cloudfront_invalidation_id || source.invalidationId || source.invalidation_id, 240),
-		publicProof: cleanText(source.publicProof || source.public_proof || source.publicUrl || source.public_url, 1000),
-		configChangeEvidence: cleanText(source.configChangeEvidence || source.config_change_evidence, 1000),
-		seedDataEvidence: cleanText(source.seedDataEvidence || source.seed_data_evidence, 1000),
-		cacheInvalidationEvidence: cleanText(source.cacheInvalidationEvidence || source.cache_invalidation_evidence, 1000),
-		serviceRestartEvidence: cleanText(source.serviceRestartEvidence || source.service_restart_evidence, 1000),
-		releaseArtifactFingerprint: cleanText(source.releaseArtifactFingerprint || source.release_artifact_fingerprint || source.artifactFingerprint || source.artifact_fingerprint, 240),
-		lastReleaseArtifactFingerprint: cleanText(source.lastReleaseArtifactFingerprint || source.last_release_artifact_fingerprint || source.lastArtifactFingerprint || source.last_artifact_fingerprint, 240),
-		sourceCommitSha: cleanText(source.sourceCommitSha || source.source_commit_sha || source.gitCommitSha || source.git_commit_sha || source.commitSha || source.commit_sha, 120),
-		githubCommitUrl: cleanText(source.githubCommitUrl || source.github_commit_url || source.gitCommitUrl || source.git_commit_url || source.commitUrl || source.commit_url, 500),
-		gitCommitStatus: cleanText(source.gitCommitStatus || source.git_commit_status || source.githubCommitStatus || source.github_commit_status, 160),
-		gitPushStatus: cleanText(source.gitPushStatus || source.git_push_status || source.githubPushStatus || source.github_push_status || source.githubCommitReachableStatus || source.github_commit_reachable_status, 160),
-		committedAt: source.committedAt || source.committed_at,
-		forceDeployReason: cleanText(source.forceDeployReason || source.force_deploy_reason, 1000),
-		hotfixCannotResolveReason: cleanText(source.hotfixCannotResolveReason || source.hotfix_cannot_resolve_reason, 1000),
-		fullDeployRequested: source.fullDeployRequested === true || source.full_deploy_requested === true,
-		recordedAt: source.recordedAt || source.recorded_at
-	};
-}
-
-function matchingHotfixPlanStep(
-	policy: ResolveIOAIManagerHotfixFirstReleasePolicy | undefined,
-	channel: ResolveIOAIManagerHotfixChannel | ''
-): ResolveIOAIManagerHotfixPlanStep | undefined {
-	return (policy?.hotfixPlan?.steps || []).find((step) => step.channel === channel);
-}
-
-function pushMissing(blockers: string[], condition: boolean, message: string): void {
-	if (!condition) {
-		blockers.push(message);
-	}
-}
-
-function hotfixRequiresGithubCommit(channel: ResolveIOAIManagerHotfixChannel | ''): boolean {
-	return /^(backend_js|static_ui|config|seed_data|release_artifact|new_artifact_deploy|artifact_build)$/.test(channel);
-}
-
-function extractGithubCommitSha(value: string): string {
-	const match = cleanText(value, 500).match(/^https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/commit\/([a-f0-9]{40})(?:$|[?#/])/i);
-	return match?.[1]?.toLowerCase() || '';
-}
-
-function isFullGitCommitSha(value: string): boolean {
-	return /^[a-f0-9]{40}$/i.test(cleanText(value, 120));
-}
-
-function isStrongRemoteChecksum(value: string): boolean {
-	return /^[a-f0-9]{12,128}$/i.test(cleanText(value, 160));
-}
-
-function githubCommitProofBlockers(value: ResolveIOAIManagerHotfixEvidence, channel: ResolveIOAIManagerHotfixChannel | ''): string[] {
-	const blockers: string[] = [];
-	const sourceCommitSha = cleanText(value.sourceCommitSha, 120);
-	const githubCommitUrl = cleanText(value.githubCommitUrl, 500);
-	const gitCommitStatus = cleanText(value.gitCommitStatus, 160);
-	const gitPushStatus = cleanText(value.gitPushStatus, 160);
-	const urlCommitSha = extractGithubCommitSha(githubCommitUrl);
-	if (!sourceCommitSha || !githubCommitUrl) {
-		blockers.push(`${channel} hotfix requires sourceCommitSha, githubCommitUrl, and passed gitPushStatus so live hotfixes are backed by a GitHub commit pushed before continuation.`);
-		return blockers;
-	}
-	if (!isFullGitCommitSha(sourceCommitSha)) {
-		blockers.push(`${channel} hotfix sourceCommitSha must be a full 40-character git SHA.`);
-	}
-	if (!urlCommitSha) {
-		blockers.push(`${channel} hotfix githubCommitUrl must be a GitHub commit URL ending in a full 40-character git SHA.`);
-	}
-	else if (isFullGitCommitSha(sourceCommitSha) && urlCommitSha !== sourceCommitSha.toLowerCase()) {
-		blockers.push(`${channel} hotfix githubCommitUrl commit SHA must match sourceCommitSha.`);
-	}
-	if (!gitPushStatus) {
-		blockers.push(`${channel} hotfix requires passed gitPushStatus so the manager knows the hotfix commit is present on GitHub before continuation.`);
-	}
-	else if (!hotfixStatusPassed(gitPushStatus)) {
-		blockers.push(`${channel} hotfix gitPushStatus must be passed before continuation.`);
-	}
-	if (gitCommitStatus && !hotfixStatusPassed(gitCommitStatus)) {
-		blockers.push(`${channel} hotfix gitCommitStatus must be passed when provided.`);
-	}
-	return blockers;
-}
-
-export function evaluateResolveIOAIManagerHotfixGitProof(
-	value: any,
-	channelHint: ResolveIOAIManagerHotfixChannel | '' = ''
-): ResolveIOAIManagerHotfixGitProof {
-	const normalized = normalizeResolveIOAIManagerHotfixEvidence(value);
-	const source = (normalized || cleanObject(value)) as Record<string, any>;
-	const channel = (channelHint || normalized?.channel || source.channel || '') as ResolveIOAIManagerHotfixChannel | '';
-	const required = hotfixRequiresGithubCommit(channel);
-	const sourceCommitSha = cleanText(source.sourceCommitSha || source.source_commit_sha || source.gitCommitSha || source.git_commit_sha || source.commitSha || source.commit_sha, 120);
-	const githubCommitUrl = cleanText(source.githubCommitUrl || source.github_commit_url || source.gitCommitUrl || source.git_commit_url || source.commitUrl || source.commit_url, 500);
-	const githubCommitSha = extractGithubCommitSha(githubCommitUrl);
-	const gitCommitStatus = cleanText(source.gitCommitStatus || source.git_commit_status || source.githubCommitStatus || source.github_commit_status, 160);
-	const gitPushStatus = cleanText(source.gitPushStatus || source.git_push_status || source.githubPushStatus || source.github_push_status || source.githubCommitReachableStatus || source.github_commit_reachable_status, 160);
-	const blockers = required
-		? githubCommitProofBlockers({
-			channel: channel as ResolveIOAIManagerHotfixChannel,
-			target: normalized?.target || {},
-			sourceCommitSha,
-			githubCommitUrl,
-			gitCommitStatus,
-			gitPushStatus
-		}, channel)
-		: [];
-	const status: ResolveIOAIManagerHotfixGitProofStatus = !required
-		? 'not_required'
-		: (!sourceCommitSha || !githubCommitUrl || !gitPushStatus)
-			? 'missing'
-			: blockers.length
-				? 'invalid'
-				: 'passed';
-	const passed = !required || status === 'passed';
-	return {
-		required,
-		status,
-		passed,
-		managerMustCommitBeforeHotfix: required && !passed,
-		channel,
-		sourceCommitSha,
-		githubCommitUrl,
-		githubCommitSha,
-		gitCommitStatus,
-		gitPushStatus,
-		blockers,
-		nextCommands: required && !passed
-			? ['commit_and_push_hotfix_to_github', 'verify_github_commit_url_and_push_status', 'record_hotfix_evidence']
-			: [],
-		requiredEvidence: required
-			? ['full 40-character sourceCommitSha', 'matching GitHub commit URL', 'passed gitPushStatus']
-			: []
-	};
-}
-
-export function validateResolveIOAIManagerHotfixEvidence(
-	value: any,
-	options: { policy?: ResolveIOAIManagerHotfixFirstReleasePolicy } = {}
-): ResolveIOAIManagerHotfixEvidenceValidation {
-	const normalized = normalizeResolveIOAIManagerHotfixEvidence(value, options.policy);
-	const policy = options.policy;
-	if (!normalized) {
-		return {
-			valid: false,
-			status: 'missing',
-			channel: '',
-			blockers: ['Hotfix evidence is missing or channel is unsupported.'],
-			warnings: [],
-			fullDeployAllowed: false,
-			fullDeployBlocked: true,
-			hotfixSatisfied: false,
-			requiredEvidence: policy?.hotfixPlan?.steps?.flatMap((step) => step.requiredEvidence) || [],
-			successEvidence: policy?.hotfixPlan?.steps?.flatMap((step) => step.successEvidence) || [],
-			githubCommitGuard: evaluateResolveIOAIManagerHotfixGitProof(value),
-			policy,
-			nextAction: 'record_hotfix_evidence'
-		};
-	}
-	const blockers: string[] = [];
-	const warnings: string[] = [];
-	const target = normalized.target || {};
-	const channel = normalized.channel;
-	const step = matchingHotfixPlanStep(policy, channel);
-	const requiredEvidence = step?.requiredEvidence || [];
-	const successEvidence = step?.successEvidence || [];
-	const policyAllowsFullDeploy = policy?.fullDeployAllowed === true;
-	const policyBlocksDuplicate = policy?.duplicateDeployBlocked === true || policy?.duplicatePublishBlocked === true;
-	const githubCommitGuard = evaluateResolveIOAIManagerHotfixGitProof(normalized, channel);
-	if (normalized.fullDeployRequested && !policyAllowsFullDeploy && channel !== 'force_deploy_review' && channel !== 'new_artifact_deploy') {
-		blockers.push('Full deploy requested but hotfix-first policy does not allow a full deploy for this release state.');
-	}
-	if (normalized.fullDeployRequested && policyBlocksDuplicate && !normalized.forceDeployReason && channel !== 'force_deploy_review') {
-		blockers.push('Duplicate deploy/publish fingerprint requires force deploy/publish evidence before any full deploy.');
-	}
-	if (githubCommitGuard.required) {
-		blockers.push(...githubCommitGuard.blockers);
-	}
-	if (channel === 'backend_js') {
-		pushMissing(blockers, !!normalized.compiledArtifactPath, 'Backend JS hotfix requires compiledArtifactPath.');
-		pushMissing(blockers, !!target.host, 'Backend JS hotfix requires target.host.');
-		pushMissing(blockers, !!target.path, 'Backend JS hotfix requires target.path.');
-		pushMissing(blockers, !!(normalized.remoteChecksumAfter || normalized.remoteChecksum), 'Backend JS hotfix requires remote checksum after replacement.');
-		if ((normalized.remoteChecksumAfter || normalized.remoteChecksum) && !isStrongRemoteChecksum(normalized.remoteChecksumAfter || normalized.remoteChecksum || '')) {
-			blockers.push('Backend JS hotfix remote checksum after replacement must be a strong hex checksum, not a label or placeholder.');
-		}
-		pushMissing(blockers, !!(normalized.restartEvidence || normalized.serviceRestartEvidence), 'Backend JS hotfix requires restart evidence.');
-		pushMissing(blockers, hotfixStatusPassed(normalized.healthCheckStatus), 'Backend JS hotfix requires passed healthCheckStatus.');
-		pushMissing(blockers, hotfixStatusPassed(normalized.selfTestStatus), 'Backend JS hotfix requires passed selfTestStatus.');
-		if (normalized.remoteChecksumBefore && normalized.remoteChecksumAfter && normalized.remoteChecksumBefore === normalized.remoteChecksumAfter) {
-			blockers.push('Backend JS hotfix checksum did not change; record force/no-op evidence or do not claim a hotfix.');
-		}
-	}
-	else if (channel === 'static_ui') {
-		pushMissing(blockers, !!normalized.builtDistPath, 'Static UI hotfix requires builtDistPath.');
-		pushMissing(blockers, !!target.bucket, 'Static UI hotfix requires target.bucket.');
-		pushMissing(blockers, !!target.distributionId, 'Static UI hotfix requires target.distributionId.');
-		pushMissing(blockers, !!normalized.s3UploadResult, 'Static UI hotfix requires s3UploadResult.');
-		pushMissing(blockers, !!normalized.cloudfrontInvalidationId, 'Static UI hotfix requires cloudfrontInvalidationId.');
-		pushMissing(blockers, !!normalized.publicProof, 'Static UI hotfix requires publicProof.');
-	}
-	else if (channel === 'config') {
-		pushMissing(blockers, !!target.configKey, 'Config hotfix requires target.configKey.');
-		pushMissing(blockers, !!normalized.configChangeEvidence, 'Config hotfix requires configChangeEvidence.');
-		pushMissing(blockers, hotfixStatusPassed(normalized.releaseGateStatus), 'Config hotfix requires passed releaseGateStatus.');
-	}
-	else if (channel === 'seed_data') {
-		pushMissing(blockers, !!target.seedKey, 'Seed-data hotfix requires target.seedKey.');
-		pushMissing(blockers, !!normalized.seedDataEvidence, 'Seed-data hotfix requires seedDataEvidence.');
-		pushMissing(blockers, hotfixStatusPassed(normalized.releaseGateStatus), 'Seed-data hotfix requires passed releaseGateStatus.');
-	}
-	else if (channel === 'cache_invalidation') {
-		pushMissing(blockers, !!target.cacheKey, 'Cache invalidation hotfix requires target.cacheKey.');
-		pushMissing(blockers, !!normalized.cacheInvalidationEvidence, 'Cache invalidation hotfix requires cacheInvalidationEvidence.');
-		pushMissing(blockers, hotfixStatusPassed(normalized.releaseGateStatus) || hotfixStatusPassed(normalized.healthCheckStatus), 'Cache invalidation hotfix requires passed releaseGateStatus or healthCheckStatus.');
-	}
-	else if (channel === 'service_restart') {
-		pushMissing(blockers, !!target.processName, 'Service restart hotfix requires target.processName.');
-		pushMissing(blockers, !!(normalized.serviceRestartEvidence || normalized.restartEvidence), 'Service restart hotfix requires restart evidence.');
-		pushMissing(blockers, hotfixStatusPassed(normalized.healthCheckStatus), 'Service restart hotfix requires passed healthCheckStatus.');
-		pushMissing(blockers, hotfixStatusPassed(normalized.selfTestStatus), 'Service restart hotfix requires passed selfTestStatus.');
-	}
-	else if (channel === 'release_artifact') {
-		pushMissing(blockers, !!normalized.releaseArtifactFingerprint, 'Release artifact hotfix requires releaseArtifactFingerprint.');
-		pushMissing(blockers, hotfixStatusPassed(normalized.releaseGateStatus), 'Release artifact hotfix requires passed releaseGateStatus.');
-	}
-	else if (channel === 'force_deploy_review') {
-		pushMissing(blockers, !!normalized.forceDeployReason, 'Force deploy review requires forceDeployReason.');
-		pushMissing(blockers, !!normalized.hotfixCannotResolveReason, 'Force deploy review requires hotfixCannotResolveReason.');
-	}
-	else if (channel === 'new_artifact_deploy') {
-		pushMissing(blockers, !!normalized.releaseArtifactFingerprint, 'New artifact deploy requires releaseArtifactFingerprint.');
-		pushMissing(blockers, !!normalized.lastReleaseArtifactFingerprint, 'New artifact deploy requires lastReleaseArtifactFingerprint.');
-		if (normalized.releaseArtifactFingerprint && normalized.lastReleaseArtifactFingerprint && normalized.releaseArtifactFingerprint === normalized.lastReleaseArtifactFingerprint) {
-			blockers.push('New artifact deploy requires a fingerprint different from the last deployed artifact.');
-		}
-		pushMissing(blockers, hotfixStatusPassed(normalized.releaseGateStatus), 'New artifact deploy requires passed releaseGateStatus.');
-	}
-	else if (channel === 'artifact_build') {
-		pushMissing(blockers, !!normalized.releaseArtifactFingerprint, 'Artifact build requires releaseArtifactFingerprint.');
-		if (normalized.fullDeployRequested) {
-			blockers.push('Artifact build evidence cannot request a full deploy in the same step.');
-		}
-	}
-	if (!step && policy) {
-		warnings.push(`Hotfix channel ${channel} is not the recommended channel in the current release policy.`);
-	}
-	const forceDeployReviewValid = channel === 'force_deploy_review' && blockers.length === 0;
-	const newArtifactDeployValid = channel === 'new_artifact_deploy' && blockers.length === 0;
-	const fullDeployAllowed = forceDeployReviewValid || newArtifactDeployValid || (policyAllowsFullDeploy && blockers.length === 0 && normalized.fullDeployRequested === true);
-	const hotfixSatisfied = blockers.length === 0 && !fullDeployAllowed;
-	const status: ResolveIOAIManagerHotfixEvidenceStatus = blockers.length
-		? (normalizeHotfixStatus(normalized.status) === 'blocked' ? 'blocked' : 'incomplete')
-		: 'passed';
-	const fullDeployBlocked = !fullDeployAllowed && (normalized.fullDeployRequested === true || policy?.fullDeployAllowed !== true);
-	const nextAction: ResolveIOAIManagerHotfixEvidenceValidation['nextAction'] = blockers.some((blocker) => /force deploy/i.test(blocker))
-		? 'request_force_deploy_reason'
-		: fullDeployAllowed
-			? 'allow_one_full_deploy'
-			: hotfixSatisfied
-				? 'rerun_release_gate'
-				: blockers.length
-					? 'record_hotfix_evidence'
-					: 'park_manual';
-	normalized.status = status;
-	return {
-		valid: blockers.length === 0,
-		status,
-		channel,
-		blockers,
-		warnings,
-		fullDeployAllowed,
-		fullDeployBlocked,
-		hotfixSatisfied,
-		requiredEvidence,
-		successEvidence,
-		normalized,
-		githubCommitGuard,
-		policy,
-		nextAction
-	};
-}
-
-function mergeHotfixEvidenceRecordInput(input: ResolveIOAIManagerHotfixEvidenceRecordInput): Record<string, any> {
-	const merged = {
-		...cleanObject(input.evidence)
-	};
-	const directFields = [
-		'channel',
-		'status',
-		'target',
-		'compiledArtifactPath',
-		'builtDistPath',
-		'remoteChecksumBefore',
-		'remoteChecksumAfter',
-		'remoteChecksum',
-		'restartEvidence',
-		'healthCheckStatus',
-		'selfTestStatus',
-		'releaseGateStatus',
-		's3UploadResult',
-		'cloudfrontInvalidationId',
-		'publicProof',
-		'configChangeEvidence',
-		'seedDataEvidence',
-		'cacheInvalidationEvidence',
-		'serviceRestartEvidence',
-		'releaseArtifactFingerprint',
-		'lastReleaseArtifactFingerprint',
-		'sourceCommitSha',
-		'githubCommitUrl',
-		'gitCommitStatus',
-		'gitPushStatus',
-		'committedAt',
-		'forceDeployReason',
-		'hotfixCannotResolveReason',
-		'fullDeployRequested',
-		'recordedAt'
-	];
-	for (const field of directFields) {
-		const value = (input as any)[field];
-		if (value !== undefined && value !== null && value !== '') {
-			(merged as any)[field] = value;
-		}
-	}
-	return merged;
-}
-
-function resolveHotfixEvidenceRequiredFields(
-	channel: ResolveIOAIManagerHotfixChannel | ''
-): string[] {
-	const fields = ['channel'];
-	if (hotfixRequiresGithubCommit(channel)) {
-		fields.push('sourceCommitSha', 'githubCommitUrl', 'gitPushStatus');
-	}
-	if (channel === 'backend_js') {
-		fields.push('compiledArtifactPath', 'target.host', 'target.path', 'remoteChecksumAfter', 'restartEvidence', 'healthCheckStatus', 'selfTestStatus');
-	}
-	else if (channel === 'static_ui') {
-		fields.push('builtDistPath', 'target.bucket', 'target.distributionId', 's3UploadResult', 'cloudfrontInvalidationId', 'publicProof');
-	}
-	else if (channel === 'config') {
-		fields.push('target.configKey', 'configChangeEvidence', 'releaseGateStatus');
-	}
-	else if (channel === 'seed_data') {
-		fields.push('target.seedKey', 'seedDataEvidence', 'releaseGateStatus');
-	}
-	else if (channel === 'cache_invalidation') {
-		fields.push('target.cacheKey', 'cacheInvalidationEvidence', 'releaseGateStatus_or_healthCheckStatus');
-	}
-	else if (channel === 'service_restart') {
-		fields.push('target.processName', 'serviceRestartEvidence', 'healthCheckStatus', 'selfTestStatus');
-	}
-	else if (channel === 'release_artifact') {
-		fields.push('releaseArtifactFingerprint', 'releaseGateStatus');
-	}
-	else if (channel === 'new_artifact_deploy') {
-		fields.push('releaseArtifactFingerprint', 'lastReleaseArtifactFingerprint', 'releaseGateStatus');
-	}
-	else if (channel === 'artifact_build') {
-		fields.push('releaseArtifactFingerprint');
-	}
-	else if (channel === 'force_deploy_review') {
-		fields.push('forceDeployReason', 'hotfixCannotResolveReason');
-	}
-	return Array.from(new Set(fields));
-}
-
-function hotfixEvidenceFieldPresent(
-	evidence: ResolveIOAIManagerHotfixEvidence | undefined,
-	field: string
-): boolean {
-	if (!evidence) {
-		return false;
-	}
-	const target = evidence.target || {};
-	switch (field) {
-		case 'channel':
-			return !!evidence.channel;
-		case 'sourceCommitSha':
-			return isFullGitCommitSha(evidence.sourceCommitSha || '');
-		case 'githubCommitUrl':
-			return !!extractGithubCommitSha(evidence.githubCommitUrl || '');
-		case 'gitPushStatus':
-			return hotfixStatusPassed(evidence.gitPushStatus);
-		case 'compiledArtifactPath':
-			return !!cleanText(evidence.compiledArtifactPath, 500);
-		case 'builtDistPath':
-			return !!cleanText(evidence.builtDistPath, 500);
-		case 'remoteChecksumAfter':
-			return !!cleanText(evidence.remoteChecksumAfter || evidence.remoteChecksum, 160);
-		case 'restartEvidence':
-			return !!cleanText(evidence.restartEvidence || evidence.serviceRestartEvidence, 1000);
-		case 'serviceRestartEvidence':
-			return !!cleanText(evidence.serviceRestartEvidence || evidence.restartEvidence, 1000);
-		case 'healthCheckStatus':
-			return hotfixStatusPassed(evidence.healthCheckStatus);
-		case 'selfTestStatus':
-			return hotfixStatusPassed(evidence.selfTestStatus);
-		case 'releaseGateStatus':
-			return hotfixStatusPassed(evidence.releaseGateStatus);
-		case 'releaseGateStatus_or_healthCheckStatus':
-			return hotfixStatusPassed(evidence.releaseGateStatus) || hotfixStatusPassed(evidence.healthCheckStatus);
-		case 's3UploadResult':
-			return !!cleanText(evidence.s3UploadResult, 1000);
-		case 'cloudfrontInvalidationId':
-			return !!cleanText(evidence.cloudfrontInvalidationId, 240);
-		case 'publicProof':
-			return !!cleanText(evidence.publicProof, 1000);
-		case 'configChangeEvidence':
-			return !!cleanText(evidence.configChangeEvidence, 1000);
-		case 'seedDataEvidence':
-			return !!cleanText(evidence.seedDataEvidence, 1000);
-		case 'cacheInvalidationEvidence':
-			return !!cleanText(evidence.cacheInvalidationEvidence, 1000);
-		case 'releaseArtifactFingerprint':
-			return !!cleanText(evidence.releaseArtifactFingerprint, 240);
-		case 'lastReleaseArtifactFingerprint':
-			return !!cleanText(evidence.lastReleaseArtifactFingerprint, 240);
-		case 'forceDeployReason':
-			return !!cleanText(evidence.forceDeployReason, 1000);
-		case 'hotfixCannotResolveReason':
-			return !!cleanText(evidence.hotfixCannotResolveReason, 1000);
-		case 'target.host':
-			return !!cleanText(target.host, 200);
-		case 'target.path':
-			return !!cleanText(target.path, 500);
-		case 'target.bucket':
-			return !!cleanText(target.bucket, 200);
-		case 'target.distributionId':
-			return !!cleanText(target.distributionId, 200);
-		case 'target.configKey':
-			return !!cleanText(target.configKey, 200);
-		case 'target.seedKey':
-			return !!cleanText(target.seedKey, 200);
-		case 'target.cacheKey':
-			return !!cleanText(target.cacheKey, 200);
-		case 'target.processName':
-			return !!cleanText(target.processName, 200);
-		default:
-			return false;
-	}
-}
-
-export function buildResolveIOAIManagerHotfixEvidenceRecord(
-	input: ResolveIOAIManagerHotfixEvidenceRecordInput = {}
-): ResolveIOAIManagerHotfixEvidenceRecord {
-	const merged = mergeHotfixEvidenceRecordInput(input);
-	const normalized = normalizeResolveIOAIManagerHotfixEvidence(merged, input.policy);
-	const validation = validateResolveIOAIManagerHotfixEvidence(merged, { policy: input.policy });
-	const channel = validation.channel || normalized?.channel || input.policy?.hotfixPlan?.recommendedChannel || '';
-	const requiredFields = resolveHotfixEvidenceRequiredFields(channel);
-	const missingFields = requiredFields.filter((field) => !hotfixEvidenceFieldPresent(normalized, field));
-	const recordedAt = cleanDateString(input.now || normalized?.recordedAt || new Date());
-	const githubCommitGuard = validation.githubCommitGuard || evaluateResolveIOAIManagerHotfixGitProof(normalized || merged, channel);
-	return {
-		recordId: cleanText(input.recordId, 160) || `hotfix-${fingerprintResolveIOAIManagerBlocker(`${channel}:${githubCommitGuard.sourceCommitSha}:${recordedAt}`)}`,
-		recordedAt,
-		recordedBy: cleanText(input.recordedBy || 'manager', 160),
-		source: cleanText(input.source || 'unknown', 80),
-		reason: cleanText(input.reason, 1000),
-		channel,
-		status: validation.status,
-		nextAction: validation.nextAction,
-		valid: validation.valid,
-		hotfixSatisfied: validation.hotfixSatisfied,
-		fullDeployAllowed: validation.fullDeployAllowed,
-		fullDeployBlocked: validation.fullDeployBlocked,
-		requiredFields,
-		missingFields,
-		evidence: normalized,
-		validation,
-		sourceCommitSha: githubCommitGuard.sourceCommitSha,
-		githubCommitUrl: githubCommitGuard.githubCommitUrl,
-		gitPushStatus: githubCommitGuard.gitPushStatus,
-		githubCommitRequired: githubCommitGuard.required,
-		githubCommitProofPassed: githubCommitGuard.passed,
-		commitProofStatus: githubCommitGuard.status,
-		managerMustCommitBeforeHotfix: githubCommitGuard.managerMustCommitBeforeHotfix,
-		githubCommitGuard,
-		readyForReleaseGate: validation.valid === true && validation.nextAction === 'rerun_release_gate',
-		readyForContinuation: validation.valid === true && validation.hotfixSatisfied === true && hotfixStatusPassed(normalized?.releaseGateStatus)
-	};
-}
-
-export function decideResolveIOAIManagerHotfixContinuation(
-	input: ResolveIOAIManagerHotfixContinuationInput = {}
-): ResolveIOAIManagerHotfixContinuationDecision {
-	const validation = validateResolveIOAIManagerHotfixEvidence(input.evidence, { policy: input.policy });
-	const failureClass = cleanText(input.failureClass, 120) || 'release';
-	const blockerText = cleanText(input.blocker || validation.blockers.join('; ') || validation.normalized?.hotfixCannotResolveReason, 1000);
-	const blockerFingerprint = fingerprintResolveIOAIManagerBlocker(blockerText || `${validation.channel}:${validation.status}:${validation.nextAction}`);
-	const baseBlockers = [...validation.blockers];
-	const githubCommitGuard = validation.githubCommitGuard || evaluateResolveIOAIManagerHotfixGitProof(input.evidence, validation.channel);
-	const needsGithubCommitProof = githubCommitGuard.managerMustCommitBeforeHotfix
-		|| validation.blockers.some((blocker) => /sourceCommitSha|githubCommitUrl|gitPushStatus|gitCommitStatus|GitHub commit|pushed/i.test(blocker));
-	const repeatedFailure = input.repeatedFailure === true;
-	const releaseGatePassed = input.releaseGatePassed === true
-		|| hotfixStatusPassed(validation.normalized?.releaseGateStatus);
-	let action: ResolveIOAIManagerHotfixContinuationAction = validation.nextAction;
-	let canContinueRun = false;
-	let canRunFullDeploy = validation.fullDeployAllowed;
-	let shouldRerunReleaseGate = false;
-	let shouldPark = false;
-	let reason = '';
-	const nextCommands: string[] = [];
-
-	if (githubCommitGuard.managerMustCommitBeforeHotfix) {
-		action = 'record_hotfix_evidence';
-		reason = githubCommitGuard.blockers.length
-			? `Manager hotfix cannot continue until the hotfix is committed and pushed: ${githubCommitGuard.blockers.join('; ')}`
-			: 'Manager hotfix cannot continue until sourceCommitSha, githubCommitUrl, and passed gitPushStatus prove the hotfix is on GitHub.';
-		nextCommands.push(...githubCommitGuard.nextCommands, 'rerun_hotfix_evidence_validator');
-		for (const blocker of githubCommitGuard.blockers) {
-			if (!baseBlockers.includes(blocker)) {
-				baseBlockers.push(blocker);
-			}
-		}
-	}
-	else if (!validation.valid || validation.status === 'missing' || validation.status === 'incomplete') {
-		action = validation.nextAction === 'request_force_deploy_reason'
-			? 'request_force_deploy_reason'
-			: 'record_hotfix_evidence';
-		reason = validation.blockers.length
-			? `Hotfix evidence is not complete: ${validation.blockers.join('; ')}`
-			: 'Hotfix evidence is missing; record the hotfix target, checksum, restart, health, and self-test proof before continuing.';
-		if (needsGithubCommitProof) {
-			nextCommands.push('commit_and_push_hotfix_to_github', 'verify_github_commit_url_and_push_status');
-		}
-		nextCommands.push('record_hotfix_evidence', 'rerun_hotfix_evidence_validator');
-	}
-	else if (validation.fullDeployAllowed) {
-		action = 'allow_one_full_deploy';
-		canRunFullDeploy = true;
-		reason = 'Hotfix evidence proves the duplicate release cannot be resolved by a hotfix, or a new artifact was verified, so exactly one full deploy can proceed.';
-		nextCommands.push('run_release_gate_once', 'execute_one_full_deploy_with_force_evidence', 'record_deploy_result');
-	}
-	else if (repeatedFailure) {
-		action = 'park_manual';
-		shouldPark = true;
-		reason = 'The same release failure repeated after valid hotfix evidence; park for manual review instead of looping or redeploying blindly.';
-		nextCommands.push('park_manual_with_hotfix_evidence', 'attach_release_gate_logs');
-	}
-	else if (validation.hotfixSatisfied && releaseGatePassed) {
-		action = 'continue_runner';
-		canContinueRun = true;
-		reason = 'Hotfix evidence and the release gate both passed; continue the current runner without a full deploy.';
-		nextCommands.push('continue_current_runner', 'record_hotfix_continuation');
-	}
-	else if (validation.hotfixSatisfied) {
-		action = 'rerun_release_gate';
-		shouldRerunReleaseGate = true;
-		reason = 'Hotfix evidence passed; rerun the smallest release gate before continuing the runner.';
-		nextCommands.push('rerun_release_gate_once', 'record_release_gate_status');
-	}
-	else {
-		action = 'park_manual';
-		shouldPark = true;
-		reason = 'Hotfix evidence reached an unsupported state; park instead of starting another broad deploy or model loop.';
-		baseBlockers.push('Unsupported hotfix continuation state.');
-		nextCommands.push('park_manual_with_hotfix_evidence');
-	}
-
-	return {
-		action,
-		canContinueRun,
-		canRunFullDeploy,
-		shouldRerunReleaseGate,
-		shouldPark,
-		reason,
-		blockers: baseBlockers,
-			warnings: validation.warnings,
-			requiredEvidence: validation.requiredEvidence,
-			successEvidence: validation.successEvidence,
-			nextCommands: Array.from(new Set(nextCommands)),
-			failureClass,
-			blockerFingerprint,
-			githubCommitGuard,
-			validation,
-			recordedAt: isoNow(input.now)
-		};
-}
-
-export function decideResolveIOAIManagerHotfixCommitGuard(
-	input: ResolveIOAIManagerHotfixContinuationInput = {}
-): ResolveIOAIManagerHotfixCommitGuardDecision {
-	const normalized = normalizeResolveIOAIManagerHotfixEvidence(input.evidence, input.policy);
-	const validation = validateResolveIOAIManagerHotfixEvidence(input.evidence, { policy: input.policy });
-	const githubCommitGuard = validation.githubCommitGuard || evaluateResolveIOAIManagerHotfixGitProof(input.evidence, validation.channel);
-	const active = !!normalized || githubCommitGuard.required === true;
-	const hotfixCommitBlockers = validation.blockers.filter((blocker) => /sourceCommitSha|githubCommitUrl|gitPushStatus|gitCommitStatus|GitHub commit|pushed/i.test(blocker));
-	const blockers = Array.from(new Set([
-		...(githubCommitGuard.blockers || []),
-		...hotfixCommitBlockers
-	]));
-	const blocked = active && (
-		githubCommitGuard.managerMustCommitBeforeHotfix === true
-		|| (githubCommitGuard.required === true && githubCommitGuard.passed !== true)
-		|| hotfixCommitBlockers.length > 0
-	);
-	const nextCommands = blocked
-		? Array.from(new Set([
-			...(githubCommitGuard.nextCommands || []),
-			'commit_and_push_hotfix_to_github',
-			'verify_github_commit_url_and_push_status',
-			'record_hotfix_evidence'
-		]))
-		: [];
-	return {
-		active,
-		blocked,
-		reason: blocked
-			? (blockers.length
-				? `Hotfix continuation is blocked until GitHub commit proof is recorded: ${blockers.join('; ')}`
-				: 'Hotfix continuation is blocked until sourceCommitSha, githubCommitUrl, and passed gitPushStatus prove the hotfix is pushed to GitHub.')
-			: (active ? 'Hotfix GitHub commit proof is recorded.' : 'No hotfix commit guard is active.'),
-		nextAction: blocked ? 'record_hotfix_evidence' : 'continue',
-		channel: validation.channel || githubCommitGuard.channel || '',
-		blockers,
-		nextCommands,
-		requiredEvidence: githubCommitGuard.requiredEvidence,
-		githubCommitGuard,
-		validation
-	};
-}
-
-function releaseStatusIsBlocked(value: string): boolean {
-	return /fail|error|blocked|missing|empty|not ready|not_ready|denied|invalid|timeout|stale/i.test(value);
-}
-
-function releaseStatusIsTerminalDeploy(value: string): boolean {
-	return /requested|queued|in.?progress|completed|complete|success|succeeded|pass|passed|published|deployed|failed|error|blocked/i.test(value);
-}
-
-function buildReleaseAllowedActions(action: ResolveIOAIManagerHotfixFirstReleaseAction): string[] {
-	if (action === 'wait_for_active_deploy') {
-		return ['wait_for_current_deploy_result', 'collect_current_deploy_log', 'refresh_release_snapshot'];
-	}
-	if (action === 'block_duplicate_deploy') {
-		return ['collect_existing_deploy_evidence', 'hotfix_release_artifact', 'request_force_deploy_with_reason'];
-	}
-	if (action === 'block_duplicate_publish') {
-		return ['collect_existing_publish_evidence', 'hotfix_release_artifact', 'request_force_publish_with_reason'];
-	}
-	if (action === 'review_force_deploy') {
-		return ['verify_force_deploy_reason', 'rerun_failed_release_gate_once', 'record_force_deploy_evidence'];
-	}
-	if (action === 'deploy_new_artifact_after_release_gate') {
-		return ['verify_new_artifact_fingerprint', 'run_release_gate_once', 'record_publish_deploy_evidence'];
-	}
-	if (action === 'build_artifact_first') {
-		return ['build_missing_release_artifact', 'record_artifact_fingerprint', 'run_release_gate_once'];
-	}
-	return ['hotfix_live_runner_or_release_artifact', 'rerun_failed_release_gate_only', 'record_release_evidence'];
-}
-
-function hotfixStep(
-	id: string,
-	label: string,
-	channel: ResolveIOAIManagerHotfixChannel,
-	options: {
-		safeToAutoRun?: boolean;
-		requiresFullDeploy?: boolean;
-		requiredEvidence?: string[];
-		successEvidence?: string[];
-		blockedBy?: string[];
-	} = {}
-): ResolveIOAIManagerHotfixPlanStep {
-	return {
-		id,
-		label,
-		channel,
-		safeToAutoRun: options.safeToAutoRun === true,
-		requiresFullDeploy: options.requiresFullDeploy === true,
-		requiredEvidence: options.requiredEvidence || [],
-		successEvidence: options.successEvidence || [],
-		blockedBy: options.blockedBy || []
-	};
-}
-
-function buildHotfixFirstReleasePlan(input: {
-	action: ResolveIOAIManagerHotfixFirstReleaseAction;
-	surface: string;
-	reason: string;
-	releaseBlocked: boolean;
-}): ResolveIOAIManagerHotfixPlan {
-	const surface = cleanText(input.surface || 'runner', 80)
-		.toLowerCase()
-		.replace(/[^a-z0-9]+/g, '_')
-		.replace(/^_+|_+$/g, '') || 'runner';
-	const commonAcceptance = [
-		'failed release gate is rerun once and passes',
-		'artifact fingerprint or hotfix evidence is recorded',
-		'operator console shows no active duplicate deploy blocker'
-	];
-	if (input.action === 'wait_for_active_deploy') {
-		return {
-			planId: `${surface}:wait_for_active_deploy`,
-			label: 'Wait For Active Deploy',
-			recommendedChannel: 'release_artifact',
-			reason: input.reason,
-			fullDeployAvoided: true,
-			steps: [
-				hotfixStep('collect_active_deploy_log', 'Collect active deploy log', 'release_artifact', {
-					safeToAutoRun: true,
-					requiredEvidence: ['active deploy id or release operation id'],
-					successEvidence: ['terminal deploy status and release log captured']
-				})
-			],
-			acceptanceEvidence: commonAcceptance,
-			escalationTriggers: ['active deploy exceeds timeout', 'active deploy fails without a release log']
-		};
-	}
-	if (input.action === 'deploy_new_artifact_after_release_gate') {
-		return {
-			planId: `${surface}:deploy_new_artifact_after_release_gate`,
-			label: 'Deploy New Artifact After Release Gate',
-			recommendedChannel: 'new_artifact_deploy',
-			reason: input.reason,
-			fullDeployAvoided: false,
-			steps: [
-				hotfixStep('verify_new_artifact_fingerprint', 'Verify new artifact fingerprint', 'new_artifact_deploy', {
-					safeToAutoRun: true,
-					requiresFullDeploy: true,
-					requiredEvidence: ['current artifact fingerprint differs from last deployed fingerprint'],
-					successEvidence: ['release gate permits one full deploy']
-				})
-			],
-			acceptanceEvidence: [
-				'new artifact fingerprint recorded',
-				'release gate passed before full deploy',
-				'deploy/publish result recorded'
-			],
-			escalationTriggers: ['artifact fingerprint matches last deploy', 'release gate fails']
-		};
-	}
-	if (input.action === 'build_artifact_first') {
-		return {
-			planId: `${surface}:build_artifact_first`,
-			label: 'Build Artifact First',
-			recommendedChannel: 'artifact_build',
-			reason: input.reason,
-			fullDeployAvoided: true,
-			steps: [
-				hotfixStep('build_once_record_fingerprint', 'Build once and record fingerprint', 'artifact_build', {
-					safeToAutoRun: false,
-					requiredEvidence: ['missing artifact fingerprint', 'release gate reason for building'],
-					successEvidence: ['artifact fingerprint recorded before any deploy']
-				})
-			],
-			acceptanceEvidence: ['artifact fingerprint exists', 'no deploy queued before release gate'],
-			escalationTriggers: ['build repeats without a new fingerprint', 'build failure lacks compile log']
-		};
-	}
-	if (input.action === 'review_force_deploy') {
-		return {
-			planId: `${surface}:review_force_deploy`,
-			label: 'Review Force Deploy',
-			recommendedChannel: 'force_deploy_review',
-			reason: input.reason,
-			fullDeployAvoided: false,
-			steps: [
-				hotfixStep('verify_force_deploy_reason', 'Verify force deploy reason', 'force_deploy_review', {
-					requiredEvidence: ['explicit force_deploy reason', 'why hotfix cannot resolve the release blocker'],
-					successEvidence: ['one allowed deploy attempt is recorded with reason']
-				})
-			],
-			acceptanceEvidence: ['force deploy evidence recorded', 'duplicate fingerprint exception is auditable'],
-			escalationTriggers: ['force deploy reason is empty', 'same force deploy fails twice']
-		};
-	}
-	return {
-		planId: `${surface}:${input.action}`,
-		label: input.action === 'block_duplicate_deploy'
-			? 'Hotfix Or Force Deploy'
-			: input.action === 'block_duplicate_publish'
-				? 'Hotfix Or Force Publish'
-				: 'Hotfix Release Artifact',
-		recommendedChannel: input.action === 'block_duplicate_publish'
-			? 'release_artifact'
-			: input.releaseBlocked ? 'release_artifact' : 'static_ui',
-		reason: input.reason,
-		fullDeployAvoided: true,
-		steps: [
-			hotfixStep('static_ui_hotfix', 'Static UI hotfix', 'static_ui', {
-				safeToAutoRun: true,
-				requiredEvidence: ['sourceCommitSha, githubCommitUrl, and passed gitPushStatus', 'built dist path', 'target S3 bucket and CloudFront distribution', 'changed frontend bundle or asset list'],
-				successEvidence: ['GitHub commit and push proof', 'S3 upload result', 'CloudFront invalidation id', 'public bundle contains expected hotfix marker']
-			}),
-			hotfixStep('backend_js_hotfix', 'Backend JS hotfix', 'backend_js', {
-				requiredEvidence: ['sourceCommitSha, githubCommitUrl, and passed gitPushStatus', 'compiled JS artifact path', 'target backend host', 'diff limited to runner/operator code'],
-				successEvidence: ['GitHub commit and push proof', 'remote file checksum', 'service restart or process reload evidence', 'self-test passes']
-			}),
-			hotfixStep('config_seed_cache_restart', 'Config, seed, cache, or restart repair', 'config', {
-				safeToAutoRun: true,
-				requiredEvidence: ['sourceCommitSha, githubCommitUrl, and passed gitPushStatus', 'exact config/seed/cache key or process name', 'why no product artifact changed'],
-				successEvidence: ['GitHub commit and push proof', 'release gate rerun result', 'operator console release snapshot refreshed']
-			})
-		],
-		acceptanceEvidence: commonAcceptance,
-		escalationTriggers: [
-			'hotfix changes customer-facing product code outside the release artifact',
-			'same release gate fails twice after hotfix evidence',
-			'same publish fingerprint is retried without force_publish evidence',
-			'force deploy is requested without a reason'
-		]
-	};
-}
-
-export function buildResolveIOAIManagerHotfixFirstReleasePolicy(
-	input: ResolveIOAIManagerHotfixFirstReleasePolicyInput = {}
-): ResolveIOAIManagerHotfixFirstReleasePolicy {
-	const surface = cleanText(input.surface || 'runner', 120);
-	const deployStatus = cleanText(input.deployStatus, 160);
-	const publishStatus = cleanText(input.publishStatus, 160);
-	const sampleDataStatus = cleanText(input.sampleDataStatus, 160);
-	const deployFingerprint = cleanText(input.deployFingerprint, 240);
-	const lastDeployFingerprint = cleanText(input.lastDeployFingerprint, 240);
-	const publishFingerprint = cleanText(input.publishFingerprint, 240);
-	const lastPublishFingerprint = cleanText(input.lastPublishFingerprint, 240);
-	const fingerprintMatchesLast = !!deployFingerprint && !!lastDeployFingerprint && deployFingerprint === lastDeployFingerprint;
-	const publishFingerprintMatchesLast = !!publishFingerprint && !!lastPublishFingerprint && publishFingerprint === lastPublishFingerprint;
-	const releaseBlocked = [deployStatus, publishStatus, sampleDataStatus].some(releaseStatusIsBlocked);
-	const duplicateDeployBlocked = fingerprintMatchesLast
-		&& input.forceDeploy !== true
-		&& releaseStatusIsTerminalDeploy([deployStatus, publishStatus].filter(Boolean).join(' '));
-	const duplicatePublishBlocked = publishFingerprintMatchesLast
-		&& input.forcePublish !== true
-		&& releaseStatusIsBlocked(publishStatus)
-		&& releaseStatusIsTerminalDeploy(publishStatus);
-	let recommendedAction: ResolveIOAIManagerHotfixFirstReleaseAction = 'hotfix_release_artifact';
-	let label = 'Hotfix Release Artifact';
-	let reason = 'Repair the live runner/operator code, release config, domain, seed-data, or release artifact and rerun only the failed release gate.';
-	let fullDeployAllowed = false;
-	if (input.activeDeploy === true) {
-		recommendedAction = 'wait_for_active_deploy';
-		label = 'Wait For Active Deploy';
-		reason = 'A deploy is already queued or running; collect that result before spending another deploy cycle.';
-	}
-	else if (duplicateDeployBlocked) {
-		recommendedAction = 'block_duplicate_deploy';
-		label = 'Block Duplicate Deploy';
-		reason = 'The same artifact fingerprint already has release status; hotfix or provide explicit force_deploy evidence before rerunning it.';
-	}
-	else if (duplicatePublishBlocked) {
-		recommendedAction = 'block_duplicate_publish';
-		label = 'Block Duplicate Publish';
-		reason = 'The same publish fingerprint already has release status; hotfix the release artifact or provide explicit force_publish evidence before rerunning publish.';
-	}
-	else if ((fingerprintMatchesLast && input.forceDeploy === true) || (publishFingerprintMatchesLast && input.forcePublish === true)) {
-		recommendedAction = 'review_force_deploy';
-		label = 'Review Force Deploy';
-		reason = input.forcePublish === true
-			? 'force_publish was explicitly requested for a repeated publish artifact; require a reason and rerun only the failed release gate.'
-			: 'force_deploy was explicitly requested for a repeated artifact; require a reason and rerun only the failed release gate.';
-		fullDeployAllowed = true;
-	}
-	else if (input.hasNewArtifact === false && !releaseBlocked) {
-		recommendedAction = 'build_artifact_first';
-		label = 'Build Artifact First';
-		reason = 'No release artifact fingerprint is available yet; build once, record the fingerprint, and avoid repeated deploys.';
-	}
-	else if (input.hasNewArtifact === true && !releaseBlocked) {
-		recommendedAction = 'deploy_new_artifact_after_release_gate';
-		label = 'Deploy New Artifact After Release Gate';
-		reason = 'A new artifact can be deployed after the release gate proves the artifact is new and ready.';
-		fullDeployAllowed = true;
-	}
-	const allowedActions = buildReleaseAllowedActions(recommendedAction);
-	const hotfixPlan = buildHotfixFirstReleasePlan({
-		action: recommendedAction,
-		surface,
-		reason,
-		releaseBlocked
-	});
-	return {
-		policy: 'hotfix_first',
-		surface,
-		recommendedAction,
-		label,
-		reason,
-		hotfixPreferred: recommendedAction !== 'deploy_new_artifact_after_release_gate' && recommendedAction !== 'review_force_deploy',
-		fullDeployAllowed,
-		duplicateDeployBlocked,
-		duplicatePublishBlocked,
-		forceDeployRequiredToRepeat: true,
-		forcePublishRequiredToRepeat: true,
-		statuses: {
-			deploy: deployStatus,
-			publish: publishStatus,
-			sampleData: sampleDataStatus
-		},
-		fingerprints: {
-			current: deployFingerprint,
-			last: lastDeployFingerprint,
-			matchesLast: fingerprintMatchesLast,
-			publishCurrent: publishFingerprint,
-			publishLast: lastPublishFingerprint,
-			publishMatchesLast: publishFingerprintMatchesLast
-		},
-		hotfixPlan,
-		allowedActions,
-		forbiddenActions: [
-			'rerun full builder loop for a release-only blocker',
-			'queue duplicate deploy without force_deploy evidence',
-			'queue duplicate publish without force_publish evidence',
-			'publish/deploy again before reading the failed release log',
-			'change core workflow after business proof passed unless release evidence proves it is required'
-		],
-		requiredEvidence: [
-			'failed release gate log or active deploy result',
-			'deploy artifact fingerprint comparison',
-			'publish artifact fingerprint comparison when publish is the failed gate',
-			'hotfix/config/seed/domain change evidence when no new product artifact is needed',
-			'force_deploy or force_publish reason when repeating the same fingerprint'
-		]
-	};
-}
-
-export function isResolveIOAIManagerSafeAutoDispatch(
-	input: ResolveIOAIManagerAutoDispatchPolicyInput | ResolveIOAIManagerRecoveryActionDispatchAction | string | undefined
-): boolean {
-	const normalizedInput = typeof input === 'string'
-		? { dispatchAction: input }
-		: (input || {});
-	const dispatchAction = cleanText(normalizedInput.dispatchAction || normalizedInput.directive?.dispatchAction, 120);
-	const directiveAllowed = normalizedInput.directive?.allowed;
-	const actionAutoRunnable = normalizedInput.action?.autoRunnable;
-	const productRepairAllowed = normalizedInput.directive?.canRunProductRepair === true
-		|| normalizedInput.directive?.productRepairAllowed === true
-		|| normalizedInput.action?.productRepairAllowed === true;
-	const expensiveModelAllowed = normalizedInput.directive?.canRunExpensiveModel === true
-		|| normalizedInput.directive?.expensiveModelAllowed === true
-		|| normalizedInput.action?.expensiveModelAllowed === true;
-	if (!dispatchAction || dispatchAction === 'park_manual') {
-		return false;
-	}
-	if (directiveAllowed === false || actionAutoRunnable === false) {
-		return false;
-	}
-	if ([
-		'run_evidence_probe',
-		'run_read_only_diagnosis',
-		'run_infra_repair',
-		'run_compile_repair'
-	].includes(dispatchAction)) {
-		return true;
-	}
-	if (dispatchAction === 'run_release_repair') {
-		return normalizedInput.includeReleaseRepair !== false;
-	}
-	if (dispatchAction === 'run_journey_contract_repair') {
-		return normalizedInput.includeJourneyContractRepair !== false && productRepairAllowed !== true;
-	}
-	if (dispatchAction === 'run_business_assertion_repair') {
-		return normalizedInput.includeBusinessProofRepair === true
-			&& productRepairAllowed !== true
-			&& expensiveModelAllowed !== true;
-	}
-	if (dispatchAction === 'run_targeted_product_repair') {
-		return normalizedInput.includeProductRepair === true
-			&& productRepairAllowed === true
-			&& expensiveModelAllowed !== true;
-	}
-	return dispatchAction === 'advance' || dispatchAction === 'continue_gate';
-}
-
-function isoNow(value?: Date | string): string {
-	if (value instanceof Date) {
-		return value.toISOString();
-	}
-	const parsed = value ? new Date(value) : new Date();
-	if (Number.isFinite(parsed.getTime())) {
-		return parsed.toISOString();
-	}
-	return new Date().toISOString();
-}
-
-function stableHash(prefix: string, value: any): string {
-	const normalized = typeof value === 'string'
-		? cleanText(value, 12000)
-		: JSON.stringify(value || {});
-	let hash = 0;
-	for (let index = 0; index < normalized.length; index += 1) {
-		hash = ((hash << 5) - hash + normalized.charCodeAt(index)) | 0;
-	}
-	return `${prefix}-${Math.abs(hash).toString(36) || '0'}`;
-}
-
-export function normalizeResolveIOAIManagerFailureClass(value: any): string {
-	const normalized = cleanText(value, 80)
-		.toLowerCase()
-		.replace(/[\s-]+/g, '_');
-	if (!normalized) {
-		return 'unknown';
-	}
-	if (/^(qa_infra|infrastructure|harness|puppeteer|chrome|mongo|port|startup)$/.test(normalized)) {
-		return 'infra';
-	}
-	if (/^(build|compile|typescript|tsc|angular_build|ng_build)$/.test(normalized)) {
-		return 'compile';
-	}
-	if (/^(false_pass|route_only|missing_business_proof)$/.test(normalized)) {
-		return 'business';
-	}
-	return normalized.slice(0, 80);
-}
-
-export function fingerprintResolveIOAIManagerBlocker(value: any): string {
-	const normalized = cleanText(value, 4000)
-		.toLowerCase()
-		.replace(/[a-f0-9]{16,}/g, '<id>')
-		.replace(/\b\d{2,}\b/g, '<n>')
-		.replace(/\bline\s+<n>\b/g, 'line <n>')
-		.replace(/https?:\/\/\S+/g, '<url>')
-		.replace(/\s+/g, ' ')
-		.trim();
-	return stableHash('mgr-blocker', normalized);
-}
-
-function resolveResolveIOAIManagerBlockerFingerprint(
-	record: ResolveIOAIManagerFailureRecord | undefined,
-	fallback?: any
-): string {
-	const blockerText = cleanText(record?.blocker || record?.summary, 4000);
-	if (blockerText) {
-		return fingerprintResolveIOAIManagerBlocker(blockerText);
-	}
-	const explicit = cleanText(record?.blockerFingerprint, 120);
-	if (explicit) {
-		return explicit;
-	}
-	return fingerprintResolveIOAIManagerBlocker(fallback || '');
-}
-
-export function hashResolveIOAIManagerEvidence(record: ResolveIOAIManagerFailureRecord | undefined): string {
-	if (!record) {
-		return stableHash('mgr-evidence', '');
-	}
-	const explicit = cleanText(record.evidenceHash, 120);
-	if (explicit) {
-		return explicit;
-	}
-	return stableHash('mgr-evidence', {
-		failureClass: normalizeResolveIOAIManagerFailureClass(record.failureClass),
-		blocker: cleanText(record.blocker || record.summary, 2000),
-		changedFiles: cleanList(record.changedFiles, 80, 500).sort(),
-		artifactPaths: cleanList(record.artifactPaths, 80, 500).sort()
-	});
-}
-
-export function buildResolveIOAIManagerRecoveryCheckpoint(
-	input: ResolveIOAIManagerRecoveryCheckpointInput
-): ResolveIOAIManagerRecoveryCheckpoint {
-	const plan = input.plan;
-	const current = input.current || {};
-	const blockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(current, plan.objective);
-	const evidenceHash = hashResolveIOAIManagerEvidence(current);
-	const changedFiles = cleanList(current.changedFiles, 80, 500);
-	const artifactPaths = cleanList(current.artifactPaths, 80, 500);
-	const previous = input.previousCheckpoint;
-	const sameCheckpointBase = previous
-		&& previous.recoveryClass === plan.recoveryClass
-		&& previous.lane === plan.lane
-		&& previous.stepType === plan.stepType
-		&& previous.blockerFingerprint === blockerFingerprint
-		&& previous.evidenceHash === evidenceHash;
-	const attempts = sameCheckpointBase ? Math.max(0, Number(previous.attempts || 0)) + 1 : 1;
-	const status: ResolveIOAIManagerRecoveryCheckpointStatus = plan.recoveryClass === 'manual_handoff'
-		? 'manual_handoff'
-		: plan.recoveryClass === 'blocked_until_new_evidence'
-			? 'parked'
-			: plan.recoveryClass === 'advance_after_proof'
-				? 'complete'
-				: 'active';
-	const now = isoNow(input.now);
-	const checkpointId = stableHash('mgr-recovery', {
-		recoveryClass: plan.recoveryClass,
-		lane: plan.lane,
-		stepType: plan.stepType,
-		allowedAction: plan.allowedAction,
-		blockerFingerprint,
-		evidenceHash
-	});
-	return {
-		checkpointId,
-		recoveryClass: plan.recoveryClass,
-		status,
-		lane: plan.lane,
-		stepType: plan.stepType,
-		allowedAction: plan.allowedAction,
-		productRepairAllowed: plan.productRepairAllowed,
-		expensiveModelAllowed: plan.expensiveModelAllowed,
-		attempts,
-		maxAttemptsBeforePark: plan.maxAttemptsBeforePark,
-		blockerFingerprint,
-		evidenceHash,
-		changedFiles,
-		artifactPaths,
-		requiredEvidence: cleanList(plan.requiredEvidence, 40, 500),
-		loopResetEvidence: cleanList(plan.loopResetEvidence, 40, 500),
-		forbiddenActions: cleanList(plan.forbiddenActions, 40, 500),
-		objective: cleanText(plan.objective, 1000),
-		nextActionLabel: cleanText(plan.nextActionLabel, 160),
-		createdAt: sameCheckpointBase && previous?.createdAt ? previous.createdAt : now,
-		updatedAt: now
-	};
-}
-
-function makeRecoveryEvidenceProbeStep(
-	id: string,
-	kind: ResolveIOAIManagerRecoveryEvidenceProbeStepKind,
-	label: string,
-	objective: string,
-	artifactExpectation: string,
-	successSignal: string,
-	options: Partial<Pick<ResolveIOAIManagerRecoveryEvidenceProbeStep, 'required' | 'commandHint'>> = {}
-): ResolveIOAIManagerRecoveryEvidenceProbeStep {
-	return {
-		id,
-		kind,
-		label,
-		objective: cleanText(objective, 1000),
-		required: options.required !== false,
-		...(options.commandHint ? { commandHint: cleanText(options.commandHint, 500) } : {}),
-		artifactExpectation: cleanText(artifactExpectation, 500),
-		successSignal: cleanText(successSignal, 500)
-	};
-}
-
-function recoveryEvidenceProbeStepsFor(
-	checkpoint: ResolveIOAIManagerRecoveryCheckpoint
-): ResolveIOAIManagerRecoveryEvidenceProbeStep[] {
-	const base = [
-		makeRecoveryEvidenceProbeStep(
-			'snapshot_current_blocker',
-			'rerun_same_gate',
-			'Snapshot Current Blocker',
-			'Capture the current blocker, failure class, evidence hash, changed files, and artifact paths before any new repair.',
-			'runner-evidence/current-blocker.json',
-			'Snapshot includes the same checkpointId, blockerFingerprint, and evidenceHashBefore.'
-		)
-	];
-	if (checkpoint.recoveryClass === 'diagnosis_only' || checkpoint.recoveryClass === 'diagnosis_revision') {
-		return [
-			...base,
-			makeRecoveryEvidenceProbeStep(
-				'collect_read_only_root_cause_evidence',
-				'read_only_diagnosis',
-				'Collect Read-Only Root-Cause Evidence',
-				checkpoint.recoveryClass === 'diagnosis_revision'
-					? 'Collect new evidence that proves the current owner_files or failing_path is wrong before broadening scope.'
-					: 'Reproduce or classify the issue and record the exact customer complaint, expected result, observed result, route/module, and account context.',
-				'runner-evidence/diagnosis-readonly.md',
-				'Evidence supports one falsifiable accepted hypothesis and at least one rejected alternative.'
-			),
-			makeRecoveryEvidenceProbeStep(
-				'validate_diagnosis_gate',
-				'read_only_diagnosis',
-				'Validate Diagnosis Gate',
-				'Validate issue_case, accepted_hypothesis, rejected_alternatives, failing_path, owner_files, and before/action/after proof_plan.',
-				'runner-evidence/diagnosis-gate.json',
-				'Diagnosis gate validates before product-code repair is allowed.'
-			)
-		];
-	}
-	if (checkpoint.recoveryClass === 'infra_repair') {
-		return [
-			...base,
-			makeRecoveryEvidenceProbeStep(
-				'run_infra_preflight',
-				'infra_preflight',
-				'Run Infra Preflight',
-				'Check Puppeteer/Chrome, ports, Mongo/settings, cache state, startup commands, and server/client process health.',
-				'runner-evidence/infra-preflight.log',
-				'The same infra gate either passes or returns a new infra blocker hash.',
-				{ commandHint: 'runner preflight: puppeteer/chrome/mongo/ports/startup' }
-			)
-		];
-	}
-	if (checkpoint.recoveryClass === 'compile_repair') {
-		return [
-			...base,
-			makeRecoveryEvidenceProbeStep(
-				'rerun_compile_gate',
-				'compile_check',
-				'Rerun Compile Gate',
-				'Rerun the same deterministic compile/build command and capture the first actionable error.',
-				'runner-evidence/compile.log',
-				'Compile passes or the first failing error changes.',
-				{ commandHint: 'same finite build/compile command from the failed gate' }
-			)
-		];
-	}
-	if (checkpoint.recoveryClass === 'journey_contract_repair') {
-		return [
-			...base,
-			makeRecoveryEvidenceProbeStep(
-				'validate_journey_contract',
-				'journey_validation',
-				'Validate Journey Contract',
-				'Validate docs/APP_JOURNEY_CONTRACT.md has first/next/last workflow, route/action/method mapping, seeded data story, completion states, and QA assertions.',
-				'runner-evidence/journey-contract-validation.json',
-				'Journey contract validates before build tasks continue.'
-			),
-			makeRecoveryEvidenceProbeStep(
-				'verify_hub_workflow_mapping',
-				'journey_validation',
-				'Verify Hub Workflow Mapping',
-				'Confirm the hub CTA and screen sequence implement the journey contract instead of link-only navigation.',
-				'runner-evidence/hub-workflow-map.json',
-				'Primary hub action maps to a real route/action/method/calculation and next state.'
-			)
-		];
-	}
-	if (checkpoint.recoveryClass === 'business_proof_repair' || checkpoint.recoveryClass === 'product_code_repair') {
-		return [
-			...base,
-			makeRecoveryEvidenceProbeStep(
-				'rerun_business_assertion',
-				'business_assertion',
-				'Rerun Business Assertion',
-				'Run the exact issue/app promise proof and capture before/action/after DOM/data evidence.',
-				'runner-evidence/business-assertion.json',
-				'Business assertion passes, or the observed failure changes with a new artifact path.'
-			),
-			makeRecoveryEvidenceProbeStep(
-				'check_diff_scope',
-				'diff_scope_check',
-				'Check Diff Scope',
-				'Compare changed files against the current diagnosis/journey owner scope before another code repair.',
-				'runner-evidence/diff-scope.json',
-				'Changed files are in scope, or diagnosis/journey scope is revised with evidence.'
-			)
-		];
-	}
-	if (checkpoint.recoveryClass === 'release_repair') {
-		return [
-			...base,
-			makeRecoveryEvidenceProbeStep(
-				'collect_release_status',
-				'release_status',
-				'Collect Release Status',
-				'Collect publish/deploy/build-instance/domain/CloudFront status and the last actionable deploy error.',
-				'runner-evidence/release-status.json',
-				'Release gate passes or returns a new release blocker hash without product-code repair.'
-			)
-		];
-	}
-	if (checkpoint.recoveryClass === 'manual_handoff') {
-		return [
-			...base,
-			makeRecoveryEvidenceProbeStep(
-				'operator_review_checkpoint',
-				'operator_review',
-				'Operator Review Checkpoint',
-				'Expose budget, blocker, evidence hash, and the minimum policy/scope change needed before another expensive loop.',
-				'runner-evidence/operator-review.json',
-				'Operator approves a new scope/policy or provides new external evidence.'
-			)
-		];
-	}
-	return [
-		...base,
-		makeRecoveryEvidenceProbeStep(
-			'rerun_same_deterministic_gate',
-			'rerun_same_gate',
-			'Rerun Same Deterministic Gate',
-			'Rerun the exact failed check and capture new logs/artifacts without changing product code first.',
-			'runner-evidence/retry-gate.log',
-			'Gate passes, or evidenceHash/blockerFingerprint/artifactPaths change.'
-		)
-	];
-}
-
-export function buildResolveIOAIManagerRecoveryEvidenceProbe(
-	input: ResolveIOAIManagerRecoveryEvidenceProbeInput
-): ResolveIOAIManagerRecoveryEvidenceProbe {
-	const checkpoint = input.checkpoint;
-	const now = isoNow(input.now);
-	const steps = recoveryEvidenceProbeStepsFor(checkpoint);
-	const requiredArtifacts = Array.from(new Set(steps
-		.filter((step) => step.required)
-		.map((step) => step.artifactExpectation)
-		.filter(Boolean)));
-	return {
-		probeId: stableHash('mgr-probe', {
-			checkpointId: checkpoint.checkpointId,
-			recoveryClass: checkpoint.recoveryClass,
-			evidenceHash: checkpoint.evidenceHash,
-			blockerFingerprint: checkpoint.blockerFingerprint
-		}),
-		checkpointId: checkpoint.checkpointId,
-		recoveryClass: checkpoint.recoveryClass,
-		lane: checkpoint.lane,
-		stepType: checkpoint.stepType,
-		objective: checkpoint.status === 'parked'
-			? 'Collect new evidence before any additional expensive model/code repair.'
-			: cleanText(checkpoint.objective, 1000),
-		evidenceOnly: checkpoint.status === 'parked'
-			|| checkpoint.recoveryClass === 'diagnosis_only'
-			|| checkpoint.recoveryClass === 'diagnosis_revision'
-			|| checkpoint.recoveryClass === 'infra_repair'
-			|| checkpoint.recoveryClass === 'compile_repair'
-			|| checkpoint.recoveryClass === 'release_repair',
-		productRepairAllowed: checkpoint.productRepairAllowed && checkpoint.status !== 'parked',
-		expensiveModelAllowed: checkpoint.expensiveModelAllowed && checkpoint.status !== 'parked',
-		evidenceHashBefore: checkpoint.evidenceHash,
-		blockerFingerprint: checkpoint.blockerFingerprint,
-		steps,
-		requiredArtifacts,
-		acceptanceEvidence: Array.from(new Set([
-			...checkpoint.requiredEvidence,
-			...checkpoint.loopResetEvidence,
-			...steps.map((step) => step.successSignal)
-		].map((entry) => cleanText(entry, 500)).filter(Boolean))).slice(0, 30),
-		stopConditions: Array.from(new Set([
-			...checkpoint.forbiddenActions,
-			'no new evidence hash',
-			'no new artifact path',
-			'product-code repair requested while evidenceOnly is true'
-		].map((entry) => cleanText(entry, 500)).filter(Boolean))).slice(0, 30),
-		loopResetEvidence: checkpoint.loopResetEvidence,
-		createdAt: now
-	};
-}
-
-function recoveryAutomationModeFor(
-	checkpoint: ResolveIOAIManagerRecoveryCheckpoint
-): ResolveIOAIManagerRecoveryAutomationMode {
-	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: ResolveIOAIManagerRecoveryAutomationMode, checkpoint: ResolveIOAIManagerRecoveryCheckpoint): string {
-	const explicit = cleanText(checkpoint.nextActionLabel, 120);
-	if (explicit && mode !== 'collect_evidence') {
-		return explicit;
-	}
-	const labels: Record<ResolveIOAIManagerRecoveryAutomationMode, string> = {
-		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: ResolveIOAIManagerRecoveryAutomationMode,
-	probe: ResolveIOAIManagerRecoveryEvidenceProbe
-): boolean {
-	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((step) => step.commandHint || step.kind === 'rerun_same_gate' || step.kind === 'release_status' || step.kind === 'diff_scope_check');
-}
-
-function recoveryActionCostCeilingUsd(mode: ResolveIOAIManagerRecoveryAutomationMode): number {
-	const map: Record<ResolveIOAIManagerRecoveryAutomationMode, number> = {
-		advance: 0,
-		collect_evidence: 0.25,
-		read_only_diagnosis: 1,
-		repair_infra: 0.5,
-		repair_compile: 1.5,
-		repair_journey_contract: 2,
-		repair_business_assertion: 1.5,
-		repair_release: 0.75,
-		targeted_product_repair: 5,
-		manual_review: 0,
-		continue_gate: 0
-	};
-	return map[mode] ?? 1;
-}
-
-function recoveryActionRequiredStateTransition(mode: ResolveIOAIManagerRecoveryAutomationMode): string {
-	const map: Record<ResolveIOAIManagerRecoveryAutomationMode, string> = {
-		advance: 'current gate advances without repair after existing proof is accepted',
-		collect_evidence: 'blockerFingerprint or evidenceHash changes with material proof, or run remains parked',
-		read_only_diagnosis: 'diagnosis gate becomes valid or records a blocked-reproduction reason',
-		repair_infra: 'infra preflight changes from failed/blocked to passed, or records a new infra blocker',
-		repair_compile: 'compile/startup status changes from failed to passed, or records a new compile blocker',
-		repair_journey_contract: 'journey contract validates with first/next/last workflow proof',
-		repair_business_assertion: 'business assertion changes from missing/failed to passed with artifact proof',
-		repair_release: 'hotfix/release gate changes from blocked to passed, rerun_release_gate, or parked manual',
-		targeted_product_repair: 'owner-scoped diff is produced and deterministic proof advances to QA',
-		manual_review: 'operator records one explicit decision',
-		continue_gate: 'current gate records accepted proof and advances'
-	};
-	return map[mode] || 'runner records a validated state transition before continuing';
-}
-
-function recoveryActionProofRequiredBeforeContinuation(mode: ResolveIOAIManagerRecoveryAutomationMode): boolean {
-	return mode !== 'advance' && mode !== 'continue_gate' && mode !== 'manual_review';
-}
-
-function recoveryActionExitCriteria(input: {
-	mode: ResolveIOAIManagerRecoveryAutomationMode;
-	dispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
-	requiredStateTransition: string;
-	stopWhen: string[];
-}): string[] {
-	return Array.from(new Set([
-		`exact dispatch action ${input.dispatchAction} completed or was parked`,
-		input.requiredStateTransition,
-		...(recoveryActionProofRequiredBeforeContinuation(input.mode) ? ['do not continue runner until required proof artifact is attached'] : []),
-		...input.stopWhen
-	].map((entry) => cleanText(entry, 500)).filter(Boolean))).slice(0, 30);
-}
-
-function recoveryReleaseHotfixCommands(policy: ResolveIOAIManagerHotfixFirstReleasePolicy | undefined): string[] {
-	if (!policy) {
-		return [];
-	}
-	return Array.from(new Set([
-		...policy.allowedActions,
-		...(policy.hotfixPreferred ? [
-			'prepare_hotfix_patch_without_live_apply',
-			'commit_and_push_hotfix_to_github',
-			'record_github_commit_for_hotfix',
-			'apply_live_hotfix_only_after_github_commit_proof'
-		] : []),
-		'run_failed_release_gate_once',
-		'record_release_evidence'
-	].map((entry) => cleanText(entry, 500)).filter(Boolean))).slice(0, 20);
-}
-
-function recoveryReleaseRequiredEvidence(policy: ResolveIOAIManagerHotfixFirstReleasePolicy | undefined): string[] {
-	if (!policy) {
-		return [];
-	}
-	const stepEvidence = (policy.hotfixPlan?.steps || []).flatMap((step) => step.requiredEvidence || []);
-	return Array.from(new Set([
-		...policy.requiredEvidence,
-		...stepEvidence,
-		...(policy.hotfixPreferred ? [
-			'full 40-character sourceCommitSha',
-			'matching githubCommitUrl',
-			'passed gitPushStatus before any live hotfix is treated as durable'
-		] : [])
-	].map((entry) => cleanText(entry, 500)).filter(Boolean))).slice(0, 30);
-}
-
-function recoveryReleaseSuccessEvidence(policy: ResolveIOAIManagerHotfixFirstReleasePolicy | undefined): string[] {
-	if (!policy) {
-		return [];
-	}
-	const stepEvidence = (policy.hotfixPlan?.steps || []).flatMap((step) => step.successEvidence || []);
-	return Array.from(new Set([
-		...(policy.hotfixPlan?.acceptanceEvidence || []),
-		...stepEvidence,
-		...(policy.hotfixPreferred ? ['GitHub commit and push proof validates before continuation'] : [])
-	].map((entry) => cleanText(entry, 500)).filter(Boolean))).slice(0, 30);
-}
-
-export function buildResolveIOAIManagerRecoveryActionPacket(
-	input: ResolveIOAIManagerRecoveryActionPacketInput
-): ResolveIOAIManagerRecoveryActionPacket {
-	const checkpoint = input.checkpoint;
-	const probe = input.probe || buildResolveIOAIManagerRecoveryEvidenceProbe({
-		checkpoint,
-		current: input.current,
-		now: input.now
-	});
-	const mode = recoveryAutomationModeFor(checkpoint);
-	const primaryStep = probe.steps.find((step) => step.required && step.id !== 'snapshot_current_blocker')
-		|| probe.steps.find((step) => step.required)
-		|| probe.steps[0];
-	const evidenceOnly = probe.evidenceOnly || mode === 'collect_evidence' || mode === 'repair_infra' || mode === 'repair_compile' || mode === 'repair_release';
-	const requireNewEvidence = mode === 'collect_evidence'
-		|| checkpoint.status === 'parked'
-		|| checkpoint.attempts >= checkpoint.maxAttemptsBeforePark;
-	const stopWhen = Array.from(new Set([
-		...probe.stopConditions,
-		...(requireNewEvidence ? ['same blocker fingerprint and same evidence hash after probe'] : [])
-	].map((entry) => cleanText(entry, 500)).filter(Boolean))).slice(0, 30);
-	const resetLoopWhen = Array.from(new Set([
-		...checkpoint.loopResetEvidence,
-		...probe.loopResetEvidence,
-		...(requireNewEvidence ? [
-			'new material evidence: changed blocker, validated diagnosis/journey, business proof, compile/infra/release proof, or new actionable trace',
-			'weak hash-only evidence does not reset the loop'
-		] : [])
-	].map((entry) => cleanText(entry, 500)).filter(Boolean))).slice(0, 30);
-	const nextCommands = probe.steps
-		.map((step) => cleanText(step.commandHint || `${step.kind}:${step.id}`, 500))
-		.filter(Boolean)
-		.slice(0, 12);
-	const releasePolicy = mode === 'repair_release'
-		? buildResolveIOAIManagerHotfixFirstReleasePolicy({
-			surface: 'manager_recovery',
-			deployStatus: checkpoint.stepType,
-			publishStatus: checkpoint.lane
-		})
-		: undefined;
-	const releaseNextCommands = recoveryReleaseHotfixCommands(releasePolicy);
-	const releaseRequiredEvidence = recoveryReleaseRequiredEvidence(releasePolicy);
-	const releaseSuccessEvidence = recoveryReleaseSuccessEvidence(releasePolicy);
-	const allowedDispatchAction = dispatchActionForMode(mode);
-	const requiredStateTransition = recoveryActionRequiredStateTransition(mode);
-	const proofRequiredBeforeContinuation = recoveryActionProofRequiredBeforeContinuation(mode);
-	const exitCriteria = recoveryActionExitCriteria({
-		mode,
-		dispatchAction: allowedDispatchAction,
-		requiredStateTransition,
-		stopWhen
-	});
-	const now = isoNow(input.now);
-	return {
-		actionId: stableHash('mgr-action', {
-			checkpointId: checkpoint.checkpointId,
-			probeId: probe.probeId,
-			mode,
-			evidenceHash: checkpoint.evidenceHash,
-			blockerFingerprint: checkpoint.blockerFingerprint
-		}),
-		checkpointId: checkpoint.checkpointId,
-		probeId: probe.probeId,
-		recoveryClass: checkpoint.recoveryClass,
-		mode,
-		singleActionOnly: true,
-		allowedDispatchAction,
-		label: recoveryActionLabelFor(mode, checkpoint),
-		lane: checkpoint.lane,
-		stepType: checkpoint.stepType,
-		primaryStepKind: primaryStep?.kind || 'none',
-		objective: mode === 'collect_evidence'
-			? probe.objective
-			: cleanText(checkpoint.objective || probe.objective, 1000),
-		evidenceOnly,
-		autoRunnable: recoveryActionAutoRunnable(mode, probe),
-		productRepairAllowed: checkpoint.productRepairAllowed && !evidenceOnly && checkpoint.status !== 'parked',
-		expensiveModelAllowed: checkpoint.expensiveModelAllowed && checkpoint.status !== 'parked',
-		costCeilingUsd: recoveryActionCostCeilingUsd(mode),
-		requiredStateTransition,
-		proofRequiredBeforeContinuation,
-		canResetLoopAfterEvidence: resetLoopWhen.length > 0,
-		maxAttemptsBeforePark: checkpoint.maxAttemptsBeforePark,
-		requiredArtifacts: releasePolicy
-			? Array.from(new Set([...probe.requiredArtifacts, ...releaseRequiredEvidence])).slice(0, 20)
-			: probe.requiredArtifacts.slice(0, 20),
-		nextCommands: releasePolicy
-			? Array.from(new Set([...nextCommands, ...releaseNextCommands])).slice(0, 20)
-			: nextCommands,
-		successCriteria: releasePolicy
-			? Array.from(new Set([...probe.acceptanceEvidence, ...releaseSuccessEvidence])).slice(0, 20)
-			: probe.acceptanceEvidence.slice(0, 20),
-		exitCriteria,
-		retryPolicy: {
-			allowImmediateRetry: checkpoint.status !== 'parked' && mode !== 'manual_review',
-			requireNewEvidence,
-			resetLoopWhen,
-			stopWhen
-		},
-		...(releasePolicy ? { releasePolicy } : {}),
-		...(mode === 'collect_evidence' ? { blockedReason: 'Manager parked this loop until the recovery action records new evidence.' } : {}),
-		createdAt: now
-	};
-}
-
-function dispatchActionForMode(mode: ResolveIOAIManagerRecoveryAutomationMode): ResolveIOAIManagerRecoveryActionDispatchAction {
-	const map: Record<ResolveIOAIManagerRecoveryAutomationMode, ResolveIOAIManagerRecoveryActionDispatchAction> = {
-		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: ResolveIOAIManagerRecoveryActionPacket,
-	dispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction,
-	status: ResolveIOAIManagerRecoveryActionDispatchStatus,
-	reason: string,
-	current?: ResolveIOAIManagerFailureRecord,
-	now?: Date | string
-): ResolveIOAIManagerRecoveryActionDispatchRecord {
-	const evidenceHash = current?.evidenceHash || action.checkpointId || action.actionId;
-	const blockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(current, action.objective);
-	const artifactPaths = cleanList(current?.artifactPaths, 20, 500);
-	const createdAt = isoNow(now);
-	return {
-		dispatchId: stableHash('mgr-dispatch', {
-			actionId: action.actionId,
-			dispatchAction,
-			evidenceHash,
-			blockerFingerprint,
-			status
-		}),
-		actionId: action.actionId,
-		checkpointId: action.checkpointId,
-		probeId: action.probeId,
-		mode: action.mode,
-		dispatchAction,
-		status,
-		evidenceHash,
-		blockerFingerprint,
-		productRepairAllowed: action.productRepairAllowed && dispatchAction === 'run_targeted_product_repair',
-		expensiveModelAllowed: action.expensiveModelAllowed && dispatchAction !== 'run_evidence_probe',
-		reason,
-		artifactPaths,
-		...(status === 'started' ? { startedAt: createdAt } : {}),
-		...(status === 'completed' ? { completedAt: createdAt } : {}),
-		createdAt
-	};
-}
-
-export function decideResolveIOAIManagerRecoveryActionDispatch(
-	input: ResolveIOAIManagerRecoveryActionDispatchInput
-): ResolveIOAIManagerRecoveryActionDispatchDecision {
-	const action = input.action;
-	const history = Array.isArray(input.history) ? input.history.filter(Boolean).slice(-50) : [];
-	const 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
-		};
-	}
-	const dispatchAction = dispatchActionForMode(action.mode);
-	const allowedDispatchAction = action.allowedDispatchAction || dispatchAction;
-	const evidenceHash = current.evidenceHash || action.checkpointId || action.actionId;
-	const blockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(current, action.objective);
-	const sameActionHistory = history.filter((entry) => entry.actionId === action.actionId);
-	const sameEvidenceHistory = sameActionHistory.filter((entry) => entry.evidenceHash === evidenceHash
-		&& entry.blockerFingerprint === blockerFingerprint);
-	const activeDispatch = sameEvidenceHistory.find((entry) => entry.status === 'queued' || entry.status === 'started');
-	const completedDispatch = sameEvidenceHistory.find((entry) => entry.status === 'completed' || entry.status === 'failed');
-	const newEvidence = sameActionHistory.length > 0 && sameEvidenceHistory.length === 0;
-	const requiresNewEvidence = action.retryPolicy.requireNewEvidence === true;
-	const sameEvidenceAlreadyAttempted = !!completedDispatch && requiresNewEvidence && !newEvidence;
-	const manualOnly = action.mode === 'manual_review' || !action.autoRunnable;
-	const productDispatch = dispatchAction === 'run_targeted_product_repair';
-	const expensiveDispatch = !['run_evidence_probe', 'advance', 'continue_gate', 'park_manual'].includes(dispatchAction);
-	const evidenceAssessment = assessResolveIOAIManagerEvidenceChange(undefined, current, action.objective);
-	const autonomyPolicy = input.autonomyPolicy
-		? decideResolveIOAIManagerAutonomyPolicy({
-			...(input.autonomyPolicy || {}),
-			dispatchAction,
-			projectedActionCostUsd: input.autonomyPolicy?.projectedActionCostUsd ?? action.costCeilingUsd,
-			newEvidence: input.autonomyPolicy?.newEvidence ?? newEvidence,
-			materialEvidence: input.autonomyPolicy?.materialEvidence ?? evidenceAssessment.material,
-			evidenceStrength: input.autonomyPolicy?.evidenceStrength ?? evidenceAssessment.strength,
-			evidenceSignals: input.autonomyPolicy?.evidenceSignals ?? evidenceAssessment.signals,
-			sameEvidenceAlreadyAttempted: input.autonomyPolicy?.sameEvidenceAlreadyAttempted ?? sameEvidenceAlreadyAttempted,
-			operatorApproved: input.operatorApproved
-		})
-		: undefined;
-	const autonomyBlocksDispatch = !!autonomyPolicy && (
-		autonomyPolicy.mode === 'monitor_only'
-		|| (autonomyPolicy.requiresHumanApproval === true && input.operatorApproved !== true)
-		|| (autonomyPolicy.canAutoDispatch !== true && input.operatorApproved !== true)
-		|| (autonomyPolicy.blocked === true && autonomyPolicy.canManualDispatch !== true)
-	);
-	if (autonomyBlocksDispatch) {
-		const record = buildRecoveryDispatchRecord(action, 'park_manual', 'parked', `recovery_dispatch_blocked_by_autonomy_policy:${autonomyPolicy?.reason || 'unknown'}`, current, input.now);
-		return {
-			dispatchAction: 'park_manual',
-			allowed: false,
-			reason: record.reason,
-			status: 'parked',
-			canRunProductRepair: false,
-			canRunExpensiveModel: false,
-			shouldRecordDispatch: true,
-			requiresNewEvidence,
-			newEvidence,
-			autonomyPolicy,
-			dispatchRecord: record
-		};
-	}
-	if (action.singleActionOnly === true && allowedDispatchAction !== dispatchAction) {
-		const record = buildRecoveryDispatchRecord(action, 'park_manual', 'parked', 'recovery_dispatch_action_not_in_packet_contract', current, input.now);
-		return {
-			dispatchAction: 'park_manual',
-			allowed: false,
-			reason: record.reason,
-			status: 'parked',
-			canRunProductRepair: false,
-			canRunExpensiveModel: false,
-			shouldRecordDispatch: true,
-			requiresNewEvidence: true,
-			newEvidence,
-			autonomyPolicy,
-			dispatchRecord: record
-		};
-	}
-	if (manualOnly && input.operatorApproved !== true) {
-		const record = buildRecoveryDispatchRecord(action, 'park_manual', 'parked', 'recovery_dispatch_requires_manual_review', current, input.now);
-		return {
-			dispatchAction: 'park_manual',
-			allowed: false,
-			reason: record.reason,
-			status: 'parked',
-			canRunProductRepair: false,
-			canRunExpensiveModel: false,
-			shouldRecordDispatch: true,
-			requiresNewEvidence,
-			newEvidence,
-			autonomyPolicy,
-			dispatchRecord: record
-		};
-	}
-	if (productDispatch && action.productRepairAllowed !== true) {
-		const record = buildRecoveryDispatchRecord(action, 'park_manual', 'parked', 'recovery_dispatch_product_repair_not_allowed', current, input.now);
-		return {
-			dispatchAction: 'park_manual',
-			allowed: false,
-			reason: record.reason,
-			status: 'parked',
-			canRunProductRepair: false,
-			canRunExpensiveModel: false,
-			shouldRecordDispatch: true,
-			requiresNewEvidence: true,
-			newEvidence,
-			autonomyPolicy,
-			dispatchRecord: record
-		};
-	}
-	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,
-			autonomyPolicy
-		};
-	}
-	if (sameEvidenceAlreadyAttempted) {
-		const record = buildRecoveryDispatchRecord(action, 'park_manual', 'parked', 'recovery_dispatch_same_evidence_already_attempted', current, input.now);
-		return {
-			dispatchAction: 'park_manual',
-			allowed: false,
-			reason: record.reason,
-			status: 'parked',
-			canRunProductRepair: false,
-			canRunExpensiveModel: false,
-			shouldRecordDispatch: true,
-			requiresNewEvidence: true,
-			newEvidence: false,
-			autonomyPolicy,
-			dispatchRecord: record
-		};
-	}
-	const status: ResolveIOAIManagerRecoveryActionDispatchStatus = dispatchAction === 'advance' || dispatchAction === 'continue_gate'
-		? 'completed'
-		: 'started';
-	const record = buildRecoveryDispatchRecord(action, dispatchAction, status, 'recovery_dispatch_allowed', current, input.now);
-	return {
-		dispatchAction,
-		allowed: true,
-		reason: 'recovery_dispatch_allowed',
-		status,
-		canRunProductRepair: productDispatch && action.productRepairAllowed === true,
-		canRunExpensiveModel: expensiveDispatch && action.expensiveModelAllowed === true,
-		shouldRecordDispatch: true,
-		requiresNewEvidence,
-		newEvidence,
-		autonomyPolicy,
-		dispatchRecord: record
-	};
-}
-
-export function appendResolveIOAIManagerRecoveryActionDispatch(
-	history: ResolveIOAIManagerRecoveryActionDispatchRecord[] | undefined,
-	record: ResolveIOAIManagerRecoveryActionDispatchRecord | undefined,
-	limit = 50
-): ResolveIOAIManagerRecoveryActionDispatchRecord[] {
-	const existing = Array.isArray(history) ? history.filter(Boolean) : [];
-	if (!record) {
-		return existing.slice(-limit);
-	}
-	const deduped = existing.filter((entry) => entry.dispatchId !== record.dispatchId);
-	return [...deduped, record].slice(-limit);
-}
-
-function recoveryExecutionPhaseForDispatch(
-	dispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction
-): ResolveIOAIManagerRecoveryExecutionPhase {
-	const map: Record<ResolveIOAIManagerRecoveryActionDispatchAction, ResolveIOAIManagerRecoveryExecutionPhase> = {
-		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: ResolveIOAIManagerRecoveryActionPacket | undefined,
-	decision: ResolveIOAIManagerRecoveryActionDispatchDecision,
-	current?: ResolveIOAIManagerFailureRecord
-): string {
-	const blocker = cleanText(current?.blocker || current?.summary || '', 260);
-	const label = cleanText(action?.label, 120) || decision.dispatchAction;
-	const objective = cleanText(action?.objective, 260);
-	return [
-		`MANAGER_RECOVERY:${decision.dispatchAction}`,
-		`label=${label}`,
-		decision.reason ? `reason=${decision.reason}` : '',
-		blocker ? `blocker=${blocker}` : '',
-		objective ? `objective=${objective}` : ''
-	].filter(Boolean).join(' | ');
-}
-
-export function buildResolveIOAIManagerRecoveryExecutionDirective(
-	input: ResolveIOAIManagerRecoveryExecutionDirectiveInput
-): ResolveIOAIManagerRecoveryExecutionDirective {
-	const action = input.action;
-	const dispatchDecision = input.dispatchDecision || decideResolveIOAIManagerRecoveryActionDispatch({
-		action,
-		current: input.current,
-		autonomyPolicy: input.autonomyPolicy,
-		now: input.now
-	});
-	const dispatchAction = dispatchDecision.dispatchAction;
-	const now = isoNow(input.now);
-	const phase = recoveryExecutionPhaseForDispatch(dispatchAction);
-	const lane = cleanText(action?.lane || input.current?.lane || '', 120);
-	const stepType = cleanText(action?.stepType || input.current?.stepType || '', 120);
-	const rerunReason = recoveryDirectiveReason(action, dispatchDecision, input.current);
-	const surface = cleanText(input.surface || 'runner', 120);
-	return {
-		directiveId: stableHash('mgr-directive', {
-			surface,
-			actionId: action?.actionId || '',
-			dispatchAction,
-			reason: dispatchDecision.reason,
-			evidenceHash: dispatchDecision.dispatchRecord?.evidenceHash || input.current?.evidenceHash || ''
-		}),
-		surface,
-		dispatchAction,
-		phase,
-		allowed: dispatchDecision.allowed,
-		status: dispatchDecision.status,
-		reason: dispatchDecision.reason,
-		singleActionOnly: action?.singleActionOnly !== false,
-		allowedDispatchAction: action?.allowedDispatchAction || dispatchAction,
-		lane,
-		stepType,
-		nextActionLabel: cleanText(action?.label, 160) || dispatchAction,
-		rerunReason,
-		evidenceOnly: action?.evidenceOnly !== false || dispatchAction === 'run_evidence_probe',
-		autoRunnable: action?.autoRunnable === true,
-		productRepairAllowed: action?.productRepairAllowed === true,
-		expensiveModelAllowed: action?.expensiveModelAllowed === true,
-		costCeilingUsd: Math.max(0, Number(action?.costCeilingUsd || 0) || 0),
-		requiredStateTransition: cleanText(action?.requiredStateTransition, 500),
-		proofRequiredBeforeContinuation: action?.proofRequiredBeforeContinuation === true,
-		canRunProductRepair: dispatchDecision.canRunProductRepair,
-		canRunExpensiveModel: dispatchDecision.canRunExpensiveModel,
-		canResetLoopAfterEvidence: action?.canResetLoopAfterEvidence === true,
-		requiresNewEvidence: dispatchDecision.requiresNewEvidence,
-		newEvidence: dispatchDecision.newEvidence,
-		...(dispatchDecision.autonomyPolicy ? { autonomyPolicy: dispatchDecision.autonomyPolicy } : {}),
-		maxAttemptsBeforePark: Math.max(1, Number(action?.maxAttemptsBeforePark || 1) || 1),
-		requiredArtifacts: cleanList(action?.requiredArtifacts, 20, 500),
-		nextCommands: cleanList(action?.nextCommands, 20, 500),
-		successCriteria: cleanList(action?.successCriteria, 20, 500),
-		exitCriteria: cleanList(action?.exitCriteria, 30, 500),
-		forbiddenActions: action?.productRepairAllowed === true
-			? []
-			: Array.from(new Set([
-				'Do not run product-code repair from this directive unless canRunProductRepair is true.',
-				...(action?.releasePolicy?.forbiddenActions || [])
-			])).slice(0, 20),
-		...(dispatchDecision.dispatchRecord ? { dispatchRecord: dispatchDecision.dispatchRecord } : {}),
-		...(action?.releasePolicy ? { releasePolicy: action.releasePolicy } : {}),
-		createdAt: now
-	};
-}
-
-function newListEntries(current: string[], previous: string[]): string[] {
-	const existing = new Set(previous.map((entry) => cleanText(entry, 500)).filter(Boolean));
-	return current
-		.map((entry) => cleanText(entry, 500))
-		.filter((entry) => entry && !existing.has(entry));
-}
-
-function recordLane(value: any): string {
-	return cleanText(value?.lane, 80);
-}
-
-function recordStepType(value: any): string {
-	return cleanText(value?.stepType, 80);
-}
-
-function recordFailureClass(value: any): string {
-	const valueText = cleanText(value?.failureClass, 80);
-	return valueText ? normalizeResolveIOAIManagerFailureClass(valueText) : '';
-}
-
-function materialEvidenceText(record: ResolveIOAIManagerFailureRecord | undefined, paths: string[] = []): string {
-	return [
-		cleanText(record?.blocker, 1200),
-		cleanText(record?.summary, 1200),
-		...paths.map((path) => cleanText(path, 500))
-	].filter(Boolean).join(' ').toLowerCase();
-}
-
-function hasMaterialEvidenceLanguage(text: string): boolean {
-	return /(business|assertion|proof|before|after|dom|trace|stack|network|mongo|query|diff|scope|diagnosis|journey|contract|workflow|compile|build|preflight|infra|chrome|puppeteer|release|publish|deploy|sample|seed|route|auth|hydration|performance|slow|owner|root.?cause|repro|pdf|export|upload|import|filter|invoice|saved|calculated|comparison|report)/i.test(text);
-}
-
-export function assessResolveIOAIManagerEvidenceChange(
-	previous: (ResolveIOAIManagerFailureRecord | ResolveIOAIManagerRecoveryCheckpoint | undefined),
-	current: ResolveIOAIManagerFailureRecord | undefined,
-	fallbackObjective?: string
-): ResolveIOAIManagerEvidenceAssessment {
-	const currentRecord = current || {};
-	const previousRecord = previous as any;
-	const previousEvidenceHash = previousRecord ? cleanText(previousRecord.evidenceHash, 160) || hashResolveIOAIManagerEvidence(previousRecord) : '';
-	const currentEvidenceHash = hashResolveIOAIManagerEvidence(currentRecord);
-	const previousBlockerFingerprint = previousRecord
-		? cleanText(previousRecord.blockerFingerprint, 160) || resolveResolveIOAIManagerBlockerFingerprint(previousRecord, fallbackObjective)
-		: '';
-	const currentBlockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(currentRecord, fallbackObjective);
-	const previousChangedFiles = cleanList(previousRecord?.changedFiles, 80, 500);
-	const currentChangedFiles = cleanList(currentRecord.changedFiles, 80, 500);
-	const previousArtifactPaths = cleanList(previousRecord?.artifactPaths, 80, 500);
-	const currentArtifactPaths = cleanList(currentRecord.artifactPaths, 80, 500);
-	const addedChangedFiles = newListEntries(currentChangedFiles, previousChangedFiles);
-	const addedArtifactPaths = newListEntries(currentArtifactPaths, previousArtifactPaths);
-	const signals: string[] = [];
-	if (previousEvidenceHash && currentEvidenceHash !== previousEvidenceHash) {
-		signals.push('evidence_hash_changed');
-	}
-	if (previousBlockerFingerprint && currentBlockerFingerprint !== previousBlockerFingerprint) {
-		signals.push('blocker_fingerprint_changed');
-	}
-	if (recordLane(previousRecord) && recordLane(previousRecord) !== recordLane(currentRecord)) {
-		signals.push('lane_changed');
-	}
-	if (recordStepType(previousRecord) && recordStepType(previousRecord) !== recordStepType(currentRecord)) {
-		signals.push('step_type_changed');
-	}
-	if (recordFailureClass(previousRecord) && recordFailureClass(previousRecord) !== recordFailureClass(currentRecord)) {
-		signals.push('failure_class_changed');
-	}
-	if (addedChangedFiles.length) {
-		signals.push('changed_files_added');
-	}
-	if (addedArtifactPaths.length) {
-		signals.push('artifact_paths_added');
-	}
-	if (isPassingOutcome(currentRecord)) {
-		signals.push('passing_outcome');
-	}
-	const changed = signals.length > 0;
-	const evidenceText = materialEvidenceText(currentRecord, addedArtifactPaths);
-	const pathOrSummaryHasMaterialSignal = hasMaterialEvidenceLanguage(evidenceText);
-	const proof = signals.includes('passing_outcome');
-	const structuralChange = signals.some((signal) => /blocker_fingerprint_changed|lane_changed|step_type_changed|failure_class_changed/.test(signal));
-	const materialArtifact = addedArtifactPaths.length > 0 && pathOrSummaryHasMaterialSignal;
-	const materialChangedFiles = addedChangedFiles.length > 0
-		&& /diagnosis|owner|scope|diff|root.?cause|failing path|stack|trace|business|proof|compile|release|deploy|workflow|journey/i.test(evidenceText);
-	const material = proof || structuralChange || materialArtifact || materialChangedFiles;
-	const strength: ResolveIOAIManagerEvidenceStrength = proof
-		? 'proof'
-		: material
-			? 'material'
-			: changed
-				? 'weak'
-				: 'none';
-	return {
-		changed,
-		material,
-		strength,
-		signals,
-		evidenceHash: currentEvidenceHash,
-		blockerFingerprint: currentBlockerFingerprint
-	};
-}
-
-function proposedActionIsProductRepair(value: any): boolean {
-	const normalized = cleanText(value, 120);
-	return /product|code|repair|build|business|journey|workflow/i.test(normalized)
-		&& !/infra|compile|diagnosis|manual|evidence|release|publish/i.test(normalized);
-}
-
-export function decideResolveIOAIManagerRecoveryGate(
-	input: ResolveIOAIManagerRecoveryGateInput
-): ResolveIOAIManagerRecoveryGateDecision {
-	const checkpoint = input.checkpoint;
-	const hasCurrent = !!input.current;
-	const current = input.current || {};
-	const assessment = hasCurrent
-		? assessResolveIOAIManagerEvidenceChange(checkpoint, current, checkpoint.objective)
-		: {
-			changed: false,
-			material: false,
-			strength: 'none' as ResolveIOAIManagerEvidenceStrength,
-			signals: [],
-			evidenceHash: checkpoint.evidenceHash,
-			blockerFingerprint: checkpoint.blockerFingerprint
-		};
-	const blockerFingerprint = assessment.blockerFingerprint;
-	const evidenceHash = assessment.evidenceHash;
-	const changedFiles = hasCurrent ? cleanList(current.changedFiles, 80, 500) : checkpoint.changedFiles;
-	const artifactPaths = hasCurrent ? cleanList(current.artifactPaths, 80, 500) : checkpoint.artifactPaths;
-	const evidenceChanged = assessment.changed;
-	const proposedAction = cleanText(input.proposedAction || checkpoint.allowedAction, 120);
-	const productRepairRequested = proposedActionIsProductRepair(proposedAction);
-	const missingEvidence = checkpoint.requiredEvidence.filter((required) => {
-		const normalized = cleanText(required, 120).toLowerCase();
-		if (!normalized) {
-			return false;
-		}
-		if (/artifact|log|proof|gate|evidence/.test(normalized)) {
-			return !artifactPaths.length && !current.evidenceHash;
-		}
-		if (/diff|changed files|owner|scope|file/.test(normalized)) {
-			return !changedFiles.length;
-		}
-		return false;
-	});
-	const makeDecision = (
-		action: ResolveIOAIManagerRecoveryGateAction,
-		reason: string,
-		overrides: Partial<ResolveIOAIManagerRecoveryGateDecision> = {}
-	): ResolveIOAIManagerRecoveryGateDecision => ({
-		action,
-		reason,
-		canRunProductRepair: checkpoint.productRepairAllowed,
-		canRunExpensiveModel: checkpoint.expensiveModelAllowed,
-		shouldResetLoopBudget: false,
-		shouldIncrementAttempt: action === 'allow',
-		newEvidence: evidenceChanged,
-		materialEvidence: assessment.material,
-		evidenceStrength: assessment.strength,
-		evidenceSignals: assessment.signals,
-		blockerFingerprint,
-		evidenceHash,
-		missingEvidence,
-		checkpoint: {
-			...checkpoint,
-			updatedAt: isoNow(input.now)
-		},
-		...overrides
-	});
-
-	if (checkpoint.status === 'complete') {
-		return makeDecision('complete', 'recovery_gate_checkpoint_already_complete', {
-			canRunProductRepair: false,
-			canRunExpensiveModel: false,
-			shouldIncrementAttempt: false
-		});
-	}
-	if (checkpoint.status === 'manual_handoff' && input.operatorApproved !== true) {
-		return makeDecision('manual_handoff', 'recovery_gate_manual_handoff_requires_operator_approval', {
-			canRunProductRepair: false,
-			canRunExpensiveModel: false,
-			shouldIncrementAttempt: false
-		});
-	}
-	if (productRepairRequested && !checkpoint.productRepairAllowed) {
-		return makeDecision('reject_action', 'recovery_gate_product_repair_not_allowed_for_checkpoint', {
-			canRunProductRepair: false,
-			canRunExpensiveModel: false,
-			shouldIncrementAttempt: false
-		});
-	}
-	if (checkpoint.status === 'parked' && !evidenceChanged) {
-		return makeDecision('collect_new_evidence', 'recovery_gate_parked_until_new_evidence', {
-			canRunProductRepair: false,
-			canRunExpensiveModel: false,
-			shouldIncrementAttempt: false
-		});
-	}
-	if (checkpoint.status === 'parked' && evidenceChanged && !assessment.material) {
-		return makeDecision('collect_new_evidence', 'recovery_gate_weak_evidence_requires_material_signal', {
-			canRunProductRepair: false,
-			canRunExpensiveModel: false,
-			shouldIncrementAttempt: false
-		});
-	}
-	if (checkpoint.attempts >= checkpoint.maxAttemptsBeforePark && !evidenceChanged) {
-		return makeDecision('collect_new_evidence', 'recovery_gate_attempt_limit_requires_new_evidence', {
-			canRunProductRepair: false,
-			canRunExpensiveModel: false,
-			shouldIncrementAttempt: false
-		});
-	}
-	if (checkpoint.attempts >= checkpoint.maxAttemptsBeforePark && evidenceChanged && !assessment.material) {
-		return makeDecision('collect_new_evidence', 'recovery_gate_attempt_limit_requires_material_evidence', {
-			canRunProductRepair: false,
-			canRunExpensiveModel: false,
-			shouldIncrementAttempt: false
-		});
-	}
-	if (evidenceChanged) {
-		const currentFailureClass = normalizeResolveIOAIManagerFailureClass(current.failureClass);
-		const currentCanRunProductRepair = checkpoint.productRepairAllowed
-			|| !/^(infra|compile|diagnosis|release)$/i.test(currentFailureClass);
-		return makeDecision('allow', 'recovery_gate_new_material_evidence_unblocks_retry', {
-			canRunProductRepair: currentCanRunProductRepair,
-			canRunExpensiveModel: checkpoint.expensiveModelAllowed || currentCanRunProductRepair,
-			shouldResetLoopBudget: true
-		});
-	}
-	return makeDecision('allow', 'recovery_gate_action_allowed');
-}
-
-function failureKey(record: ResolveIOAIManagerFailureRecord | undefined): string {
-	if (!record) {
-		return '';
-	}
-	const failureClass = normalizeResolveIOAIManagerFailureClass(record.failureClass);
-	const blockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(record);
-	return `${cleanText(record.lane, 80)}:${cleanText(record.stepType, 80)}:${failureClass}:${blockerFingerprint}`;
-}
-
-function failureEvidenceKey(record: ResolveIOAIManagerFailureRecord | undefined): string {
-	return `${failureKey(record)}:${hashResolveIOAIManagerEvidence(record)}`;
-}
-
-function isPassingOutcome(record: ResolveIOAIManagerFailureRecord | undefined): boolean {
-	return /^(pass|accepted|ready_to_publish|published|ready_for_merge|complete|completed)$/i.test(cleanText(record?.outcome, 80));
-}
-
-function isManualOutcome(record: ResolveIOAIManagerFailureRecord | undefined): boolean {
-	return /^(manual_handoff|park_manual|stopped)$/i.test(cleanText(record?.outcome, 80));
-}
-
-export function buildResolveIOAIManagerRecoveryPlan(input: ResolveIOAIManagerRecoveryPlanInput = {}): ResolveIOAIManagerRecoveryPlan {
-	const action = cleanText(input.action, 80) || 'continue';
-	const reason = cleanText(input.reason, 240);
-	const failureClass = normalizeResolveIOAIManagerFailureClass(input.failureClass);
-	const lane = cleanText(input.lane, 80) || 'supervisor';
-	const stepType = cleanText(input.stepType, 80) || 'unknown';
-	const blocker = cleanText(input.blocker, 700);
-	const changedFiles = cleanList(input.changedFiles, 12, 240);
-	const artifactPaths = cleanList(input.artifactPaths, 12, 240);
-	const maxAttemptsBeforePark = Math.max(1, Number(input.maxSameFailureRepeats || 3) || 3);
-	const commonNotes = [
-		reason ? `policy_reason=${reason}` : '',
-		blocker ? `blocker=${blocker}` : '',
-		changedFiles.length ? `changed_files=${changedFiles.join(', ')}` : '',
-		artifactPaths.length ? `artifacts=${artifactPaths.join(', ')}` : ''
-	].filter(Boolean);
-	const base: Omit<ResolveIOAIManagerRecoveryPlan, 'recoveryClass' | 'nextActionLabel' | 'objective' | 'allowedAction' | 'productRepairAllowed' | 'expensiveModelAllowed' | 'finiteSteps' | 'requiredEvidence' | 'loopResetEvidence' | 'forbiddenActions'> = {
-		lane,
-		stepType,
-		maxAttemptsBeforePark,
-		notes: commonNotes
-	};
-	const makePlan = (
-		recoveryClass: ResolveIOAIManagerRecoveryClass,
-		nextActionLabel: string,
-		objective: string,
-		allowedAction: string,
-		productRepairAllowed: boolean,
-		expensiveModelAllowed: boolean,
-		finiteSteps: string[],
-		requiredEvidence: string[],
-		loopResetEvidence: string[],
-		forbiddenActions: string[]
-	): ResolveIOAIManagerRecoveryPlan => ({
-		...base,
-		recoveryClass,
-		nextActionLabel,
-		objective,
-		allowedAction,
-		productRepairAllowed,
-		expensiveModelAllowed,
-		finiteSteps,
-		requiredEvidence,
-		loopResetEvidence,
-		forbiddenActions
-	});
-	if (action === 'reset_loop_budget') {
-		return makePlan(
-			'advance_after_proof',
-			'Advance After Proof',
-			'Checkpoint the passing evidence and move to the next required gate.',
-			'advance_to_next_gate',
-			false,
-			false,
-			[
-				'Record the passing artifact, changed files, and gate result.',
-				'Reset the loop counter because a real gate passed.',
-				'Select the next unmet deterministic gate instead of repeating the previous repair.'
-			],
-			['passing gate record', 'artifact or log proving the passed check'],
-			['new passing gate result', 'new business proof artifact'],
-			['rerun the same repair after a pass', 'mark accepted without the required downstream gate']
-		);
-	}
-	if (action === 'manual_handoff') {
-		return makePlan(
-			'manual_handoff',
-			'Manual Review',
-			'Stop autonomous repair and expose the blocker, evidence, and last safe state.',
-			'manual_review_only',
-			false,
-			false,
-			[
-				'Freeze further product-code edits.',
-				'Show the blocker fingerprint, evidence hash, and prior attempts.',
-				'Require a human edit to classification, scope, or retry policy before another model/code loop.'
-			],
-			['blocker fingerprint', 'evidence hash', 'attempt history'],
-			['manual policy change', 'new external evidence'],
-			['start another automatic model repair', 'hide the failed evidence']
-		);
-	}
-	if (action === 'budget_stop') {
-		return makePlan(
-			'manual_handoff',
-			'Budget Stop Review',
-			'Stop autonomous model/code loops until a cheaper scoped next action is selected.',
-			'budget_review_only',
-			false,
-			false,
-			[
-				'Freeze further model repair loops.',
-				'Show the prompt/token/runtime budget that tripped the guard.',
-				'Select a cheaper deterministic gate, infra repair, diagnosis revision, or manual scope edit before resuming.'
-			],
-			['budget guard reason', 'latest prompt estimate', 'last blocker/evidence hash'],
-			['manual scope reduction', 'new deterministic evidence', 'approved budget policy change'],
-			['start another broad model prompt', 'reset budget without new evidence', 'hide cost context']
-		);
-	}
-	if (failureClass === 'diagnosis' || stepType === 'diagnosis_gate') {
-		return makePlan(
-			'diagnosis_only',
-			'Run Diagnosis Gate',
-			'Produce a falsifiable root-cause diagnosis before any repair.',
-			'read_only_diagnosis',
-			false,
-			true,
-			[
-				'Reproduce or explicitly classify the customer issue.',
-				'Accept one falsifiable hypothesis and record rejected alternatives.',
-				'Identify the frontend/backend/shared failing path.',
-				'Select a small owner_files set.',
-				'Define exact before/action/after business proof.'
-			],
-			['issue_case', 'accepted_hypothesis', 'rejected_alternatives', 'failing_path', 'owner_files', 'proof_plan'],
-			['new reproduction artifact', 'new query/log/code evidence', 'validated diagnosis gate'],
-			['edit product code', 'run broad repo repair', 'accept route-load evidence as success']
-		);
-	}
-	if (failureClass === 'owner_scope' || failureClass === 'out_of_scope' || /out.?of.?scope|owner_files/i.test(reason)) {
-		return makePlan(
-			'diagnosis_revision',
-			'Revise Diagnosis Scope',
-			'Revise owner_files only when new evidence proves the current scope is wrong.',
-			'diagnosis_revision_only',
-			false,
-			true,
-			[
-				'Compare changed files against the diagnosis owner_files.',
-				'Collect evidence proving why the new file is in the failing path.',
-				'Update accepted_hypothesis, failing_path, owner_files, and proof_plan together.',
-				'Resume repair only after the revised gate validates.'
-			],
-			['out-of-scope file list', 'new failing-path evidence', 'revalidated diagnosis gate'],
-			['revised owner_files with evidence', 'new business proof requirement'],
-			['keep broad edits without diagnosis', 'add convenience refactors', 'continue repair outside owner_files']
-		);
-	}
-	if (action === 'retry_infra') {
-		const isCompile = failureClass === 'compile';
-		return makePlan(
-			isCompile ? 'compile_repair' : 'infra_repair',
-			isCompile ? 'Repair Compile Gate' : 'Repair Infra Gate',
-			isCompile
-				? 'Fix the deterministic compile/build blocker before spending another product repair loop.'
-				: 'Fix the deterministic harness/browser/server/Mongo blocker before product repair.',
-			isCompile ? 'compile_repair_only' : 'infra_repair_only',
-			false,
-			false,
-			isCompile
-				? [
-					'Read the exact compile/build log and identify the first actionable error.',
-					'Fix missing dependency, stale artifact, command, cache, or type wiring required by the compile gate.',
-					'Rerun the same finite compile command.',
-					'Return the compile log artifact and status.'
-				]
-				: [
-					'Run preflight for Puppeteer, Chrome executable, ports, Mongo/settings, and startup command.',
-					'Repair only the failing harness/environment item.',
-					'Rerun the same infra check.',
-					'Return the infra log and pass/fail status.'
-				],
-			isCompile
-				? ['compile command', 'compile log artifact', 'first failing error fixed or still failing']
-				: ['preflight command', 'infra log artifact', 'specific repaired environment item'],
-			['same check now passes', 'new infra/compile blocker hash'],
-			['run product-code model repair', 'count this as product failure', 'accept route/business success without the compile/infra gate']
-		);
-	}
-	if (action === 'park_repeated_failure' || action === 'park_ping_pong') {
-		return makePlan(
-			'blocked_until_new_evidence',
-			action === 'park_ping_pong' ? 'Park Ping-Pong Loop' : 'Park Repeated Failure',
-			'Stop the current loop until new evidence changes the diagnosis, route, or repair target.',
-			'collect_new_evidence_only',
-			false,
-			false,
-			[
-				'Do not rerun the same prompt or same repair.',
-				'Show the repeated blocker and evidence hash.',
-				'Collect a new artifact: failing DOM state, stack trace, network response, Mongo delta, compile log, or revised diagnosis.',
-				'Reset the loop only after material evidence changes the blocker, proof, diagnosis, journey, or actionable trace.'
-			],
-			['same failure count', 'blocker fingerprint', 'evidence hash'],
-			['changed blocker fingerprint', 'changed evidence hash', 'new artifact path', 'business/compile/infra/release proof artifact', 'revised diagnosis or journey contract', 'new actionable trace or data delta'],
-			['alternate between two failed patches', 'increase loop budget without evidence', 'hide the park reason']
-		);
-	}
-	if (failureClass === 'journey') {
-		return makePlan(
-			'journey_contract_repair',
-			'Repair Journey Contract',
-			'Fix the first/next/last workflow contract before app code work continues.',
-			'journey_contract_repair',
-			false,
-			true,
-			[
-				'Open docs/APP_JOURNEY_CONTRACT.md.',
-				'Define first_screen, north_star_workflow, screen_sequence, data_story, completion_states, and qa_assertions.',
-				'Ensure each CTA maps to an action, route, method, calculation, or state transition.',
-				'Validate that sample data can drive the promised workflow.'
-			],
-			['validated journey_contract JSON', 'CTA-to-action mapping', 'workflow QA assertions'],
-			['journey validation passes', 'new workflow QA rows generated'],
-			['build empty routes', 'add link-only dashboard actions', 'defer workflow design to wow pass']
-		);
-	}
-	if (failureClass === 'release') {
-		return makePlan(
-			'release_repair',
-			'Repair Release Gate',
-			'Repair deploy/publish/sample-data release evidence with a hotfix-first path before any repeated full deploy.',
-			'release_repair_only',
-			false,
-			false,
-			[
-				'Read the deploy/publish/sample-data log.',
-				'Identify whether the blocker is domain, asset, seed data, route, permission, or CDN.',
-				'Prefer backend hotfix, release config, domain, cache, or seed-data repair when the product artifact already has business proof.',
-				'Rerun only the failed release gate.'
-			],
-			['deploy or publish log', 'sample-data status', 'failed release gate rerun'],
-			['release gate passes', 'new release blocker hash'],
-			['change core workflow after business QA passed', 'mark accepted from scorecard only', 'rerun full builder loop', 'repeat deploy of same artifact without force_deploy evidence']
-		);
-	}
-	if (failureClass === 'business' || failureClass === 'qa_evidence' || failureClass === 'route') {
-		return makePlan(
-			'business_proof_repair',
-			'Repair Business Proof',
-			'Fix the exact failing workflow assertion and prove before/action/after behavior.',
-			'business_repair',
-			true,
-			true,
-			[
-				'Open the failing QA row or proof_plan.',
-				'Trace the UI action to method/publication/query/calculation.',
-				'Patch the smallest owner or workflow files.',
-				'Rerun only the failed business assertion.',
-				'Record DOM/data/Mongo/artifact proof.'
-			],
-			['failing assertion', 'action trace', 'business proof artifact'],
-			['business assertion passes', 'new failed assertion with new evidence'],
-			['treat route load as success', 'rerun unrelated QA rows first', 'accept scorecard-only evidence']
-		);
-	}
-	if (input.productRepairFailure !== false || failureClass === 'product_code') {
-		return makePlan(
-			'product_code_repair',
-			'Run Targeted Product Repair',
-			'Repair the current product-code blocker with the smallest scoped edit and immediate proof.',
-			'targeted_product_repair',
-			true,
-			true,
-			[
-				'Inspect the current blocker, artifacts, changed files, and owner/workflow scope.',
-				'Form one small repair hypothesis.',
-				'Patch only files justified by the active diagnosis or journey contract.',
-				'Rerun the smallest failed gate.',
-				'Record new evidence before any additional loop.'
-			],
-			['owner/workflow scope', 'repair diff', 'failed gate rerun artifact'],
-			['new evidence hash', 'same gate passes'],
-			['broad repo search-and-edit', 'rerun the same prompt without inspecting artifacts', 'change unrelated UI polish']
-		);
-	}
-	return makePlan(
-		'continue',
-		'Continue Current Gate',
-		'Continue the current lane because no blocking loop or infra condition was detected.',
-		'continue',
-		false,
-		false,
-		[
-			'Use the active lane memory.',
-			'Run the next finite gate.',
-			'Record artifacts and evidence hash.'
-		],
-		['active lane memory', 'finite gate artifact'],
-		['new gate result', 'new artifact path'],
-		['spawn duplicate runners', 'advance without evidence']
-	);
-}
-
-function collectOpenTail(records: ResolveIOAIManagerFailureRecord[]): ResolveIOAIManagerFailureRecord[] {
-	const tail: ResolveIOAIManagerFailureRecord[] = [];
-	for (let index = records.length - 1; index >= 0; index -= 1) {
-		const record = records[index];
-		if (isPassingOutcome(record)) {
-			break;
-		}
-		tail.unshift(record);
-	}
-	return tail;
-}
-
-function countSameFailure(records: ResolveIOAIManagerFailureRecord[], current: ResolveIOAIManagerFailureRecord): number {
-	const currentKey = failureKey(current);
-	let count = 0;
-	for (let index = records.length - 1; index >= 0; index -= 1) {
-		const record = records[index];
-		if (isPassingOutcome(record)) {
-			break;
-		}
-		if (failureKey(record) !== currentKey) {
-			break;
-		}
-		count += 1;
-	}
-	return count;
-}
-
-function previousRecordForPolicy(
-	history: ResolveIOAIManagerFailureRecord[],
-	current: ResolveIOAIManagerFailureRecord,
-	currentWasExplicit: boolean
-): ResolveIOAIManagerFailureRecord | undefined {
-	if (!history.length) {
-		return undefined;
-	}
-	if (!currentWasExplicit) {
-		return history.length > 1 ? history[history.length - 2] : undefined;
-	}
-	const last = history[history.length - 1];
-	if (failureEvidenceKey(last) === failureEvidenceKey(current)) {
-		return history.length > 1 ? history[history.length - 2] : undefined;
-	}
-	return last;
-}
-
-function countPingPong(records: ResolveIOAIManagerFailureRecord[], current: ResolveIOAIManagerFailureRecord): number {
-	const tail = collectOpenTail(records).filter((record) => {
-		return cleanText(record.lane, 80) === cleanText(current.lane, 80)
-			&& cleanText(record.stepType, 80) === cleanText(current.stepType, 80);
-	});
-	if (tail.length < 4) {
-		return 0;
-	}
-	const keys = tail.map(failureKey).filter(Boolean);
-	const last = keys.slice(-6);
-	if (last.length < 4) {
-		return 0;
-	}
-	const distinct = Array.from(new Set(last));
-	if (distinct.length !== 2) {
-		return 0;
-	}
-	for (let index = 2; index < last.length; index += 1) {
-		if (last[index] !== last[index - 2]) {
-			return 0;
-		}
-	}
-	return last.length - 1;
-}
-
-export function decideResolveIOAIManagerPolicy(input: ResolveIOAIManagerPolicyInput): ResolveIOAIManagerPolicyDecision {
-	const history = Array.isArray(input.history) ? input.history : [];
-	const currentWasExplicit = !!input.current;
-	const current = input.current || history[history.length - 1] || {};
-	const failureClass = normalizeResolveIOAIManagerFailureClass(current.failureClass);
-	const blockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(current);
-	const evidenceHash = hashResolveIOAIManagerEvidence(current);
-	const previous = previousRecordForPolicy(history, current, currentWasExplicit);
-	const previousSameFailure = previous && failureKey(previous) === failureKey(current);
-	const evidenceAssessment = previousSameFailure
-		? assessResolveIOAIManagerEvidenceChange(previous, current)
-		: {
-			changed: false,
-			material: false,
-			strength: 'none' as ResolveIOAIManagerEvidenceStrength,
-			signals: [],
-			evidenceHash,
-			blockerFingerprint
-		};
-	const newEvidence = !!previousSameFailure && evidenceAssessment.changed;
-	const sameFailureCount = countSameFailure(history, current);
-	const pingPongCount = countPingPong(history, current);
-	const maxSameFailureRepeats = Math.max(1, Number(input.maxSameFailureRepeats || 3) || 3);
-	const maxPingPongTransitions = Math.max(3, Number(input.maxPingPongTransitions || 3) || 3);
-	const infraClasses = new Set((input.infraFailureClasses || ['infra', 'compile']).map(normalizeResolveIOAIManagerFailureClass));
-	const ignoredClasses = new Set((input.ignoredFailureClasses || []).map(normalizeResolveIOAIManagerFailureClass));
-	const base = {
-		failureClass,
-		blockerFingerprint,
-		evidenceHash,
-		sameFailureCount,
-		pingPongCount,
-		newEvidence,
-		materialEvidence: evidenceAssessment.material,
-		evidenceStrength: evidenceAssessment.strength,
-		evidenceSignals: evidenceAssessment.signals,
-		loopBudgetShouldReset: false,
-		productRepairFailure: !infraClasses.has(failureClass) && !ignoredClasses.has(failureClass)
-	};
-	const withPlan = (
-		action: ResolveIOAIManagerAction,
-		reason: string,
-		overrides: Partial<Omit<ResolveIOAIManagerPolicyDecision, 'action' | 'reason' | 'recoveryPlan' | 'recoveryCheckpoint'>> = {}
-	): ResolveIOAIManagerPolicyDecision => {
-		const merged = {
-			...base,
-			...overrides
-		};
-		const recoveryPlan = buildResolveIOAIManagerRecoveryPlan({
-			action,
-			reason,
-			failureClass: merged.failureClass,
-			lane: current.lane,
-			stepType: current.stepType,
-			blocker: current.blocker || current.summary,
-			sameFailureCount: merged.sameFailureCount,
-			pingPongCount: merged.pingPongCount,
-			newEvidence: merged.newEvidence,
-			productRepairFailure: merged.productRepairFailure,
-			changedFiles: current.changedFiles,
-			artifactPaths: current.artifactPaths,
-			maxSameFailureRepeats
-		});
-		const recoveryCheckpoint = buildResolveIOAIManagerRecoveryCheckpoint({
-			plan: recoveryPlan,
-			current
-		});
-		const recoveryEvidenceProbe = buildResolveIOAIManagerRecoveryEvidenceProbe({
-			checkpoint: recoveryCheckpoint,
-			current
-		});
-		return {
-			...merged,
-			action,
-			reason,
-			recoveryPlan,
-			recoveryCheckpoint,
-			recoveryEvidenceProbe,
-			recoveryAction: buildResolveIOAIManagerRecoveryActionPacket({
-				plan: recoveryPlan,
-				checkpoint: recoveryCheckpoint,
-				probe: recoveryEvidenceProbe,
-				current
-			})
-		};
-	};
-	if (isPassingOutcome(current)) {
-		return withPlan('reset_loop_budget', 'manager_policy_progress_passed', {
-			loopBudgetShouldReset: true,
-			productRepairFailure: false
-		});
-	}
-	if (isManualOutcome(current)) {
-		return withPlan('manual_handoff', 'manager_policy_manual_or_stopped');
-	}
-	if (pingPongCount >= maxPingPongTransitions) {
-		return withPlan('park_ping_pong', 'manager_policy_ping_pong_failure_loop');
-	}
-	if (sameFailureCount >= maxSameFailureRepeats && !evidenceAssessment.material) {
-		return withPlan('park_repeated_failure', newEvidence
-			? 'manager_policy_same_failure_with_weak_evidence'
-			: 'manager_policy_same_failure_without_new_evidence');
-	}
-	if (infraClasses.has(failureClass)) {
-		return withPlan('retry_infra', 'manager_policy_infra_failure_routes_to_infra_repair', {
-			productRepairFailure: false
-		});
-	}
-	if (newEvidence || !previousSameFailure) {
-		if (newEvidence && !evidenceAssessment.material) {
-			return withPlan('continue', 'manager_policy_weak_evidence_does_not_reset_loop_budget');
-		}
-		return withPlan('continue', newEvidence
-				? 'manager_policy_new_material_evidence_resets_loop_budget'
-				: 'manager_policy_new_failure_or_lane', {
-			loopBudgetShouldReset: true,
-			materialEvidence: newEvidence ? true : base.materialEvidence,
-			evidenceStrength: newEvidence ? evidenceAssessment.strength : base.evidenceStrength
-		});
-	}
-	return withPlan('continue', 'manager_policy_retry_below_repeat_limit');
-}
-
-function buildReplayDirectiveFromPlan(input: {
-	surface: string;
-	plan: ResolveIOAIManagerRecoveryPlan;
-	current: ResolveIOAIManagerFailureRecord;
-	now?: Date | string;
-}): ResolveIOAIManagerRecoveryExecutionDirective {
-	const checkpoint = buildResolveIOAIManagerRecoveryCheckpoint({
-		plan: input.plan,
-		current: input.current,
-		now: input.now
-	});
-	const probe = buildResolveIOAIManagerRecoveryEvidenceProbe({
-		checkpoint,
-		current: input.current,
-		now: input.now
-	});
-	const action = buildResolveIOAIManagerRecoveryActionPacket({
-		plan: input.plan,
-		checkpoint,
-		probe,
-		current: input.current,
-		now: input.now
-	});
-	const dispatch = decideResolveIOAIManagerRecoveryActionDispatch({
-		action,
-		current: input.current,
-		now: input.now
-	});
-	return buildResolveIOAIManagerRecoveryExecutionDirective({
-		action,
-		dispatchDecision: dispatch,
-		current: input.current,
-		surface: input.surface,
-		now: input.now
-	});
-}
-
-function replayCaseFromDirective(input: {
-	caseId: string;
-	surface: string;
-	action: string;
-	reason: string;
-	directive: ResolveIOAIManagerRecoveryExecutionDirective;
-	expectedSafeAutoDispatch: boolean;
-	pass: boolean;
-	loopBudgetShouldReset?: boolean;
-	materialEvidence?: boolean;
-	evidenceStrength?: ResolveIOAIManagerEvidenceStrength;
-	details?: Record<string, any>;
-}): ResolveIOAIManagerRecoveryReplayCase {
-	const directive = input.directive;
-	const safeAutoDispatch = isResolveIOAIManagerSafeAutoDispatch({
-		dispatchAction: directive.dispatchAction,
-		directive,
-		includeJourneyContractRepair: input.expectedSafeAutoDispatch && directive.dispatchAction === 'run_journey_contract_repair',
-		includeReleaseRepair: input.expectedSafeAutoDispatch && directive.dispatchAction === 'run_release_repair',
-		includeProductRepair: false
-	});
-	return {
-		caseId: input.caseId,
-		surface: input.surface,
-		pass: input.pass && safeAutoDispatch === input.expectedSafeAutoDispatch,
-		action: input.action,
-		reason: input.reason,
-		recoveryClass: cleanText(directive.dispatchRecord?.mode || directive.phase, 120),
-		dispatchAction: directive.dispatchAction,
-		safeAutoDispatch,
-		expectedSafeAutoDispatch: input.expectedSafeAutoDispatch,
-		productRepairAllowed: directive.canRunProductRepair === true,
-		loopBudgetShouldReset: input.loopBudgetShouldReset === true,
-		materialEvidence: input.materialEvidence === true,
-		evidenceStrength: input.evidenceStrength || 'none',
-		...(directive.releasePolicy ? {
-			hotfixFirst: directive.releasePolicy.policy === 'hotfix_first',
-			fullDeployAllowed: directive.releasePolicy.fullDeployAllowed
-		} : {}),
-		details: {
-			phase: directive.phase,
-			allowed: directive.allowed,
-			reason: directive.reason,
-			releasePolicy: directive.releasePolicy,
-			...(input.details || {})
-		}
-	};
-}
-
-export function buildResolveIOAIManagerRecoveryReplayMatrix(
-	input: ResolveIOAIManagerRecoveryReplayMatrixInput = {}
-): ResolveIOAIManagerRecoveryReplayCase[] {
-	const surface = cleanText(input.surface || 'runner', 120);
-	const maxSameFailureRepeats = Math.max(1, Number(input.maxSameFailureRepeats || 2) || 2);
-	const includeReleaseRepair = input.includeReleaseRepair !== false;
-	const includeJourneyContractRepair = input.includeJourneyContractRepair !== false;
-	const cases: ResolveIOAIManagerRecoveryReplayCase[] = [];
-	const infraPolicy = decideResolveIOAIManagerPolicy({
-		history: [
-			{ lane: 'qa', stepType: 'workflow_qa', outcome: 'needs_repair', failureClass: 'infra', blocker: 'Chrome executable missing.', evidenceHash: 'chrome-missing' }
-		],
-		current: { lane: 'qa', stepType: 'workflow_qa', outcome: 'needs_repair', failureClass: 'infra', blocker: 'Chrome executable missing.', evidenceHash: 'chrome-missing' },
-		maxSameFailureRepeats
-	});
-	const infraDirective = buildResolveIOAIManagerRecoveryExecutionDirective({
-		action: infraPolicy.recoveryAction,
-		current: { lane: 'qa', stepType: 'workflow_qa', outcome: 'needs_repair', failureClass: 'infra', blocker: 'Chrome executable missing.', evidenceHash: 'chrome-missing' },
-		surface
-	});
-	cases.push(replayCaseFromDirective({
-		caseId: 'infra_routes_to_infra_repair',
-		surface,
-		action: infraPolicy.action,
-		reason: infraPolicy.reason,
-		directive: infraDirective,
-		expectedSafeAutoDispatch: true,
-		pass: infraPolicy.action === 'retry_infra'
-			&& infraPolicy.recoveryPlan.recoveryClass === 'infra_repair'
-			&& infraDirective.dispatchAction === 'run_infra_repair'
-			&& infraDirective.canRunProductRepair === false,
-		details: { recoveryClass: infraPolicy.recoveryPlan.recoveryClass }
-	}));
-	const releasePlan = buildResolveIOAIManagerRecoveryPlan({
-		action: 'continue',
-		reason: 'publish failed after business proof',
-		failureClass: 'release',
-		lane: 'publish',
-		stepType: 'test_deploy',
-		blocker: 'Domain publish failed for the current artifact.'
-	});
-	const releaseCurrent = {
-		lane: 'publish',
-		stepType: 'test_deploy',
-		outcome: 'needs_repair',
-		failureClass: 'release',
-		blocker: 'Domain publish failed for the current artifact.',
-		evidenceHash: 'release-domain-publish-failed',
-		artifactPaths: ['runner-evidence/release-status.json']
-	};
-	const releaseDirective = buildReplayDirectiveFromPlan({
-		surface,
-		plan: releasePlan,
-		current: releaseCurrent
-	});
-	cases.push(replayCaseFromDirective({
-		caseId: 'release_uses_hotfix_first_repair',
-		surface,
-		action: 'continue',
-		reason: 'publish failed after business proof',
-		directive: releaseDirective,
-		expectedSafeAutoDispatch: includeReleaseRepair,
-		pass: releasePlan.recoveryClass === 'release_repair'
-			&& releaseDirective.dispatchAction === 'run_release_repair'
-			&& releaseDirective.releasePolicy?.policy === 'hotfix_first'
-			&& releaseDirective.releasePolicy?.fullDeployAllowed === false
-			&& releaseDirective.canRunProductRepair === false,
-		details: { recoveryClass: releasePlan.recoveryClass }
-	}));
-	const journeyPlan = buildResolveIOAIManagerRecoveryPlan({
-		action: 'continue',
-		reason: 'journey contract missing first next last',
-		failureClass: 'journey',
-		lane: 'plan',
-		stepType: 'journey_contract',
-		blocker: 'Journey contract does not map the hub CTA to an action.'
-	});
-	const journeyDirective = buildReplayDirectiveFromPlan({
-		surface,
-		plan: journeyPlan,
-		current: {
-			lane: 'plan',
-			stepType: 'journey_contract',
-			outcome: 'needs_repair',
-			failureClass: 'journey',
-			blocker: 'Journey contract does not map the hub CTA to an action.',
-			evidenceHash: 'journey-contract-invalid'
-		}
-	});
-	cases.push(replayCaseFromDirective({
-		caseId: 'journey_repair_is_safe_only_for_aicoder_surfaces',
-		surface,
-		action: 'continue',
-		reason: 'journey contract missing first next last',
-		directive: journeyDirective,
-		expectedSafeAutoDispatch: includeJourneyContractRepair,
-		pass: journeyPlan.recoveryClass === 'journey_contract_repair'
-			&& journeyDirective.dispatchAction === 'run_journey_contract_repair'
-			&& journeyDirective.canRunProductRepair === false,
-		details: { recoveryClass: journeyPlan.recoveryClass }
-	}));
-	const weakPolicy = decideResolveIOAIManagerPolicy({
-		history: [
-			{ lane: 'repair', stepType: 'repair', outcome: 'needs_repair', failureClass: 'product_code', blocker: 'Save action still throws TypeError.', evidenceHash: 'save-before' },
-			{ lane: 'repair', stepType: 'repair', outcome: 'needs_repair', failureClass: 'product_code', blocker: 'Save action still throws TypeError.', evidenceHash: 'renamed-hash-only' }
-		],
-		current: { lane: 'repair', stepType: 'repair', outcome: 'needs_repair', failureClass: 'product_code', blocker: 'Save action still throws TypeError.', evidenceHash: 'renamed-hash-only' },
-		maxSameFailureRepeats
-	});
-	const weakDirective = buildResolveIOAIManagerRecoveryExecutionDirective({
-		action: weakPolicy.recoveryAction,
-		current: { lane: 'repair', stepType: 'repair', outcome: 'needs_repair', failureClass: 'product_code', blocker: 'Save action still throws TypeError.', evidenceHash: 'renamed-hash-only' },
-		surface
-	});
-	cases.push(replayCaseFromDirective({
-		caseId: 'weak_hash_only_evidence_stays_parked',
-		surface,
-		action: weakPolicy.action,
-		reason: weakPolicy.reason,
-		directive: weakDirective,
-		expectedSafeAutoDispatch: true,
-		pass: weakPolicy.action === 'park_repeated_failure'
-			&& weakPolicy.materialEvidence === false
-			&& weakPolicy.loopBudgetShouldReset === false
-			&& weakDirective.dispatchAction === 'run_evidence_probe',
-		loopBudgetShouldReset: weakPolicy.loopBudgetShouldReset,
-		materialEvidence: weakPolicy.materialEvidence,
-		evidenceStrength: weakPolicy.evidenceStrength,
-		details: { evidenceSignals: weakPolicy.evidenceSignals }
-	}));
-	const materialPolicy = decideResolveIOAIManagerPolicy({
-		history: [
-			{ lane: 'repair', stepType: 'repair', outcome: 'needs_repair', failureClass: 'product_code', blocker: 'Save action still throws TypeError.', evidenceHash: 'save-before', artifactPaths: ['qa/save-before.log'] },
-			{
-				lane: 'repair',
-				stepType: 'repair',
-				outcome: 'needs_repair',
-				failureClass: 'product_code',
-				blocker: 'Save action still throws TypeError.',
-				summary: 'New DOM trace proves the click reaches the method with an undefined id.',
-				evidenceHash: 'save-dom-trace',
-				artifactPaths: ['qa/save-before.log', 'qa/save-dom-trace.json']
-			}
-		],
-		current: {
-			lane: 'repair',
-			stepType: 'repair',
-			outcome: 'needs_repair',
-			failureClass: 'product_code',
-			blocker: 'Save action still throws TypeError.',
-			summary: 'New DOM trace proves the click reaches the method with an undefined id.',
-			evidenceHash: 'save-dom-trace',
-			artifactPaths: ['qa/save-before.log', 'qa/save-dom-trace.json']
-		},
-		maxSameFailureRepeats
-	});
-	cases.push({
-		caseId: 'material_evidence_resets_loop_budget',
-		surface,
-		pass: materialPolicy.action === 'continue'
-			&& materialPolicy.materialEvidence === true
-			&& materialPolicy.loopBudgetShouldReset === true,
-		action: materialPolicy.action,
-		reason: materialPolicy.reason,
-		recoveryClass: materialPolicy.recoveryPlan.recoveryClass,
-		dispatchAction: materialPolicy.recoveryAction.mode,
-		safeAutoDispatch: false,
-		expectedSafeAutoDispatch: false,
-		productRepairAllowed: materialPolicy.recoveryAction.productRepairAllowed,
-		loopBudgetShouldReset: materialPolicy.loopBudgetShouldReset,
-		materialEvidence: materialPolicy.materialEvidence,
-		evidenceStrength: materialPolicy.evidenceStrength,
-		details: { evidenceSignals: materialPolicy.evidenceSignals }
-	});
-	const productPlan = buildResolveIOAIManagerRecoveryPlan({
-		action: 'continue',
-		reason: 'business proof still failing',
-		failureClass: 'product_code',
-		lane: 'repair',
-		stepType: 'repair',
-		blocker: 'Save action still throws TypeError.',
-		productRepairFailure: true
-	});
-	const productDirective = buildReplayDirectiveFromPlan({
-		surface,
-		plan: productPlan,
-		current: {
-			lane: 'repair',
-			stepType: 'repair',
-			outcome: 'needs_repair',
-			failureClass: 'product_code',
-			blocker: 'Save action still throws TypeError.',
-			evidenceHash: 'save-product-repair'
-		}
-	});
-	const productSafe = isResolveIOAIManagerSafeAutoDispatch({
-		dispatchAction: productDirective.dispatchAction,
-		directive: productDirective,
-		includeProductRepair: input.includeProductRepair === true
-	});
-	cases.push({
-		caseId: 'product_repair_requires_explicit_operator_policy',
-		surface,
-		pass: productPlan.recoveryClass === 'product_code_repair'
-			&& productDirective.dispatchAction === 'run_targeted_product_repair'
-			&& productSafe === false,
-		action: 'continue',
-		reason: 'business proof still failing',
-		recoveryClass: productPlan.recoveryClass,
-		dispatchAction: productDirective.dispatchAction,
-		safeAutoDispatch: productSafe,
-		expectedSafeAutoDispatch: false,
-		productRepairAllowed: productDirective.canRunProductRepair,
-		loopBudgetShouldReset: false,
-		materialEvidence: false,
-		evidenceStrength: 'none',
-		details: { phase: productDirective.phase, allowed: productDirective.allowed }
-	});
-	const duplicateReleasePolicy = buildResolveIOAIManagerHotfixFirstReleasePolicy({
-		surface,
-		deployFingerprint: `${surface}-artifact-sha`,
-		lastDeployFingerprint: `${surface}-artifact-sha`,
-		deployStatus: 'completed',
-		publishStatus: 'published'
-	});
-	cases.push({
-		caseId: 'duplicate_release_fingerprint_blocks_full_deploy',
-		surface,
-		pass: duplicateReleasePolicy.recommendedAction === 'block_duplicate_deploy'
-			&& duplicateReleasePolicy.duplicateDeployBlocked === true
-			&& duplicateReleasePolicy.fullDeployAllowed === false,
-		action: duplicateReleasePolicy.recommendedAction,
-		reason: duplicateReleasePolicy.reason,
-		recoveryClass: 'release_repair',
-		dispatchAction: 'run_release_repair',
-		safeAutoDispatch: includeReleaseRepair,
-		expectedSafeAutoDispatch: includeReleaseRepair,
-		productRepairAllowed: false,
-		loopBudgetShouldReset: false,
-		materialEvidence: false,
-		evidenceStrength: 'none',
-		hotfixFirst: true,
-		fullDeployAllowed: duplicateReleasePolicy.fullDeployAllowed,
-		details: { releasePolicy: duplicateReleasePolicy }
-	});
-	return cases;
-}