@resolveio/server-lib 22.3.174 → 22.3.176

package/src/util/ai-run-evidence-adapters.ts

@@ -0,0 +1,3292 @@
+import {
+	AIRun,
+	AIRunCost,
+	AIRunEvent,
+	AIRunGateResult,
+	AIQaArtifact,
+	AIQaBusinessAssertion,
+	AIQaCompileResult,
+	AIQaInfraCheck,
+	AIQaRun,
+	AIQaRouteProbe,
+	buildAIRun,
+	buildAIRunCost,
+	buildAIQaRun,
+	normalizeOpenAIUsageRowsForCosting
+} from './ai-run-evidence';
+import {
+	evaluateResolveIOAICoderWorkflowProofReadiness,
+	ResolveIOAICoderJourneyContractValidationResult,
+	ResolveIOAICoderWorkflowProofReadiness,
+	validateResolveIOAICoderJourneyContract
+} from './aicoder-runner-v6';
+import {
+	decideResolveIOAIManagerPolicy,
+	ResolveIOAIManagerFailureRecord,
+	validateResolveIOAIManagerHotfixEvidence
+} from './ai-runner-manager-policy';
+import {
+	buildResolveIOSupportDiagnosisEvidencePack,
+	validateResolveIOSupportDiagnosisGate
+} from './support-runner-v5';
+
+export interface SupportAIRunAdapterInput {
+	ticket?: Record<string, any>;
+	job?: Record<string, any>;
+	versions?: Array<Record<string, any>>;
+	buildPlans?: Array<Record<string, any>>;
+	aiJobs?: Array<Record<string, any>>;
+	taskEvents?: Array<Record<string, any>>;
+	usageLedger?: Array<Record<string, any>>;
+	commits?: Array<Record<string, any>>;
+	qaEvidence?: Record<string, any>;
+	now?: Date | string;
+}
+
+export interface AICoderAIRunAdapterInput {
+	app?: Record<string, any>;
+	job?: Record<string, any>;
+	logs?: Array<Record<string, any>>;
+	usageLedger?: Array<Record<string, any>>;
+	commits?: Array<Record<string, any>>;
+	qaEvidence?: Record<string, any>;
+	now?: Date | string;
+}
+
+export interface AssistantAIRunAdapterInput {
+	runId?: string;
+	requestId?: string;
+	messageId?: string;
+	conversation?: Record<string, any>;
+	messages?: Array<Record<string, any>>;
+	issueReports?: Array<Record<string, any>>;
+	usageLedger?: Array<Record<string, any>>;
+	correctnessChecks?: Array<Record<string, any>>;
+	answerQuality?: Record<string, any>;
+	now?: Date | string;
+}
+
+export type AssistantAnswerQualityStatus =
+	| 'ready'
+	| 'missing_data_source'
+	| 'date_incorrect'
+	| 'missing_date_window'
+	| 'illegal_query_shape'
+	| 'missing_query_proof'
+	| 'query_error'
+	| 'permission_error'
+	| 'no_data_unverified'
+	| 'missing_citations'
+	| 'low_confidence'
+	| 'missing_next_action'
+	| 'incorrect'
+	| 'blocked';
+
+export interface AssistantAnswerQualityInput {
+	answerQuality?: Record<string, any>;
+	correctnessChecks?: Array<Record<string, any>>;
+	now?: Date | string;
+}
+
+export interface AssistantAnswerQualityDecision {
+	ready: boolean;
+	status: AssistantAnswerQualityStatus;
+	reason: string;
+	blockers: string[];
+	queryStatus: 'ok' | 'no_data' | 'query_error' | 'permission_error' | 'unknown';
+	confidenceLevel: 'high' | 'medium' | 'low' | 'unknown';
+	dateBasis?: string;
+	expectedCurrentDate?: string;
+	dateWindowRequired: boolean;
+	dateWindowPresent: boolean;
+	dateWindow?: {
+		startDate?: string;
+		endDate?: string;
+		mode?: string;
+		months?: number;
+	};
+	noDataConfirmed: boolean;
+	legalQueryShape: boolean;
+	citationRefs: string[];
+	queryEvidenceRequired: boolean;
+	queryEvidencePresent: boolean;
+	queryEvidenceRefs: string[];
+	queryExecutionCount: number;
+	nextActions: string[];
+	evidenceRefs: string[];
+	failedChecks: string[];
+	recordedAt: string;
+}
+
+function cleanText(value: any, max = 1000): string {
+	return String(value || '').replace(/\s+/g, ' ').trim().slice(0, max);
+}
+
+function idText(value: any, max = 160): string | undefined {
+	const normalized = cleanText(value, max);
+	return normalized || undefined;
+}
+
+function asArray<T = any>(value: any): T[] {
+	return Array.isArray(value) ? value : [];
+}
+
+function cleanStringList(value: any, limit = 40, max = 500): string[] {
+	return asArray<any>(value)
+		.map((entry) => cleanText(entry, max))
+		.filter(Boolean)
+		.slice(0, limit);
+}
+
+function plainObject(value: any): Record<string, any> {
+	return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function firstText(source: Record<string, any> | undefined, fields: string[], max = 1000): string | undefined {
+	for (const field of fields) {
+		const value = source?.[field];
+		const normalized = idText(value, max);
+		if (normalized) {
+			return normalized;
+		}
+	}
+	return undefined;
+}
+
+function dateValue(source: Record<string, any> | undefined, fields: string[]): Date | string | undefined {
+	for (const field of fields) {
+		const value = source?.[field];
+		if (value) {
+			return value;
+		}
+	}
+	return undefined;
+}
+
+function addSourceId(sourceIds: Record<string, string>, key: string, value: any): void {
+	const normalized = idText(value);
+	if (normalized) {
+		sourceIds[key] = normalized;
+	}
+}
+
+function pushEvent(events: AIRunEvent[], event: AIRunEvent): void {
+	const message = cleanText(event.message, 1800);
+	const metadata = event.metadata || {};
+	if (!message && !Object.keys(metadata).length && !event.artifactPaths?.length) {
+		return;
+	}
+	events.push({
+		...event,
+		message,
+		artifactPaths: asArray<string>(event.artifactPaths).filter(Boolean).slice(0, 20)
+	});
+}
+
+function eventDate(record: Record<string, any>): Date | string | undefined {
+	return dateValue(record, ['recordedAt', 'createdAt', 'updatedAt', 'timestamp', 'time', 'date']);
+}
+
+function normalizeManagerFailureRecord(value: any, fallback: Partial<ResolveIOAIManagerFailureRecord> = {}): ResolveIOAIManagerFailureRecord | undefined {
+	const entry = plainObject(value);
+	if (!Object.keys(entry).length && !Object.keys(fallback).length) {
+		return undefined;
+	}
+	const blocker = cleanText(entry.blocker || entry.reason || entry.summary || entry.message || fallback.blocker || fallback.summary, 1200);
+	const failureClass = cleanText(entry.failureClass || entry.failure_class || entry.class || fallback.failureClass, 120);
+	const evidenceHash = cleanText(entry.evidenceHash || entry.evidence_hash || entry.hash || fallback.evidenceHash, 180);
+	const blockerFingerprint = cleanText(entry.blockerFingerprint || entry.blocker_fingerprint || fallback.blockerFingerprint, 180);
+	const lane = cleanText(entry.lane || fallback.lane || 'support', 80);
+	const stepType = cleanText(entry.stepType || entry.step_type || entry.type || fallback.stepType || 'support_step', 80);
+	const outcome = cleanText(entry.outcome || entry.status || entry.result || fallback.outcome || 'needs_repair', 80);
+	if (!blocker && !failureClass && !evidenceHash && !blockerFingerprint) {
+		return undefined;
+	}
+	return {
+		lane,
+		stepType,
+		outcome,
+		failureClass: failureClass || undefined,
+		blocker: blocker || undefined,
+		summary: cleanText(entry.summary || entry.message || fallback.summary, 1200) || undefined,
+		blockerFingerprint: blockerFingerprint || undefined,
+		evidenceHash: evidenceHash || undefined,
+		changedFiles: cleanStringList(entry.changedFiles || entry.changed_files || fallback.changedFiles, 80, 500),
+		artifactPaths: cleanStringList(entry.artifactPaths || entry.artifact_paths || entry.artifacts || fallback.artifactPaths, 80, 500)
+	};
+}
+
+function supportManagerFailureRecords(job: Record<string, any>, evidence: Record<string, any>): ResolveIOAIManagerFailureRecord[] {
+	const records: ResolveIOAIManagerFailureRecord[] = [];
+	const pushRecord = (value: any, fallback: Partial<ResolveIOAIManagerFailureRecord> = {}): void => {
+		const record = normalizeManagerFailureRecord(value, fallback);
+		if (record) {
+			records.push(record);
+		}
+	};
+	for (const entry of asArray<any>(job.supportV5StepHistory || job.support_v5_step_history || evidence.supportV5StepHistory || evidence.support_v5_step_history)) {
+		pushRecord(entry);
+	}
+	for (const entry of asArray<any>(job.supportV5FailureFingerprints || job.support_v5_failure_fingerprints || evidence.supportV5FailureFingerprints || evidence.support_v5_failure_fingerprints)) {
+		const fingerprint = plainObject(entry);
+		const count = Math.max(1, Math.min(8, Number(fingerprint.count || fingerprint.repeatedCount || fingerprint.repeated_count || 1) || 1));
+		const fallback = {
+			lane: cleanText(fingerprint.lane || 'support', 80),
+			stepType: cleanText(fingerprint.stepType || fingerprint.step_type || 'support_step', 80),
+			outcome: cleanText(fingerprint.outcome || 'needs_repair', 80),
+			failureClass: cleanText(fingerprint.failureClass || fingerprint.failure_class || fingerprint.class, 120),
+			blocker: cleanText(fingerprint.blocker || fingerprint.reason || fingerprint.summary, 1200),
+			blockerFingerprint: cleanText(fingerprint.blockerFingerprint || fingerprint.blocker_fingerprint, 180),
+			evidenceHash: cleanText(fingerprint.evidenceHash || fingerprint.evidence_hash, 180)
+		};
+		for (let index = 0; index < count; index += 1) {
+			pushRecord(fingerprint, fallback);
+		}
+	}
+	const currentFailure = evidenceObject(
+		job.supportV5CurrentFailure,
+		job.support_v5_current_failure,
+		job.supportV5RecoveryCurrent,
+		job.support_v5_recovery_current,
+		evidence.currentFailure,
+		evidence.current_failure
+	);
+	pushRecord(currentFailure);
+	return records.slice(-80);
+}
+
+function managerNoBlindLoopGateFromHistory(
+	history: ResolveIOAIManagerFailureRecord[],
+	budgetSource: Record<string, any>,
+	now?: Date | string
+): AIRunGateResult | undefined {
+	if (!history.length) {
+		return undefined;
+	}
+	const budget = plainObject(budgetSource);
+	const maxSameFailureRepeats = Math.max(1, Number(budget.maxRepeatedNoProgress || budget.max_repeated_no_progress || budget.maxSameFailureRepeats || budget.max_same_failure_repeats || 3) || 3);
+	const decision = decideResolveIOAIManagerPolicy({
+		history,
+		maxSameFailureRepeats
+	});
+	const parksRun = /^(park_repeated_failure|park_ping_pong|manual_handoff)$/.test(decision.action);
+	const status: AIRunGateResult['status'] = parksRun
+		? 'blocked'
+		: decision.action === 'retry_infra'
+			? 'warn'
+			: 'pass';
+	return {
+		key: 'manager_no_blind_loop_policy',
+		label: 'No-blind-loop manager policy',
+		status,
+		reason: decision.reason,
+		evidenceRefs: cleanStringList(decision.recoveryAction.requiredArtifacts, 20, 500),
+		recordedAt: isoNow(now),
+		metadata: {
+			action: decision.action,
+			failureClass: decision.failureClass,
+			blockerFingerprint: decision.blockerFingerprint,
+			evidenceHash: decision.evidenceHash,
+			sameFailureCount: decision.sameFailureCount,
+			pingPongCount: decision.pingPongCount,
+			newEvidence: decision.newEvidence,
+			materialEvidence: decision.materialEvidence,
+			evidenceStrength: decision.evidenceStrength,
+			evidenceSignals: decision.evidenceSignals,
+			loopBudgetShouldReset: decision.loopBudgetShouldReset,
+			productRepairFailure: decision.productRepairFailure,
+			recoveryClass: decision.recoveryPlan.recoveryClass,
+			allowedAction: decision.recoveryPlan.allowedAction,
+			dispatchAction: decision.recoveryAction.allowedDispatchAction,
+			evidenceOnly: decision.recoveryAction.evidenceOnly,
+			productRepairAllowed: decision.recoveryAction.productRepairAllowed,
+			expensiveModelAllowed: decision.recoveryAction.expensiveModelAllowed,
+			costCeilingUsd: decision.recoveryAction.costCeilingUsd,
+			requiresNewEvidence: decision.recoveryAction.retryPolicy?.requireNewEvidence === true,
+			nextCommands: decision.recoveryAction.nextCommands,
+			requiredEvidence: decision.recoveryAction.requiredArtifacts,
+			forbiddenActions: decision.recoveryPlan.forbiddenActions
+		}
+	};
+}
+
+function supportManagerNoBlindLoopGate(
+	job: Record<string, any>,
+	evidence: Record<string, any>,
+	now?: Date | string
+): AIRunGateResult | undefined {
+	return managerNoBlindLoopGateFromHistory(
+		supportManagerFailureRecords(job, evidence),
+		job.supportV5Budget || job.support_v5_budget || evidence.supportV5Budget || evidence.support_v5_budget,
+		now
+	);
+}
+
+function aicoderManagerFailureRecords(
+	app: Record<string, any>,
+	job: Record<string, any>,
+	evidence: Record<string, any>
+): ResolveIOAIManagerFailureRecord[] {
+	const records: ResolveIOAIManagerFailureRecord[] = [];
+	const pushRecord = (value: any, fallback: Partial<ResolveIOAIManagerFailureRecord> = {}): void => {
+		const record = normalizeManagerFailureRecord(value, {
+			lane: 'aicoder',
+			stepType: 'workflow_step',
+			...fallback
+		});
+		if (record) {
+			records.push(record);
+		}
+	};
+	const historySources = [
+		job.aicoderV6StepHistory,
+		job.aiCoderV6StepHistory,
+		job.aicoder_v6_step_history,
+		job.ai_coder_v6_step_history,
+		job.workflowStepHistory,
+		job.workflow_step_history,
+		job.stepHistory,
+		job.step_history,
+		job.managerFailureHistory,
+		job.manager_failure_history,
+		app.aicoderV6StepHistory,
+		app.aiCoderV6StepHistory,
+		app.aicoder_v6_step_history,
+		app.ai_coder_v6_step_history,
+		app.workflowStepHistory,
+		app.workflow_step_history,
+		evidence.aicoderV6StepHistory,
+		evidence.aiCoderV6StepHistory,
+		evidence.aicoder_v6_step_history,
+		evidence.ai_coder_v6_step_history,
+		evidence.workflowStepHistory,
+		evidence.workflow_step_history,
+		evidence.stepHistory,
+		evidence.step_history,
+		evidence.managerFailureHistory,
+		evidence.manager_failure_history
+	];
+	for (const source of historySources) {
+		for (const entry of asArray<any>(source)) {
+			pushRecord(entry);
+		}
+	}
+	const fingerprintSources = [
+		job.aicoderV6FailureFingerprints,
+		job.aiCoderV6FailureFingerprints,
+		job.aicoder_v6_failure_fingerprints,
+		job.ai_coder_v6_failure_fingerprints,
+		job.workflowFailureFingerprints,
+		job.workflow_failure_fingerprints,
+		job.failureFingerprints,
+		job.failure_fingerprints,
+		app.aicoderV6FailureFingerprints,
+		app.aiCoderV6FailureFingerprints,
+		app.aicoder_v6_failure_fingerprints,
+		app.ai_coder_v6_failure_fingerprints,
+		evidence.aicoderV6FailureFingerprints,
+		evidence.aiCoderV6FailureFingerprints,
+		evidence.aicoder_v6_failure_fingerprints,
+		evidence.ai_coder_v6_failure_fingerprints,
+		evidence.workflowFailureFingerprints,
+		evidence.workflow_failure_fingerprints,
+		evidence.failureFingerprints,
+		evidence.failure_fingerprints
+	];
+	for (const source of fingerprintSources) {
+		for (const entry of asArray<any>(source)) {
+			const fingerprint = plainObject(entry);
+			const count = Math.max(1, Math.min(8, Number(fingerprint.count || fingerprint.repeatedCount || fingerprint.repeated_count || 1) || 1));
+			const fallback = {
+				lane: cleanText(fingerprint.lane || 'aicoder', 80),
+				stepType: cleanText(fingerprint.stepType || fingerprint.step_type || 'workflow_step', 80),
+				outcome: cleanText(fingerprint.outcome || 'needs_repair', 80),
+				failureClass: cleanText(fingerprint.failureClass || fingerprint.failure_class || fingerprint.class, 120),
+				blocker: cleanText(fingerprint.blocker || fingerprint.reason || fingerprint.summary, 1200),
+				blockerFingerprint: cleanText(fingerprint.blockerFingerprint || fingerprint.blocker_fingerprint, 180),
+				evidenceHash: cleanText(fingerprint.evidenceHash || fingerprint.evidence_hash, 180)
+			};
+			for (let index = 0; index < count; index += 1) {
+				pushRecord(fingerprint, fallback);
+			}
+		}
+	}
+	const currentFailure = evidenceObject(
+		job.aicoderV6CurrentFailure,
+		job.aiCoderV6CurrentFailure,
+		job.aicoder_v6_current_failure,
+		job.ai_coder_v6_current_failure,
+		job.workflowCurrentFailure,
+		job.workflow_current_failure,
+		job.currentFailure,
+		job.current_failure,
+		evidence.aicoderV6CurrentFailure,
+		evidence.aiCoderV6CurrentFailure,
+		evidence.aicoder_v6_current_failure,
+		evidence.ai_coder_v6_current_failure,
+		evidence.workflowCurrentFailure,
+		evidence.workflow_current_failure,
+		evidence.currentFailure,
+		evidence.current_failure
+	);
+	pushRecord(currentFailure);
+	return records.slice(-80);
+}
+
+function aicoderManagerNoBlindLoopGate(
+	app: Record<string, any>,
+	job: Record<string, any>,
+	evidence: Record<string, any>,
+	now?: Date | string
+): AIRunGateResult | undefined {
+	return managerNoBlindLoopGateFromHistory(
+		aicoderManagerFailureRecords(app, job, evidence),
+		job.aicoderV6Budget
+			|| job.aiCoderV6Budget
+			|| job.aicoder_v6_budget
+			|| job.ai_coder_v6_budget
+			|| evidence.aicoderV6Budget
+			|| evidence.aiCoderV6Budget
+			|| evidence.aicoder_v6_budget
+			|| evidence.ai_coder_v6_budget
+			|| app.aicoderV6Budget
+			|| app.aiCoderV6Budget
+			|| app.aicoder_v6_budget
+			|| app.ai_coder_v6_budget
+			|| job.budget
+			|| evidence.budget,
+		now
+	);
+}
+
+function managerNoBlindLoopMetadata(gate: AIRunGateResult | undefined): Record<string, any> | undefined {
+	if (!gate) {
+		return undefined;
+	}
+	return {
+		action: cleanText(gate.metadata?.action, 120),
+		status: gate.status,
+		failureClass: cleanText(gate.metadata?.failureClass, 120),
+		sameFailureCount: Number(gate.metadata?.sameFailureCount || 0),
+		pingPongCount: Number(gate.metadata?.pingPongCount || 0),
+		newEvidence: gate.metadata?.newEvidence === true,
+		materialEvidence: gate.metadata?.materialEvidence === true,
+		evidenceStrength: cleanText(gate.metadata?.evidenceStrength, 120),
+		loopBudgetShouldReset: gate.metadata?.loopBudgetShouldReset === true,
+		dispatchAction: cleanText(gate.metadata?.dispatchAction, 160),
+		productRepairAllowed: gate.metadata?.productRepairAllowed === true,
+		expensiveModelAllowed: gate.metadata?.expensiveModelAllowed === true,
+		productRepairFailure: gate.metadata?.productRepairFailure === true,
+		requiresNewEvidence: gate.metadata?.requiresNewEvidence === true
+	};
+}
+
+function hotfixEvidenceCandidates(...sources: any[]): Record<string, any>[] {
+	const result: Record<string, any>[] = [];
+	const seen = new Set<string>();
+	const pushCandidate = (value: any): void => {
+		if (Array.isArray(value)) {
+			for (const entry of value) {
+				pushCandidate(entry);
+			}
+			return;
+		}
+		if (!value || typeof value !== 'object') {
+			return;
+		}
+		const nestedValues = [
+			value.hotfixEvidence,
+			value.hotfix_evidence,
+			value.releaseHotfixEvidence,
+			value.release_hotfix_evidence,
+			value.managerHotfixEvidence,
+			value.manager_hotfix_evidence,
+			value.backendHotfixEvidence,
+			value.backend_hotfix_evidence
+		].filter(Boolean);
+		if (nestedValues.length) {
+			for (const nestedValue of nestedValues) {
+				pushCandidate(nestedValue);
+			}
+			return;
+		}
+		if (!(value.channel || value.hotfixChannel || value.hotfix_channel)) {
+			return;
+		}
+		const key = JSON.stringify({
+			channel: value.channel || value.hotfixChannel || value.hotfix_channel,
+			host: value.target?.host || value.host,
+			path: value.target?.path || value.path || value.remotePath || value.remote_path,
+			checksum: value.remoteChecksumAfter || value.remote_checksum_after || value.remoteChecksum || value.remote_checksum
+		});
+		if (seen.has(key)) {
+			return;
+		}
+		seen.add(key);
+		result.push(value);
+	};
+	for (const source of sources) {
+		pushCandidate(source);
+	}
+	return result;
+}
+
+function hotfixEvidenceArtifactPaths(evidence: Record<string, any>, normalized: Record<string, any> | undefined): string[] {
+	return [
+		normalized?.compiledArtifactPath,
+		normalized?.builtDistPath,
+		normalized?.target?.artifactPath,
+		evidence.compiledArtifactPath,
+		evidence.compiled_artifact_path,
+		evidence.builtDistPath,
+		evidence.built_dist_path,
+		evidence.artifactPath,
+		evidence.artifact_path
+	].map((entry) => cleanText(entry, 500)).filter(Boolean).slice(0, 8);
+}
+
+function hotfixEvidenceGate(
+	evidence: Record<string, any>,
+	now?: Date | string
+): AIRunGateResult | undefined {
+	const validation = validateResolveIOAIManagerHotfixEvidence(evidence);
+	if (!validation.normalized && validation.status === 'missing') {
+		return undefined;
+	}
+	const status: AIRunGateResult['status'] = validation.valid
+		? (validation.fullDeployAllowed ? 'warn' : 'pass')
+		: validation.status === 'blocked'
+			? 'blocked'
+			: 'fail';
+	const reason = validation.valid
+		? validation.fullDeployAllowed
+			? 'Hotfix evidence allows exactly one full deploy after force/new-artifact proof.'
+			: 'Hotfix evidence is sufficient; rerun the smallest release gate before continuing.'
+		: validation.blockers.join('; ');
+	return {
+		key: 'hotfix_evidence',
+		label: 'Hotfix evidence',
+		status,
+		reason,
+		evidenceRefs: hotfixEvidenceArtifactPaths(evidence, validation.normalized as any),
+		recordedAt: isoNow(now || validation.normalized?.recordedAt),
+		metadata: {
+			channel: validation.channel,
+			nextAction: validation.nextAction,
+			fullDeployAllowed: validation.fullDeployAllowed,
+			fullDeployBlocked: validation.fullDeployBlocked,
+			hotfixSatisfied: validation.hotfixSatisfied,
+			blockers: validation.blockers,
+			githubCommitGuard: validation.githubCommitGuard,
+			target: validation.normalized?.target
+		}
+	};
+}
+
+function hotfixCommitProofGate(
+	evidence: Record<string, any>,
+	now?: Date | string
+): AIRunGateResult | undefined {
+	const validation = validateResolveIOAIManagerHotfixEvidence(evidence);
+	const guard = validation.githubCommitGuard;
+	if (!guard.required) {
+		return undefined;
+	}
+	const status: AIRunGateResult['status'] = guard.passed
+		? 'pass'
+		: guard.status === 'invalid'
+			? 'fail'
+			: 'blocked';
+	return {
+		key: 'hotfix_commit_proof',
+		label: 'Hotfix GitHub commit proof',
+		status,
+		reason: guard.passed
+			? 'Hotfix has matching sourceCommitSha, GitHub commit URL, and passed gitPushStatus/gitCommitStatus.'
+			: (guard.blockers.join('; ') || 'Manager hotfix is blocked until sourceCommitSha, githubCommitUrl, and passed gitPushStatus prove the hotfix is pushed to GitHub.'),
+		evidenceRefs: cleanStringList([guard.githubCommitUrl], 1, 500),
+		recordedAt: isoNow(now || validation.normalized?.recordedAt),
+		metadata: {
+			channel: guard.channel || validation.channel,
+			status: guard.status,
+			passed: guard.passed,
+			managerMustCommitBeforeHotfix: guard.managerMustCommitBeforeHotfix,
+			sourceCommitSha: guard.sourceCommitSha,
+			githubCommitUrl: guard.githubCommitUrl,
+			githubCommitSha: guard.githubCommitSha,
+			gitCommitStatus: guard.gitCommitStatus,
+			gitPushStatus: guard.gitPushStatus,
+			blockers: guard.blockers,
+			nextCommands: guard.nextCommands,
+			requiredEvidence: guard.requiredEvidence
+		}
+	};
+}
+
+function collectHotfixEvidenceEvents(
+	sources: any[],
+	events: AIRunEvent[],
+	gates: AIRunGateResult[],
+	now?: Date | string
+): void {
+	for (const evidence of hotfixEvidenceCandidates(...sources)) {
+		const validation = validateResolveIOAIManagerHotfixEvidence(evidence);
+		if (!validation.normalized && validation.status === 'missing') {
+			continue;
+		}
+		const artifactPaths = hotfixEvidenceArtifactPaths(evidence, validation.normalized as any);
+		pushEvent(events, {
+			type: 'hotfix',
+			category: validation.channel || 'hotfix',
+			message: validation.valid
+				? `Hotfix evidence recorded for ${validation.channel}.`
+				: `Incomplete hotfix evidence for ${validation.channel || 'unknown channel'}.`,
+			artifactPaths,
+			recordedAt: validation.normalized?.recordedAt || eventDate(evidence),
+			metadata: {
+				status: validation.status,
+				nextAction: validation.nextAction,
+				fullDeployAllowed: validation.fullDeployAllowed,
+				fullDeployBlocked: validation.fullDeployBlocked,
+				hotfixSatisfied: validation.hotfixSatisfied,
+				blockers: validation.blockers,
+				githubCommitGuard: validation.githubCommitGuard,
+				target: validation.normalized?.target
+			}
+		});
+		const gate = hotfixEvidenceGate(evidence, now);
+		if (gate) {
+			gates.push(gate);
+		}
+		const commitProofGate = hotfixCommitProofGate(evidence, now);
+		if (commitProofGate) {
+			gates.push(commitProofGate);
+			pushEvent(events, {
+				type: 'log',
+				category: 'hotfix_commit_proof',
+				message: commitProofGate.reason,
+				artifactPaths: commitProofGate.evidenceRefs,
+				recordedAt: commitProofGate.recordedAt,
+				metadata: commitProofGate.metadata
+			});
+		}
+	}
+}
+
+function collectUsageEvents(entries: Array<Record<string, any>>, events: AIRunEvent[]): AIRunCost | undefined {
+	if (!entries.length) {
+		return undefined;
+	}
+	const normalizedEntries = normalizeOpenAIUsageRowsForCosting(entries);
+	for (const entry of normalizedEntries) {
+		pushEvent(events, {
+			type: 'usage',
+			category: cleanText(entry.category || entry.kind || entry.phase, 160) || 'usage',
+			message: cleanText(entry.summary || entry.description || entry.model || 'Model usage recorded.', 800),
+			recordedAt: eventDate(entry),
+			metadata: {
+				model: entry.model,
+				inputTokens: entry.inputTokens ?? entry.input_tokens,
+				outputTokens: entry.outputTokens ?? entry.output_tokens,
+				totalTokens: entry.totalTokens ?? entry.total_tokens,
+				estimatedUsd: entry.estimatedUsd ?? entry.cost_estimate,
+				usageSource: entry.usage_source ?? entry.usageSource,
+				usageSurface: entry.usage_surface ?? entry.usageSurface,
+				usagePhase: entry.usage_phase ?? entry.usagePhase,
+				costBasis: entry.cost_basis ?? entry.costBasis,
+				isManual: entry.is_manual ?? entry.isManual,
+				isUntracked: entry.is_untracked ?? entry.isUntracked,
+				untrackedReason: entry.untracked_reason ?? entry.untrackedReason
+			}
+		});
+	}
+	return buildAIRunCost(entries);
+}
+
+function collectCommitEvents(commits: Array<Record<string, any>>, events: AIRunEvent[]): void {
+	for (const commit of commits.slice(0, 80)) {
+		pushEvent(events, {
+			type: 'git_commit',
+			message: cleanText(commit.message || commit.subject || commit.title || commit.hash || commit.sha, 1200),
+			recordedAt: eventDate(commit),
+			metadata: {
+				sha: commit.sha || commit.hash,
+				branch: commit.branch,
+				author: commit.author
+			}
+		});
+	}
+}
+
+function statusFromBoolean(value: any, fallback?: string): string | undefined {
+	if (value === true) {
+		return 'pass';
+	}
+	if (value === false) {
+		return 'fail';
+	}
+	return fallback;
+}
+
+function collectArtifacts(evidence: Record<string, any> | undefined): AIQaArtifact[] {
+	const artifacts: AIQaArtifact[] = [];
+	for (const entry of asArray<any>(evidence?.artifacts)) {
+		artifacts.push({
+			type: entry.type || 'other',
+			path: cleanText(entry.path || entry.file || entry.artifactPath, 500),
+			url: cleanText(entry.url, 500),
+			title: cleanText(entry.title || entry.name, 300),
+			caption: cleanText(entry.caption || entry.message, 800),
+			metadata: entry.metadata
+		});
+	}
+	const screenshots = asArray<any>(evidence?.screenshots || evidence?.qaScreenshots || evidence?.browserScreenshots);
+	for (const screenshot of screenshots.slice(0, 40)) {
+		if (typeof screenshot === 'string') {
+			artifacts.push({ type: 'screenshot', path: screenshot });
+		} else {
+			artifacts.push({
+				type: 'screenshot',
+				path: cleanText(screenshot.path || screenshot.file, 500),
+				url: cleanText(screenshot.url, 500),
+				title: cleanText(screenshot.title || screenshot.route, 300),
+				caption: cleanText(screenshot.caption || screenshot.message, 800),
+				metadata: screenshot.metadata
+			});
+		}
+	}
+	const artifactRefs = [
+		...asArray<any>(evidence?.artifactPaths),
+		...asArray<any>(evidence?.artifact_paths),
+		...asArray<any>(evidence?.runnerEvidenceArtifacts),
+		...asArray<any>(evidence?.runner_evidence_artifacts),
+		...asArray<any>(evidence?.supportQaArtifacts),
+		...asArray<any>(evidence?.support_qa_artifacts),
+		...asArray<any>(evidence?.qa_artifacts)
+	];
+	for (const entry of artifactRefs.slice(0, 60)) {
+		if (typeof entry === 'string') {
+			artifacts.push({ type: 'other', path: cleanText(entry, 500) });
+		}
+		else if (entry && typeof entry === 'object') {
+			artifacts.push({
+				type: entry.type || 'other',
+				path: cleanText(entry.path || entry.file || entry.artifactPath || entry.artifact_path, 500),
+				url: cleanText(entry.url, 500),
+				title: cleanText(entry.title || entry.name || entry.label, 300),
+				caption: cleanText(entry.caption || entry.message || entry.summary, 800),
+				metadata: entry.metadata
+			});
+		}
+	}
+	return artifacts;
+}
+
+function collectInfraChecks(evidence: Record<string, any> | undefined): AIQaInfraCheck[] {
+	const checks: AIQaInfraCheck[] = [];
+	for (const entry of asArray<any>(evidence?.infraChecks || evidence?.preflightChecks)) {
+		checks.push({
+			name: cleanText(entry.name || entry.check || entry.key, 160) || 'infra_check',
+			status: entry.status || statusFromBoolean(entry.passed),
+			message: cleanText(entry.message || entry.error || entry.reason, 1000),
+			path: cleanText(entry.path, 500),
+			durationMs: Number(entry.durationMs ?? entry.duration_ms) || undefined,
+			metadata: entry.metadata,
+			checkedAt: eventDate(entry)
+		});
+	}
+	if (evidence?.preflightStatus) {
+		checks.push({
+			name: 'qa_preflight',
+			status: evidence.preflightStatus,
+			message: cleanText(evidence.preflightMessage || evidence.preflightReason, 1000),
+			path: cleanText(evidence.preflightArtifactPath || evidence.preflightPath, 500)
+		});
+	}
+	return checks;
+}
+
+function collectCompileResult(evidence: Record<string, any> | undefined): AIQaCompileResult | undefined {
+	const build = evidence?.compile || evidence?.build || evidence?.buildEvidence || evidence?.buildResult;
+	if (!build && evidence?.compileStatus === undefined && evidence?.buildStatus === undefined) {
+		return undefined;
+	}
+	const status = build?.status
+		|| evidence?.compileStatus
+		|| evidence?.buildStatus
+		|| statusFromBoolean(build?.passed ?? build?.allExpectedPassed ?? evidence?.buildPassed);
+	return {
+		status,
+		command: cleanText(build?.command || evidence?.buildCommand, 500),
+		artifactPath: cleanText(build?.artifactPath || build?.logPath || evidence?.buildLogPath, 500),
+		message: cleanText(build?.message || build?.error || evidence?.buildMessage, 1000),
+		durationMs: Number(build?.durationMs ?? build?.duration_ms) || undefined,
+		staleEvidence: build?.staleEvidence === true || evidence?.staleBuildEvidence === true,
+		recordedAt: eventDate(build || evidence || {})
+	};
+}
+
+function collectRouteProbes(evidence: Record<string, any> | undefined): AIQaRouteProbe[] {
+	const probes: AIQaRouteProbe[] = [];
+	const rows = [
+		...asArray<any>(evidence?.routeProbes),
+		...asArray<any>(evidence?.route_probes),
+		...asArray<any>(evidence?.routes),
+		...asArray<any>(evidence?.browserRoutes),
+		...asArray<any>(evidence?.browser_routes),
+		...asArray<any>(evidence?.workflowProbes),
+		...asArray<any>(evidence?.workflow_probes)
+	];
+	const directProbe = plainObject(evidence?.routeProbe || evidence?.route_probe || evidence?.workflowProbe || evidence?.workflow_probe);
+	if (Object.keys(directProbe).length) {
+		rows.push(directProbe);
+	}
+	for (const entry of rows) {
+		probes.push({
+			route: cleanText(entry.route || entry.path || entry.url, 500) || '/',
+			status: entry.status || statusFromBoolean(entry.passed),
+			screenshot: cleanText(entry.screenshot || entry.screenshotPath, 500),
+			caption: cleanText(entry.caption || entry.message, 1000),
+			shellOnly: entry.shellOnly === true,
+			authenticated: entry.authenticated === true,
+			consoleErrors: asArray<string>(entry.consoleErrors),
+			networkErrors: asArray<string>(entry.networkErrors),
+			message: cleanText(entry.message || entry.error, 1000),
+			recordedAt: eventDate(entry)
+		});
+	}
+	const screenshots = asArray<any>(evidence?.screenshots || evidence?.qaScreenshots || evidence?.browserScreenshots);
+	for (const screenshot of screenshots.slice(0, 20)) {
+		if (typeof screenshot === 'string') {
+			probes.push({ route: '/', status: 'pass', screenshot, caption: 'Historical browser screenshot recorded.' });
+		} else if (screenshot.route || screenshot.path || screenshot.url || screenshot.screenshot || screenshot.file) {
+			probes.push({
+				route: cleanText(screenshot.route || screenshot.url || screenshot.path, 500) || '/',
+				status: screenshot.status || statusFromBoolean(screenshot.passed, 'pass'),
+				screenshot: cleanText(screenshot.screenshot || screenshot.screenshotPath || screenshot.file || screenshot.path, 500),
+				caption: cleanText(screenshot.caption || screenshot.message, 1000),
+				shellOnly: screenshot.shellOnly === true,
+				authenticated: screenshot.authenticated === true,
+				recordedAt: eventDate(screenshot)
+			});
+		}
+	}
+	return probes;
+}
+
+function collectBusinessAssertions(evidence: Record<string, any> | undefined): AIQaBusinessAssertion[] {
+	const assertions: AIQaBusinessAssertion[] = [];
+	const rows = [
+		...asArray<any>(evidence?.businessAssertions),
+		...asArray<any>(evidence?.business_assertions),
+		...asArray<any>(evidence?.workflowAssertions),
+		...asArray<any>(evidence?.workflow_assertions),
+		...asArray<any>(evidence?.assertions),
+		...asArray<any>(evidence?.qaRows),
+		...asArray<any>(evidence?.qa_rows),
+		...asArray<any>(evidence?.rows),
+		...asArray<any>(evidence?.supportQaAssertions),
+		...asArray<any>(evidence?.support_qa_assertions),
+		...asArray<any>(evidence?.aiQaBusinessAssertions),
+		...asArray<any>(evidence?.ai_qa_business_assertions)
+	];
+	for (const entry of rows) {
+		assertions.push({
+			assertion: cleanText(entry.assertion || entry.name || entry.label || entry.workflow || entry.expected, 1000) || 'business assertion',
+			status: entry.status || entry.outcome || entry.result || statusFromBoolean(entry.passed),
+			workflow: cleanText(entry.workflow || entry.workflowName || entry.workflow_name, 400),
+			route: cleanText(entry.route || entry.url, 500),
+			action: cleanText(entry.action || entry.action_under_test || entry.actionUnderTest, 500),
+			expected: cleanText(entry.expected || entry.expected_business_state_change || entry.expectedBusinessStateChange, 1000),
+			observed: cleanText(entry.observed || entry.actual || entry.after || entry.after_state || entry.afterState, 1000),
+			dataProof: cleanText(entry.dataProof || entry.data_proof || entry.domProof || entry.dom_proof || entry.proof || entry.summary, 1400),
+			mongoDelta: plainObject(entry.mongoDelta || entry.mongo_delta),
+			artifactPaths: cleanStringList(entry.artifactPaths || entry.artifact_paths || entry.artifacts || entry.screenshots || (entry.screenshot ? [entry.screenshot] : []), 30, 500),
+			message: cleanText(entry.message || entry.error || entry.reason, 1000),
+			recordedAt: eventDate(entry),
+			metadata: {
+				...plainObject(entry.metadata),
+				...(entry.acceptanceBlocked === true || entry.acceptance_blocked === true ? { acceptanceBlocked: true } : {}),
+				...(entry.routeOnly === true || entry.route_only === true ? { routeOnly: true } : {})
+			}
+		});
+	}
+	if (!assertions.length && evidence?.qaRunOutcome === 'business_assertion_passed') {
+		assertions.push({
+			assertion: cleanText(evidence.aiRunOutcomeReason || evidence.reason || 'Historical business assertion passed.', 1000),
+			status: 'pass',
+			dataProof: cleanText(evidence.aiRunOutcomeReason || evidence.reason, 1400)
+		});
+	}
+	if (!assertions.length && evidence?.qaRunOutcome === 'business_assertion_failed') {
+		assertions.push({
+			assertion: cleanText(evidence.aiRunOutcomeReason || evidence.reason || 'Historical business assertion failed.', 1000),
+			status: 'fail',
+			observed: cleanText(evidence.aiRunOutcomeReason || evidence.reason, 1000)
+		});
+	}
+	return assertions;
+}
+
+function buildQaFromEvidence(evidence: Record<string, any> | undefined, now?: Date | string): AIQaRun {
+	return buildAIQaRun({
+		infraChecks: collectInfraChecks(evidence),
+		compile: collectCompileResult(evidence),
+		routeProbes: collectRouteProbes(evidence),
+		businessAssertions: collectBusinessAssertions(evidence),
+		artifacts: collectArtifacts(evidence),
+		now
+	});
+}
+
+function isoNow(value?: Date | string): string {
+	if (value instanceof Date) {
+		return value.toISOString();
+	}
+	if (value) {
+		const parsed = new Date(value);
+		if (!Number.isNaN(parsed.getTime())) {
+			return parsed.toISOString();
+		}
+	}
+	return new Date().toISOString();
+}
+
+function normalizeMatchText(value: any): string {
+	return cleanText(value, 3000)
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, ' ')
+		.replace(/\s+/g, ' ')
+		.trim();
+}
+
+function importantTokens(value: any): Set<string> {
+	const stopWords = new Set([
+		'the', 'and', 'that', 'with', 'from', 'after', 'before', 'when', 'then', 'this', 'must',
+		'should', 'will', 'only', 'into', 'have', 'has', 'are', 'was', 'were', 'been'
+	]);
+	return new Set(normalizeMatchText(value).split(' ')
+		.filter((token) => token.length >= 4 && !stopWords.has(token)));
+}
+
+function businessAssertionPassed(assertion: AIQaBusinessAssertion): boolean {
+	return /^(pass|passed|success|ok|done)$/i.test(cleanText(assertion.status, 40));
+}
+
+function supportAssertionMatchesDiagnosisProof(assertion: AIQaBusinessAssertion, proofPlan: Record<string, any>): boolean {
+	const metadata = assertion.metadata || {};
+	if (metadata.diagnosisProofPlanMatched === true || metadata.proofPlanMatched === true || metadata.supportDiagnosisProof === true) {
+		return true;
+	}
+	const requiredBusinessAssertion = proofPlan.business_assertion || proofPlan.businessAssertion;
+	const proofParts = [
+		requiredBusinessAssertion,
+		proofPlan.after,
+		proofPlan.data_assertion || proofPlan.dataAssertion,
+		proofPlan.artifact_expectation || proofPlan.artifactExpectation
+	].map((part) => normalizeMatchText(part)).filter((part) => part.length >= 16);
+	if (!proofParts.length) {
+		return true;
+	}
+	const assertionText = normalizeMatchText([
+		assertion.assertion,
+		assertion.workflow,
+		assertion.action,
+		assertion.expected,
+		assertion.observed,
+		assertion.dataProof,
+		assertion.message
+	].filter(Boolean).join(' '));
+	if (proofParts.some((part) => assertionText.includes(part))) {
+		return true;
+	}
+	const proofTokens = importantTokens([
+		requiredBusinessAssertion,
+		proofPlan.after,
+		proofPlan.data_assertion || proofPlan.dataAssertion
+	].filter(Boolean).join(' '));
+	const assertionTokens = importantTokens(assertionText);
+	if (!proofTokens.size) {
+		return true;
+	}
+	let overlap = 0;
+	for (const token of proofTokens) {
+		if (assertionTokens.has(token)) {
+			overlap += 1;
+		}
+	}
+	return overlap >= Math.min(4, Math.max(3, Math.ceil(proofTokens.size * 0.45)));
+}
+
+function supportDiagnosisProofGateResult(diagnosisGate: Record<string, any>, now?: Date | string): AIRunGateResult {
+	const proofPlan = diagnosisGate.proof_plan || diagnosisGate.proofPlan || {};
+	return {
+		key: 'support_diagnosis_business_proof',
+		label: 'Diagnosis proof plan',
+		status: 'blocked',
+		reason: 'Support business assertion did not map to the diagnosis proof_plan. Route proof or generic workflow proof cannot accept the ticket.',
+		evidenceRefs: [],
+		recordedAt: isoNow(now),
+		metadata: {
+			issueClass: cleanText(diagnosisGate.issue_class || diagnosisGate.issueClass, 120),
+			requiredBusinessAssertion: cleanText(proofPlan.business_assertion || proofPlan.businessAssertion, 1000),
+			requiredAfter: cleanText(proofPlan.after, 1000),
+			requiredDataAssertion: cleanText(proofPlan.data_assertion || proofPlan.dataAssertion, 1000)
+		}
+	};
+}
+
+const SUPPORT_ROOT_CAUSE_ENTRY_REQUIRED_FIELDS = [
+	'issue_case',
+	'issue_class',
+	'accepted_hypothesis',
+	'rejected_alternatives',
+	'failing_path',
+	'owner_files',
+	'proof_plan',
+	'evidence'
+];
+
+const SUPPORT_ROOT_CAUSE_ENTRY_ISSUE_CLASSES = [
+	'no_op_submit',
+	'missing_wrong_data',
+	'filter_query_mismatch',
+	'invoice_pdf_export',
+	'upload_import',
+	'route_auth_hydration',
+	'slow_query_performance'
+];
+
+function supportRootCauseEntryContractGate(contract: Record<string, any>, now?: Date | string): AIRunGateResult | undefined {
+	if (!contract || !Object.keys(contract).length) {
+		return undefined;
+	}
+	const requiredOutput = plainObject(contract.required_output || contract.requiredOutput);
+	const ownerPolicy = plainObject(contract.owner_file_policy || contract.ownerFilePolicy);
+	const businessProofPolicy = plainObject(contract.business_proof_policy || contract.businessProofPolicy);
+	const failurePolicy = plainObject(contract.failure_policy || contract.failurePolicy);
+	const probes = asArray<Record<string, any>>(contract.issue_class_probes || contract.issueClassProbes);
+	const requiredFields = cleanStringList(requiredOutput.required_fields || requiredOutput.requiredFields, 30, 160);
+	const issueClasses = probes.map((probe) => cleanText(probe.issue_class || probe.issueClass, 120)).filter(Boolean);
+	const missingRequiredFields = SUPPORT_ROOT_CAUSE_ENTRY_REQUIRED_FIELDS.filter((field) => !requiredFields.includes(field));
+	const missingIssueClasses = SUPPORT_ROOT_CAUSE_ENTRY_ISSUE_CLASSES.filter((issueClass) => !issueClasses.includes(issueClass));
+	const blockers: string[] = [];
+	if (!cleanText(contract.contract_id || contract.contractId, 160)) {
+		blockers.push('Root-cause entry contract is missing contract_id.');
+	}
+	if (cleanText(requiredOutput.object_key || requiredOutput.objectKey, 120) !== 'support_diagnosis_gate') {
+		blockers.push('Root-cause entry contract must require support_diagnosis_gate output.');
+	}
+	if (missingRequiredFields.length) {
+		blockers.push(`Root-cause entry contract missing required output fields: ${missingRequiredFields.join(', ')}.`);
+	}
+	const ownerFileMax = Number(ownerPolicy.max_files || ownerPolicy.maxFiles || 0);
+	if (!Number.isFinite(ownerFileMax) || ownerFileMax <= 0 || ownerFileMax > 12) {
+		blockers.push('Root-cause entry contract must cap owner_files to a small exact file set.');
+	}
+	if (ownerPolicy.edits_outside_owner_files_require_revised_diagnosis !== true && ownerPolicy.editsOutsideOwnerFilesRequireRevisedDiagnosis !== true) {
+		blockers.push('Root-cause entry contract must require revised diagnosis before edits outside owner_files.');
+	}
+	if (businessProofPolicy.requires_aiqa_business_assertion !== true && businessProofPolicy.requiresAiqaBusinessAssertion !== true) {
+		blockers.push('Root-cause entry contract must require AIQaBusinessAssertion business proof.');
+	}
+	if (businessProofPolicy.route_load_screenshot_scorecard_model_claim_not_acceptance !== true && businessProofPolicy.routeLoadScreenshotScorecardModelClaimNotAcceptance !== true) {
+		blockers.push('Root-cause entry contract must reject route-load/screenshot/scorecard/model-claim acceptance.');
+	}
+	if (failurePolicy.repeated_failure_without_new_evidence_parks_run !== true && failurePolicy.repeatedFailureWithoutNewEvidenceParksRun !== true) {
+		blockers.push('Root-cause entry contract must park repeated failures without new evidence.');
+	}
+	if (missingIssueClasses.length) {
+		blockers.push(`Root-cause entry contract missing issue-class probes: ${missingIssueClasses.join(', ')}.`);
+	}
+	const status: AIRunGateResult['status'] = blockers.length ? 'fail' : 'pass';
+	return {
+		key: 'support_root_cause_entry_contract',
+		label: 'Root-cause entry contract',
+		status,
+		reason: blockers.length
+			? blockers.join(' ')
+			: 'Support run has a structured root-cause-first entry contract with issue-class probes, owner-file policy, and business-proof policy.',
+		evidenceRefs: cleanStringList(businessProofPolicy.required_artifacts || businessProofPolicy.requiredArtifacts, 20, 500),
+		recordedAt: isoNow(now),
+		metadata: {
+			contractId: cleanText(contract.contract_id || contract.contractId, 160),
+			version: cleanText(contract.version, 120),
+			status: cleanText(contract.status, 120),
+			requiredOutputKey: cleanText(requiredOutput.object_key || requiredOutput.objectKey, 120),
+			requiredFields,
+			missingRequiredFields,
+			ownerFileMax,
+			requiresRevisedDiagnosisForOutOfScopeEdits: ownerPolicy.edits_outside_owner_files_require_revised_diagnosis === true || ownerPolicy.editsOutsideOwnerFilesRequireRevisedDiagnosis === true,
+			requiresBusinessAssertion: businessProofPolicy.requires_aiqa_business_assertion === true || businessProofPolicy.requiresAiqaBusinessAssertion === true,
+			routeOnlyAcceptanceRejected: businessProofPolicy.route_load_screenshot_scorecard_model_claim_not_acceptance === true || businessProofPolicy.routeLoadScreenshotScorecardModelClaimNotAcceptance === true,
+			issueClassProbeCount: issueClasses.length,
+			issueClasses,
+			missingIssueClasses
+		}
+	};
+}
+
+function applySupportDiagnosisProofGate(qa: AIQaRun, diagnosisGate: Record<string, any>, now?: Date | string): AIQaRun {
+	const proofPlan = diagnosisGate.proof_plan || diagnosisGate.proofPlan || {};
+	const requiredBusinessAssertion = cleanText(proofPlan.business_assertion || proofPlan.businessAssertion, 1000);
+	const requiredAfter = cleanText(proofPlan.after, 1000);
+	if (!Object.keys(proofPlan).length || (!requiredBusinessAssertion && !requiredAfter)) {
+		return qa;
+	}
+	const passedAssertions = qa.businessAssertions.filter(businessAssertionPassed);
+	if (!passedAssertions.length) {
+		return qa;
+	}
+	if (passedAssertions.some((assertion) => supportAssertionMatchesDiagnosisProof(assertion, proofPlan))) {
+		return qa;
+	}
+	const gate = supportDiagnosisProofGateResult(diagnosisGate, now);
+	return {
+		...qa,
+		outcome: qa.routeProbes.some((probe) => /^(pass|passed|success|ok|done)$/i.test(cleanText(probe.status, 40)))
+			? 'route_only_pass'
+			: 'incomplete',
+		gateResults: [
+			...qa.gateResults.filter((existing) => !(existing.key === 'qa_business_assertion' && existing.status === 'pass')),
+			gate
+		]
+	};
+}
+
+const SUPPORT_PRODUCT_REPAIR_STEP_TYPES = new Set([
+	'build_repair',
+	'owner_scoped_repair',
+	'product_repair',
+	'code_repair'
+]);
+
+const SUPPORT_PRODUCT_REPAIR_ACTIONS = new Set([
+	'run_owner_scoped_repair',
+	'run_targeted_product_repair',
+	'allow_product_repair'
+]);
+
+function supportSourceEditFiles(value: any): string[] {
+	return cleanStringList(value, 80, 500)
+		.filter((filePath) => {
+			const normalized = filePath.replace(/\\/g, '/').toLowerCase();
+			if (!normalized || /(^|\/)(qa-artifacts|runner-evidence|logs?|tmp|dist|node_modules)(\/|$)/.test(normalized)) {
+				return false;
+			}
+			return /\.(?:ts|tsx|js|jsx|html|scss|css|json|mjs|cjs|vue|svelte|md)$/i.test(normalized);
+		});
+}
+
+function supportRepairActivityFromRecord(
+	value: any,
+	source: string,
+	index: number
+): { changedFiles: string[]; activityRef?: string } | undefined {
+	const record = plainObject(value);
+	if (!Object.keys(record).length) {
+		return undefined;
+	}
+	const stepType = cleanText(record.stepType || record.step_type || record.type, 120);
+	const action = cleanText(record.action || record.primaryAction || record.primary_action || record.allowedDispatchAction || record.allowed_dispatch_action, 120);
+	const lane = cleanText(record.lane || record.phase || record.category, 120).toLowerCase();
+	const changedFiles = supportSourceEditFiles(
+		record.changedFiles
+		|| record.changed_files
+		|| record.modifiedFiles
+		|| record.modified_files
+		|| record.editedFiles
+		|| record.edited_files
+		|| record.files
+	);
+	const explicitProductRepair = SUPPORT_PRODUCT_REPAIR_STEP_TYPES.has(stepType)
+		|| SUPPORT_PRODUCT_REPAIR_ACTIONS.has(action)
+		|| (lane === 'build' && changedFiles.length > 0);
+	if (!explicitProductRepair) {
+		return undefined;
+	}
+	const activityRef = cleanText(
+		record.microtaskId
+		|| record.microtask_id
+		|| record.taskId
+		|| record.task_id
+		|| record.jobId
+		|| record.job_id
+		|| record._id
+		|| record.id
+		|| `${source}:${index}`,
+		240
+	);
+	return { changedFiles, activityRef };
+}
+
+function supportProductRepairEvidence(input: SupportAIRunAdapterInput, evidence: Record<string, any>): {
+	attempted: boolean;
+	changedFiles: string[];
+	activityRefs: string[];
+	activityCount: number;
+} {
+	const job = input.job || {};
+	const records = [
+		...asArray<any>(job.supportV5StepHistory),
+		...asArray<any>(job.support_v5_step_history),
+		...asArray<any>(job.stepHistory),
+		...asArray<any>(job.step_history),
+		...asArray<any>(evidence.supportV5StepHistory),
+		...asArray<any>(evidence.support_v5_step_history),
+		...asArray<any>(evidence.stepHistory),
+		...asArray<any>(evidence.step_history),
+		...asArray<any>(input.taskEvents),
+		...asArray<any>(input.aiJobs),
+		...asArray<any>(input.buildPlans)
+	];
+	const activityRefs: string[] = [];
+	const changedFiles: string[] = [];
+	let activityCount = 0;
+	records.forEach((record, index) => {
+		const activity = supportRepairActivityFromRecord(record, 'support_repair_activity', index);
+		if (!activity) {
+			return;
+		}
+		activityCount += 1;
+		if (activity.activityRef) {
+			activityRefs.push(activity.activityRef);
+		}
+		changedFiles.push(...activity.changedFiles);
+	});
+	const directChangedFiles = supportSourceEditFiles([
+		...asArray<any>(job.changedFiles),
+		...asArray<any>(job.changed_files),
+		...asArray<any>(job.modifiedFiles),
+		...asArray<any>(job.modified_files),
+		...asArray<any>(job.editedFiles),
+		...asArray<any>(job.edited_files),
+		...asArray<any>(evidence.changedFiles),
+		...asArray<any>(evidence.changed_files),
+		...asArray<any>(evidence.modifiedFiles),
+		...asArray<any>(evidence.modified_files),
+		...asArray<any>(evidence.editedFiles),
+		...asArray<any>(evidence.edited_files),
+		...asArray<any>(input.commits).flatMap((commit) => asArray<any>(commit.changedFiles || commit.changed_files || commit.files))
+	]);
+	if (directChangedFiles.length) {
+		activityCount += 1;
+		activityRefs.push('changed_files');
+		changedFiles.push(...directChangedFiles);
+	}
+	const uniqueChangedFiles = Array.from(new Set(changedFiles.map((filePath) => cleanText(filePath, 500)).filter(Boolean))).slice(0, 80);
+	return {
+		attempted: activityCount > 0,
+		changedFiles: uniqueChangedFiles,
+		activityRefs: Array.from(new Set(activityRefs.map((ref) => cleanText(ref, 240)).filter(Boolean))).slice(0, 40),
+		activityCount
+	};
+}
+
+function supportDiagnosisBeforeRepairGate(
+	diagnosisGate: Record<string, any>,
+	repairEvidence: ReturnType<typeof supportProductRepairEvidence>,
+	now?: Date | string
+): AIRunGateResult | undefined {
+	if (!repairEvidence.attempted) {
+		return undefined;
+	}
+	const validation = validateResolveIOSupportDiagnosisGate(diagnosisGate);
+	const status: AIRunGateResult['status'] = validation.valid ? 'pass' : 'blocked';
+	return {
+		key: 'support_diagnosis_before_repair',
+		label: 'Support diagnosis before repair',
+		status,
+		reason: validation.valid
+			? 'Support product repair has a valid root-cause diagnosis gate and owner-file scope.'
+			: 'Support product repair is blocked until a valid SupportDiagnosisGate records reproduction/classification, accepted hypothesis, rejected alternatives, owner_files, and before/action/after proof.',
+		evidenceRefs: repairEvidence.changedFiles,
+		recordedAt: isoNow(now),
+		metadata: {
+			repairAttempted: true,
+			activityCount: repairEvidence.activityCount,
+			activityRefs: repairEvidence.activityRefs,
+			changedFiles: repairEvidence.changedFiles,
+			diagnosisValid: validation.valid,
+			diagnosisStatus: validation.status,
+			blockers: validation.blockers,
+			ownerFiles: validation.normalized?.owner_files || [],
+			issueClass: validation.normalized?.issue_class,
+			productRepairAllowed: validation.valid,
+			allowedDispatchAction: validation.valid ? 'run_owner_scoped_repair' : 'run_read_only_diagnosis',
+			requiredEvidence: validation.valid
+				? ['AIQaBusinessAssertion mapped to diagnosis proof_plan before acceptance']
+				: ['support_diagnosis_gate JSON', 'reproduction or blocked-reproduction reason', 'accepted_hypothesis with evidence', 'owner_files', 'proof_plan before/action/after']
+		}
+	};
+}
+
+function evidenceObject(...values: any[]): Record<string, any> {
+	for (const value of values) {
+		if (value && typeof value === 'object' && !Array.isArray(value)) {
+			return value;
+		}
+	}
+	return {};
+}
+
+function mergeEvidenceRecords(...values: any[]): Record<string, any> {
+	const merged: Record<string, any> = {};
+	for (const value of values) {
+		const source = plainObject(value);
+		for (const [key, entry] of Object.entries(source)) {
+			if (entry === undefined || entry === null || entry === '') {
+				continue;
+			}
+			if (Array.isArray(entry)) {
+				merged[key] = [...asArray(merged[key]), ...entry];
+				continue;
+			}
+			if (plainObject(entry) === entry && plainObject(merged[key]) === merged[key]) {
+				merged[key] = { ...merged[key], ...entry };
+				continue;
+			}
+			merged[key] = entry;
+		}
+	}
+	return merged;
+}
+
+function buildSupportQaEvidence(input: SupportAIRunAdapterInput): Record<string, any> {
+	const job = input.job || {};
+	const ticket = input.ticket || {};
+	const qaCursor = plainObject(job.supportQaValidationCursor || job.support_qa_validation_cursor);
+	const autonomousDecision = plainObject(job.supportV5AutonomousDecision || job.support_v5_autonomous_decision);
+	const businessProofReadiness = plainObject(
+		autonomousDecision.businessProofReadiness
+		|| autonomousDecision.business_proof_readiness
+		|| job.businessProofReadiness
+		|| job.business_proof_readiness
+	);
+	const customerReplyPolicy = plainObject(
+		autonomousDecision.customerReplyPolicy
+		|| autonomousDecision.customer_reply_policy
+		|| job.customerReplyPolicy
+		|| job.customer_reply_policy
+	);
+	const humanReviewPacket = plainObject(
+		autonomousDecision.humanReviewPacket
+		|| autonomousDecision.human_review_packet
+		|| customerReplyPolicy.humanReviewPacket
+		|| customerReplyPolicy.human_review_packet
+		|| job.humanReviewPacket
+		|| job.human_review_packet
+	);
+	const evidence = mergeEvidenceRecords(
+		qaCursor,
+		job.qaEvidence,
+		job.qa_evidence,
+		ticket.qaEvidence,
+		ticket.qa_evidence,
+		input.qaEvidence
+	);
+	evidence.supportQaAssertions = [
+		...asArray(job.supportQaAssertions),
+		...asArray(job.support_qa_assertions),
+		...asArray(evidence.supportQaAssertions)
+	];
+	evidence.aiQaBusinessAssertions = [
+		...asArray(job.aiQaBusinessAssertions),
+		...asArray(job.ai_qa_business_assertions),
+		...asArray(evidence.aiQaBusinessAssertions)
+	];
+	evidence.runnerEvidenceArtifacts = [
+		...asArray(job.runnerEvidenceArtifacts),
+		...asArray(job.runner_evidence_artifacts),
+		...asArray(evidence.runnerEvidenceArtifacts)
+	];
+	evidence.supportQaArtifacts = [
+		...asArray(job.supportQaArtifacts),
+		...asArray(job.support_qa_artifacts),
+		...asArray(job.qa_artifacts),
+		...asArray(evidence.supportQaArtifacts)
+	];
+	if (Object.keys(businessProofReadiness).length) {
+		evidence.businessProofReadiness = businessProofReadiness;
+	}
+	if (Object.keys(customerReplyPolicy).length) {
+		evidence.customerReplyPolicy = {
+			...customerReplyPolicy,
+			...(Object.keys(humanReviewPacket).length ? { humanReviewPacket } : {})
+		};
+	}
+	else if (Object.keys(humanReviewPacket).length) {
+		evidence.customerReplyPolicy = { humanReviewPacket };
+	}
+	return evidence;
+}
+
+function supportBusinessProofReadinessGate(
+	readiness: Record<string, any>,
+	now?: Date | string
+): AIRunGateResult | undefined {
+	if (!readiness || !Object.keys(readiness).length) {
+		return undefined;
+	}
+	const ready = readiness.ready === true;
+	const readinessStatus = cleanText(readiness.status, 120).toLowerCase();
+	const blockers = cleanStringList(readiness.blockers, 20, 500);
+	const artifactPaths = cleanStringList(readiness.artifactPaths || readiness.artifact_paths, 40, 500);
+	const proofFingerprint = cleanText(readiness.proofFingerprint || readiness.proof_fingerprint, 160);
+	const artifactFingerprint = cleanText(readiness.artifactFingerprint || readiness.artifact_fingerprint, 160);
+	const proofFreshness = cleanText(readiness.proofFreshness || readiness.proof_freshness, 120);
+	const status: AIRunGateResult['status'] = ready
+		? 'pass'
+		: /fail|failed/.test(readinessStatus)
+			? 'fail'
+			: /missing|route_only|blocked|weak|stale|incomplete/.test(readinessStatus)
+				? 'blocked'
+				: 'warn';
+	return {
+		key: 'support_business_proof_readiness',
+		label: 'Support business proof readiness',
+		status,
+		reason: cleanText(readiness.reason || blockers.join('; ') || readinessStatus || 'Support business proof readiness recorded.', 1200),
+		evidenceRefs: artifactPaths,
+		recordedAt: isoNow(now || readiness.recordedAt || readiness.recorded_at),
+		metadata: {
+			ready,
+			status: readinessStatus,
+			blockers,
+			requiredEvidence: cleanStringList(readiness.requiredEvidence || readiness.required_evidence, 20, 500),
+			proofFingerprint,
+			artifactFingerprint,
+			proofFreshness
+		}
+	};
+}
+
+function supportCustomerReplyPolicyGate(
+	policy: Record<string, any>,
+	now?: Date | string
+): AIRunGateResult | undefined {
+	if (!policy || !Object.keys(policy).length) {
+		return undefined;
+	}
+	const action = cleanText(policy.action, 120);
+	const safety = cleanText(policy.safety, 120);
+	const reason = cleanText(policy.reason, 1200);
+	const canDraft = policy.canDraftCustomerReply === true || policy.can_draft_customer_reply === true;
+	const canSend = policy.canSendCustomerReply === true || policy.can_send_customer_reply === true;
+	const reviewPacket = plainObject(policy.humanReviewPacket || policy.human_review_packet);
+	const reviewType = cleanText(reviewPacket.reviewType || reviewPacket.review_type, 160);
+	const evidenceRefs = cleanStringList(reviewPacket.evidenceRefs || reviewPacket.evidence_refs, 40, 500);
+	const blockers = cleanStringList(policy.blockers || reviewPacket.blockers, 20, 500);
+	const gateStatus: AIRunGateResult['status'] = canSend
+		? 'blocked'
+		: action === 'draft_resolution_reply' && canDraft
+			? 'warn'
+			: action === 'ask_clarification' && canDraft
+				? 'warn'
+				: 'blocked';
+	return {
+		key: 'support_customer_reply_policy',
+		label: 'Support customer reply policy',
+		status: gateStatus,
+		reason: reason || action || 'Support customer reply policy recorded.',
+		evidenceRefs,
+		recordedAt: isoNow(now || policy.recordedAt || policy.recorded_at || reviewPacket.createdAt || reviewPacket.created_at),
+		metadata: {
+			action,
+			safety,
+			canDraftCustomerReply: canDraft,
+			canSendCustomerReply: canSend,
+			confidenceLevel: cleanText(policy.confidenceLevel || policy.confidence_level, 120),
+			reviewType,
+			primaryAction: cleanText(reviewPacket.primaryAction || reviewPacket.primary_action, 160),
+			requiresHumanApproval: reviewPacket.requiresHumanApproval !== false && reviewPacket.requires_human_approval !== false,
+			questionPresent: !!cleanText(policy.clarificationQuestion || policy.clarification_question || reviewPacket.question, 1000),
+			blockers
+		}
+	};
+}
+
+function supportNextActionContractObject(ticket: Record<string, any>, job: Record<string, any>, evidence: Record<string, any>): Record<string, any> {
+	const ticketAutomation = plainObject(ticket.automation);
+	const ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
+	const autonomousDecision = plainObject(
+		job.supportV5AutonomousDecision
+		|| job.support_v5_autonomous_decision
+		|| evidence.supportV5AutonomousDecision
+		|| evidence.support_v5_autonomous_decision
+		|| ticket.supportV5AutonomousDecision
+		|| ticket.support_v5_autonomous_decision
+	);
+	return evidenceObject(
+		autonomousDecision.nextActionContract,
+		autonomousDecision.next_action_contract,
+		job.supportV5NextActionContract,
+		job.support_v5_next_action_contract,
+		job.nextActionContract,
+		job.next_action_contract,
+		evidence.supportV5NextActionContract,
+		evidence.support_v5_next_action_contract,
+		evidence.nextActionContract,
+		evidence.next_action_contract,
+		ticket.supportV5NextActionContract,
+		ticket.support_v5_next_action_contract,
+		ticket.nextActionContract,
+		ticket.next_action_contract,
+		ticketManager.nextActionContract,
+		ticketManager.next_action_contract
+	);
+}
+
+function supportNextActionContractRequired(ticket: Record<string, any>, job: Record<string, any>, evidence: Record<string, any>): boolean {
+	const ticketAutomation = plainObject(ticket.automation);
+	const ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
+	const workflowMarkers = [
+		job.supportWorkflowMode,
+		job.workflowMode,
+		job.workflow_mode,
+		job.supportWorkflowVersion,
+		job.support_workflow_version,
+		ticket.supportWorkflowMode,
+		ticket.workflowMode,
+		ticket.workflow_mode
+	].map((value) => cleanText(value, 80).toLowerCase());
+	return workflowMarkers.some((value) => value === 'support_v5' || value === 'v5')
+		|| !!job.supportV5SupervisorState
+		|| !!job.supportV5MicrotaskLedger
+		|| !!job.supportV5StepHistory
+		|| !!job.supportV5DiagnosisGate
+		|| !!job.supportV5DiagnosisEvidencePack
+		|| !!job.support_v5_supervisor_state
+		|| !!job.support_v5_microtask_ledger
+		|| !!job.support_v5_step_history
+		|| !!job.support_v5_diagnosis_gate
+		|| !!job.support_v5_diagnosis_evidence_pack
+		|| !!job.supportRootCauseEntryContract
+		|| !!job.support_root_cause_entry_contract
+		|| !!evidence.supportV5AutonomousDecision
+		|| !!evidence.support_v5_autonomous_decision
+		|| !!evidence.rootCauseReadiness
+		|| !!evidence.root_cause_readiness
+		|| !!ticketManager.root_cause_entry_contract
+		|| !!ticketManager.rootCauseEntryContract
+		|| !!ticketManager.last_watchdog_decision;
+}
+
+function supportNextActionContractMetadata(contract: Record<string, any>): Record<string, any> {
+	const decisionBasis = plainObject(contract.decisionBasis || contract.decision_basis);
+	const costRisk = plainObject(contract.costRisk || contract.cost_risk);
+	const source = {
+		contractId: cleanText(contract.contractId || contract.contract_id, 200),
+		action: cleanText(contract.action, 160),
+		label: cleanText(contract.label, 300),
+		primaryCommand: cleanText(contract.primaryCommand || contract.primary_command, 240),
+		lane: cleanText(contract.lane, 120),
+		stepType: cleanText(contract.stepType || contract.step_type, 120),
+		safeToAutoRun: booleanFlag(contract.safeToAutoRun ?? contract.safe_to_auto_run),
+		requiresHumanApproval: booleanFlag(contract.requiresHumanApproval ?? contract.requires_human_approval),
+		canRunWithoutCodexMonitor: booleanFlag(contract.canRunWithoutCodexMonitor ?? contract.can_run_without_codex_monitor),
+		codexFallbackRequired: booleanFlag(contract.codexFallbackRequired ?? contract.codex_fallback_required),
+		codexFallbackReason: cleanText(contract.codexFallbackReason || contract.codex_fallback_reason, 1000),
+		rootCauseFirstSatisfied: booleanFlag(contract.rootCauseFirstSatisfied ?? contract.root_cause_first_satisfied),
+		preconditions: cleanStringList(contract.preconditions, 40, 500),
+		expectedStateTransition: cleanText(contract.expectedStateTransition || contract.expected_state_transition, 1000),
+		successEvidence: cleanStringList(contract.successEvidence || contract.success_evidence, 40, 500),
+		stopConditions: cleanStringList(contract.stopConditions || contract.stop_conditions, 40, 500),
+		forbiddenActions: cleanStringList(contract.forbiddenActions || contract.forbidden_actions, 40, 500),
+		ownerFiles: cleanStringList(contract.ownerFiles || contract.owner_files || decisionBasis.ownerFiles || decisionBasis.owner_files, 40, 500),
+		blockers: cleanStringList(contract.blockers, 40, 500),
+		nextCommands: cleanStringList(contract.nextCommands || contract.next_commands, 40, 500),
+		costRisk: {
+			level: cleanText(costRisk.level || contract.costRiskLevel || contract.cost_risk_level, 80),
+			estimatedUsd: numberValue(costRisk.estimatedUsd ?? costRisk.estimated_usd ?? contract.estimatedUsd ?? contract.estimated_usd),
+			reason: cleanText(costRisk.reason, 800)
+		},
+		diagnosisValid: booleanFlag(decisionBasis.diagnosisValid ?? decisionBasis.diagnosis_valid),
+		ownerFilesReady: booleanFlag(decisionBasis.ownerFilesReady ?? decisionBasis.owner_files_ready),
+		proofPlanReady: booleanFlag(decisionBasis.proofPlanReady ?? decisionBasis.proof_plan_ready),
+		businessProofReady: booleanFlag(decisionBasis.businessProofReady ?? decisionBasis.business_proof_ready),
+		evidenceFreshnessStatus: cleanText(decisionBasis.evidenceFreshnessStatus || decisionBasis.evidence_freshness_status, 120),
+		evidenceStrength: cleanText(decisionBasis.evidenceStrength || decisionBasis.evidence_strength, 120),
+		failureClass: cleanText(decisionBasis.failureClass || decisionBasis.failure_class, 120),
+		blockerFingerprint: cleanText(decisionBasis.blockerFingerprint || decisionBasis.blocker_fingerprint, 200),
+		evidenceHash: cleanText(decisionBasis.evidenceHash || decisionBasis.evidence_hash, 200),
+		sameFailureCount: numberValue(decisionBasis.sameFailureCount ?? decisionBasis.same_failure_count),
+		hotfixCommitRequired: booleanFlag(decisionBasis.hotfixCommitRequired ?? decisionBasis.hotfix_commit_required ?? contract.hotfixCommitRequired ?? contract.hotfix_commit_required),
+		liveHotfixBlockedUntilCommit: booleanFlag(decisionBasis.liveHotfixBlockedUntilCommit ?? decisionBasis.live_hotfix_blocked_until_commit ?? contract.liveHotfixBlockedUntilCommit ?? contract.live_hotfix_blocked_until_commit)
+	};
+	return source;
+}
+
+function supportNextActionContractGate(contract: Record<string, any>, now?: Date | string, required = false): AIRunGateResult | undefined {
+	if (!contract || !Object.keys(contract).length) {
+		if (!required) {
+			return undefined;
+		}
+		const blocker = 'Support V5 run is missing a validated next-action contract, so the manager cannot prove one safe primary action without external Codex monitoring.';
+		return {
+			key: 'support_next_action_contract',
+			label: 'Support next-action contract',
+			status: 'blocked',
+			reason: blocker,
+			evidenceRefs: [],
+			recordedAt: isoNow(now),
+			metadata: {
+				required: true,
+				missingContract: true,
+				safeToAutoRun: false,
+				canRunWithoutCodexMonitor: false,
+				codexFallbackRequired: true,
+				codexFallbackReason: 'missing_support_next_action_contract',
+				blockers: [blocker],
+				missingSafetyFlags: ['safeToAutoRun', 'canRunWithoutCodexMonitor', 'codexFallbackRequired']
+			}
+		};
+	}
+	const metadata = supportNextActionContractMetadata(contract);
+	const blockers = cleanStringList(metadata.blockers, 40, 500);
+	if (metadata.safeToAutoRun === false) {
+		blockers.push('Next action contract marks the action unsafe for autonomous run.');
+	}
+	if (metadata.canRunWithoutCodexMonitor === false) {
+		blockers.push('Next action requires Codex fallback/monitoring instead of manager-only execution.');
+	}
+	if (metadata.codexFallbackRequired === true) {
+		blockers.push(metadata.codexFallbackReason || 'Next action contract requires Codex fallback.');
+	}
+	if (metadata.requiresHumanApproval === true) {
+		blockers.push('Next action contract requires human approval.');
+	}
+	if (metadata.liveHotfixBlockedUntilCommit === true) {
+		blockers.push('Live hotfix is blocked until the manager records and pushes the GitHub commit proof.');
+	}
+	const missingSafetyFlags = [
+		metadata.safeToAutoRun === undefined ? 'safeToAutoRun' : '',
+		metadata.canRunWithoutCodexMonitor === undefined ? 'canRunWithoutCodexMonitor' : '',
+		metadata.codexFallbackRequired === undefined ? 'codexFallbackRequired' : ''
+	].filter(Boolean);
+	const status: AIRunGateResult['status'] = blockers.length
+		? 'blocked'
+		: missingSafetyFlags.length
+			? 'warn'
+			: 'pass';
+	const actionLabel = metadata.label || metadata.action || metadata.primaryCommand || 'support next action';
+	return {
+		key: 'support_next_action_contract',
+		label: 'Support next-action contract',
+		status,
+		reason: blockers.length
+			? blockers.join(' ')
+			: missingSafetyFlags.length
+				? `Support next-action contract is present for ${actionLabel}, but missing explicit safety flags: ${missingSafetyFlags.join(', ')}.`
+				: `Support next-action contract allows ${actionLabel} without Codex monitoring.`,
+		evidenceRefs: cleanStringList([
+			...metadata.successEvidence,
+			...metadata.preconditions,
+			...metadata.stopConditions
+		], 40, 500),
+		recordedAt: isoNow(now || contract.createdAt || contract.created_at || contract.recordedAt || contract.recorded_at),
+		metadata: {
+			...metadata,
+			blockers,
+			missingSafetyFlags
+		}
+	};
+}
+
+function supportDiagnosisEvidencePackObject(ticket: Record<string, any>, job: Record<string, any>, evidence: Record<string, any>): Record<string, any> {
+	const ticketAutomation = plainObject(ticket.automation);
+	const ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
+	return evidenceObject(
+		job.supportV5DiagnosisEvidencePack,
+		job.support_v5_diagnosis_evidence_pack,
+		job.diagnosisEvidencePack,
+		job.diagnosis_evidence_pack,
+		evidence.supportV5DiagnosisEvidencePack,
+		evidence.support_v5_diagnosis_evidence_pack,
+		evidence.diagnosisEvidencePack,
+		evidence.diagnosis_evidence_pack,
+		ticket.supportV5DiagnosisEvidencePack,
+		ticket.support_v5_diagnosis_evidence_pack,
+		ticket.diagnosisEvidencePack,
+		ticket.diagnosis_evidence_pack,
+		ticketManager.diagnosisEvidencePack,
+		ticketManager.diagnosis_evidence_pack
+	);
+}
+
+function supportSimilarFixHintsObject(ticket: Record<string, any>, job: Record<string, any>, evidence: Record<string, any>): Record<string, any> {
+	const ticketAutomation = plainObject(ticket.automation);
+	const ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
+	return evidenceObject(
+		job.supportRootCauseSimilarFixHints,
+		job.support_root_cause_similar_fix_hints,
+		job.similarFixHints,
+		job.similar_fix_hints,
+		evidence.supportRootCauseSimilarFixHints,
+		evidence.support_root_cause_similar_fix_hints,
+		evidence.similarFixHints,
+		evidence.similar_fix_hints,
+		ticket.supportRootCauseSimilarFixHints,
+		ticket.support_root_cause_similar_fix_hints,
+		ticketManager.rootCauseSimilarFixHints,
+		ticketManager.root_cause_similar_fix_hints
+	);
+}
+
+function supportDiagnosisEvidencePackGate(pack: Record<string, any>, now?: Date | string): AIRunGateResult | undefined {
+	if (!pack || !Object.keys(pack).length) {
+		return undefined;
+	}
+	const statusText = cleanText(pack.status, 120);
+	const diagnosisValid = pack.diagnosisValid === true || pack.diagnosis_valid === true;
+	const validationBlockers = cleanStringList(pack.validationBlockers || pack.validation_blockers, 40, 500);
+	const similarSelection = plainObject(pack.similarCaseSelection || pack.similar_case_selection);
+	const rankedHints = asArray<any>(similarSelection.ranked);
+	const gateStatus: AIRunGateResult['status'] = diagnosisValid || statusText === 'diagnosis_ready'
+		? 'pass'
+		: statusText === 'blocked'
+			? 'blocked'
+			: 'warn';
+	return {
+		key: 'support_diagnosis_evidence_pack',
+		label: 'Support diagnosis evidence pack',
+		status: gateStatus,
+		reason: gateStatus === 'pass'
+			? 'Support diagnosis evidence pack has a valid root-cause diagnosis and advisory similar-fix context.'
+			: validationBlockers.join('; ') || 'Support diagnosis evidence pack requires read-only root-cause evidence before repair.',
+		evidenceRefs: cleanStringList(pack.requiredEvidence || pack.required_evidence, 30, 500),
+		recordedAt: isoNow(now || pack.generatedAt || pack.generated_at),
+		metadata: {
+			packId: cleanText(pack.packId || pack.pack_id, 180),
+			status: statusText,
+			readOnly: pack.readOnly !== false && pack.read_only !== false,
+			sourceEditsAllowed: pack.sourceEditsAllowed === true || pack.source_edits_allowed === true,
+			rootCauseFirstRequired: pack.rootCauseFirstRequired !== false && pack.root_cause_first_required !== false,
+			requiredOutputKey: cleanText(pack.requiredOutputKey || pack.required_output_key, 120),
+			requiredFields: cleanStringList(pack.requiredFields || pack.required_fields, 20, 160),
+			forbiddenActions: cleanStringList(pack.forbiddenActions || pack.forbidden_actions, 20, 500),
+			diagnosisValid,
+			diagnosisStatus: cleanText(pack.diagnosisStatus || pack.diagnosis_status, 120),
+			validationBlockers,
+			issueClassHint: cleanText(pack.issueClassHint || pack.issue_class_hint, 120),
+			ownerFileHints: cleanStringList(pack.ownerFileHints || pack.owner_file_hints, 20, 500),
+			similarHintCount: rankedHints.length,
+			similarHintsAdvisoryOnly: true,
+			issueClassProbeCount: asArray(pack.issueClassProbeCatalog || pack.issue_class_probe_catalog).length
+		}
+	};
+}
+
+function firstNonEmptyText(values: any[], max = 1000): string | undefined {
+	for (const value of values) {
+		const normalized = idText(value, max);
+		if (normalized) {
+			return normalized;
+		}
+	}
+	return undefined;
+}
+
+function booleanFlag(value: any): boolean | undefined {
+	if (value === true || value === false) {
+		return value;
+	}
+	if (typeof value === 'string') {
+		const normalized = value.trim().toLowerCase();
+		if (/^(true|yes|1|passed|pass|ready|safe)$/.test(normalized)) {
+			return true;
+		}
+		if (/^(false|no|0|failed|fail|blocked|unsafe)$/.test(normalized)) {
+			return false;
+		}
+	}
+	return undefined;
+}
+
+function numberValue(value: any): number | undefined {
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function buildAICoderQaEvidence(input: AICoderAIRunAdapterInput): Record<string, any> {
+	const app = input.app || {};
+	const job = input.job || {};
+	const workflowMemory = plainObject(
+		job.aiCoderV6WorkflowMemory
+		|| job.ai_coder_v6_workflow_memory
+		|| app.aiCoderV6WorkflowMemory
+		|| app.ai_coder_v6_workflow_memory
+	);
+	const evidence = mergeEvidenceRecords(
+		job.qaEvidence,
+		job.qa_evidence,
+		app.qaEvidence,
+		app.qa_evidence,
+		input.qaEvidence
+	);
+	evidence.workflowQaRows = [
+		...asArray(workflowMemory.workflowQaRows),
+		...asArray(workflowMemory.workflow_qa_rows),
+		...asArray(job.workflowQaRows),
+		...asArray(job.workflow_qa_rows),
+		...asArray(app.workflowQaRows),
+		...asArray(app.workflow_qa_rows),
+		...asArray(evidence.workflowQaRows),
+		...asArray(evidence.workflow_qa_rows)
+	];
+	evidence.businessAssertions = [
+		...asArray(job.aiQaBusinessAssertions),
+		...asArray(job.ai_qa_business_assertions),
+		...asArray(job.businessAssertions),
+		...asArray(job.business_assertions),
+		...asArray(app.businessAssertions),
+		...asArray(app.business_assertions),
+		...asArray(evidence.businessAssertions),
+		...asArray(evidence.business_assertions)
+	];
+	evidence.routeProbes = [
+		...asArray(job.workflowProbes),
+		...asArray(job.workflow_probes),
+		...asArray(evidence.routeProbes),
+		...asArray(evidence.route_probes)
+	];
+	evidence.artifactPaths = [
+		...asArray(workflowMemory.businessProofArtifacts),
+		...asArray(workflowMemory.business_proof_artifacts),
+		...asArray(job.artifactPaths),
+		...asArray(job.artifact_paths),
+		...asArray(app.artifactPaths),
+		...asArray(app.artifact_paths),
+		...asArray(evidence.artifactPaths),
+		...asArray(evidence.artifact_paths)
+	];
+	evidence.journeyContract = evidence.journeyContract
+		|| evidence.journey_contract
+		|| job.journeyContract
+		|| job.journey_contract
+		|| app.journeyContract
+		|| app.journey_contract
+		|| workflowMemory.journeyContract
+		|| workflowMemory.journey_contract;
+	evidence.journeyContractMarkdown = evidence.journeyContractMarkdown
+		|| evidence.journey_contract_markdown
+		|| job.journeyContractMarkdown
+		|| job.journey_contract_markdown
+		|| app.journeyContractMarkdown
+		|| app.journey_contract_markdown;
+	evidence.journeyContractPath = firstNonEmptyText([
+		evidence.journeyContractPath,
+		evidence.journey_contract_path,
+		workflowMemory.journeyContractPath,
+		workflowMemory.journey_contract_path,
+		job.journeyContractPath,
+		job.journey_contract_path,
+		app.journeyContractPath,
+		app.journey_contract_path
+	], 500) || 'docs/APP_JOURNEY_CONTRACT.md';
+	evidence.deployStatus = firstNonEmptyText([
+		evidence.deployStatus,
+		evidence.deploy_status,
+		job.deployStatus,
+		job.deploy_status,
+		job.testDeployStatus,
+		job.test_deploy_status,
+		app.deployStatus,
+		app.deploy_status
+	], 160);
+	evidence.publishStatus = firstNonEmptyText([
+		evidence.publishStatus,
+		evidence.publish_status,
+		evidence.pullRequestStatus,
+		evidence.pull_request_status,
+		job.publishStatus,
+		job.publish_status,
+		job.pullRequestStatus,
+		job.pull_request_status,
+		app.publishStatus,
+		app.publish_status
+	], 160);
+	evidence.sampleDataStatus = firstNonEmptyText([
+		evidence.sampleDataStatus,
+		evidence.sample_data_status,
+		job.sampleDataStatus,
+		job.sample_data_status,
+		app.sampleDataStatus,
+		app.sample_data_status
+	], 160) || statusFromBoolean(evidence.sampleDataReady ?? evidence.hasSampleData ?? job.sampleDataReady ?? app.sampleDataReady);
+	return evidence;
+}
+
+function normalizeAICoderWorkflowProofReadiness(
+	value: Record<string, any>,
+	now?: Date | string
+): ResolveIOAICoderWorkflowProofReadiness | undefined {
+	if (!value || !Object.keys(value).length) {
+		return undefined;
+	}
+	const ready = value.ready === true;
+	const status = cleanText(value.status, 120) || (ready ? 'ready' : 'blocked');
+	return {
+		ready,
+		status: status as ResolveIOAICoderWorkflowProofReadiness['status'],
+		reason: cleanText(value.reason || value.summary || status, 1200),
+		blockers: cleanStringList(value.blockers, 40, 500),
+		journeyContractValid: value.journeyContractValid === true || value.journey_contract_valid === true,
+		primaryWorkflowId: cleanText(value.primaryWorkflowId || value.primary_workflow_id, 200),
+		passedWorkflowRows: cleanStringList(value.passedWorkflowRows || value.passed_workflow_rows, 80, 300),
+		missingWorkflowRows: cleanStringList(value.missingWorkflowRows || value.missing_workflow_rows, 80, 300),
+		failedWorkflowRows: cleanStringList(value.failedWorkflowRows || value.failed_workflow_rows, 80, 300),
+		passedBusinessAssertions: cleanStringList(value.passedBusinessAssertions || value.passed_business_assertions, 80, 500),
+		routeOnly: value.routeOnly === true || value.route_only === true,
+		scorecardOnly: value.scorecardOnly === true || value.scorecard_only === true,
+		sampleDataReady: value.sampleDataReady === true || value.sample_data_ready === true,
+		releaseBlockers: cleanStringList(value.releaseBlockers || value.release_blockers, 40, 500),
+		artifactPaths: cleanStringList(value.artifactPaths || value.artifact_paths, 80, 500),
+		workflowProofFingerprint: cleanText(value.workflowProofFingerprint || value.workflow_proof_fingerprint, 200),
+		artifactFingerprint: cleanText(value.artifactFingerprint || value.artifact_fingerprint, 200),
+		proofFreshness: cleanText(value.proofFreshness || value.proof_freshness, 80) as ResolveIOAICoderWorkflowProofReadiness['proofFreshness'],
+		nextAction: cleanText(value.nextAction || value.next_action, 1000),
+		evaluatedAt: isoNow(now || value.evaluatedAt || value.evaluated_at || value.recordedAt || value.recorded_at)
+	};
+}
+
+function aicoderJourneyContractValidationFromEvidence(evidence: Record<string, any>): ResolveIOAICoderJourneyContractValidationResult {
+	const journeyInput = evidence.journeyContract !== undefined && evidence.journeyContract !== null
+		? evidence.journeyContract
+		: evidence.journeyContractMarkdown;
+	const hasJourneyInput = journeyInput !== undefined && journeyInput !== null && cleanText(journeyInput, 100).length > 0;
+	if (!hasJourneyInput) {
+		return {
+			valid: false,
+			contract: null,
+			issues: [{
+				code: 'missing_contract',
+				path: cleanText(evidence.journeyContractPath, 500) || 'docs/APP_JOURNEY_CONTRACT.md',
+				message: 'docs/APP_JOURNEY_CONTRACT.md with structured journey_contract JSON is required before AICoder build, workflow QA, wow UI, publish, or acceptance.',
+				severity: 'error'
+			}],
+			workflowQaRows: [],
+			primaryWorkflowId: ''
+		};
+	}
+	return validateResolveIOAICoderJourneyContract(journeyInput, {
+		requireMarkdownEnvelope: typeof journeyInput === 'string'
+	});
+}
+
+function aicoderJourneyContractGate(
+	validation: ResolveIOAICoderJourneyContractValidationResult,
+	evidence: Record<string, any>,
+	now?: Date | string
+): AIRunGateResult {
+	const errorIssues = validation.issues.filter((issue) => issue.severity === 'error');
+	const warningIssues = validation.issues.filter((issue) => issue.severity === 'warning');
+	const status: AIRunGateResult['status'] = validation.valid
+		? (warningIssues.length ? 'warn' : 'pass')
+		: 'blocked';
+	const path = cleanText(evidence.journeyContractPath, 500) || 'docs/APP_JOURNEY_CONTRACT.md';
+	return {
+		key: 'aicoder_journey_contract',
+		label: 'AICoder journey contract',
+		status,
+		reason: validation.valid
+			? (warningIssues.length
+				? `Journey contract is valid with warnings: ${warningIssues.map((issue) => issue.message).slice(0, 3).join(' | ')}`
+				: 'Journey contract validates first/next/last workflow, data story, completion states, and QA assertions.')
+			: (errorIssues.map((issue) => issue.message).slice(0, 5).join(' | ') || 'AICoder Journey Contract is missing or invalid.'),
+		evidenceRefs: [path],
+		recordedAt: isoNow(now),
+		metadata: {
+			path,
+			valid: validation.valid,
+			primaryWorkflowId: cleanText(validation.primaryWorkflowId, 200),
+			workflowQaRowCount: validation.workflowQaRows.length,
+			errorCount: errorIssues.length,
+			warningCount: warningIssues.length,
+			issueCodes: cleanStringList(validation.issues.map((issue) => issue.code), 40, 120),
+			issues: validation.issues.slice(0, 20).map((issue) => ({
+				code: cleanText(issue.code, 120),
+				path: cleanText(issue.path, 500),
+				severity: issue.severity,
+				message: cleanText(issue.message, 800)
+			})),
+			blocksBuildUntilValid: !validation.valid,
+			blocksWorkflowQaUntilValid: !validation.valid,
+			blocksWowUiUntilWorkflowProof: !validation.valid,
+			blocksPublishUntilWorkflowProof: !validation.valid,
+			nextAction: validation.valid
+				? 'Generate workflow QA rows from journey_contract.qa_assertions and execute the north-star workflow.'
+				: 'Generate or repair docs/APP_JOURNEY_CONTRACT.md before app build, wow UI, publish, or acceptance.'
+		}
+	};
+}
+
+function aicoderWorkflowProofReadinessGate(
+	readiness: ResolveIOAICoderWorkflowProofReadiness,
+	now?: Date | string
+): AIRunGateResult {
+	const status: AIRunGateResult['status'] = readiness.ready
+		? 'pass'
+		: readiness.status === 'release_blocked' || readiness.status === 'journey_invalid' || readiness.status === 'sample_data_missing'
+			? 'fail'
+			: 'blocked';
+	return {
+		key: 'aicoder_workflow_proof_readiness',
+		label: 'AICoder workflow proof readiness',
+		status,
+		reason: readiness.reason || readiness.blockers.join('; ') || readiness.status,
+		evidenceRefs: readiness.artifactPaths,
+		recordedAt: isoNow(now || readiness.evaluatedAt),
+		metadata: {
+			ready: readiness.ready,
+			status: readiness.status,
+			primaryWorkflowId: readiness.primaryWorkflowId,
+			journeyContractValid: readiness.journeyContractValid,
+			blockers: readiness.blockers,
+			passedWorkflowRows: readiness.passedWorkflowRows,
+			missingWorkflowRows: readiness.missingWorkflowRows,
+			failedWorkflowRows: readiness.failedWorkflowRows,
+			passedBusinessAssertions: readiness.passedBusinessAssertions,
+			routeOnly: readiness.routeOnly,
+			scorecardOnly: readiness.scorecardOnly,
+			sampleDataReady: readiness.sampleDataReady,
+			releaseBlockers: readiness.releaseBlockers,
+			workflowProofFingerprint: readiness.workflowProofFingerprint,
+			artifactFingerprint: readiness.artifactFingerprint,
+			proofFreshness: readiness.proofFreshness,
+			nextAction: readiness.nextAction
+		}
+	};
+}
+
+function aicoderWorkflowProofCheckpointObject(app: Record<string, any>, job: Record<string, any>, evidence: Record<string, any>): Record<string, any> {
+	const workflowMemory = plainObject(
+		job.aiCoderV6WorkflowMemory
+		|| job.ai_coder_v6_workflow_memory
+		|| app.aiCoderV6WorkflowMemory
+		|| app.ai_coder_v6_workflow_memory
+		|| evidence.aiCoderV6WorkflowMemory
+		|| evidence.ai_coder_v6_workflow_memory
+	);
+	const continuationDecision = plainObject(
+		job.aicoderV6ContinuationDecision
+		|| job.aiCoderV6ContinuationDecision
+		|| job.aicoder_v6_continuation_decision
+		|| job.ai_coder_v6_continuation_decision
+		|| app.aicoderV6ContinuationDecision
+		|| app.aiCoderV6ContinuationDecision
+		|| app.aicoder_v6_continuation_decision
+		|| evidence.aicoderV6ContinuationDecision
+		|| evidence.aiCoderV6ContinuationDecision
+		|| evidence.aicoder_v6_continuation_decision
+	);
+	return evidenceObject(
+		continuationDecision.workflowProofCheckpoint,
+		continuationDecision.workflow_proof_checkpoint,
+		workflowMemory.workflowProofCheckpoint,
+		workflowMemory.workflow_proof_checkpoint,
+		job.workflowProofCheckpoint,
+		job.workflow_proof_checkpoint,
+		job.aicoderWorkflowProofCheckpoint,
+		job.aicoder_workflow_proof_checkpoint,
+		app.workflowProofCheckpoint,
+		app.workflow_proof_checkpoint,
+		evidence.workflowProofCheckpoint,
+		evidence.workflow_proof_checkpoint,
+		evidence.aicoderWorkflowProofCheckpoint,
+		evidence.aicoder_workflow_proof_checkpoint
+	);
+}
+
+function aicoderWorkflowProofCheckpointGate(checkpoint: Record<string, any>, now?: Date | string): AIRunGateResult | undefined {
+	if (!checkpoint || !Object.keys(checkpoint).length) {
+		return undefined;
+	}
+	const blocksProductRepairUntilJourneyContract = booleanFlag(checkpoint.blocksProductRepairUntilJourneyContract ?? checkpoint.blocks_product_repair_until_journey_contract) === true;
+	const blocksPublishUntilWorkflowProof = booleanFlag(checkpoint.blocksPublishUntilWorkflowProof ?? checkpoint.blocks_publish_until_workflow_proof) === true;
+	const blocksPublishUntilReleaseGate = booleanFlag(checkpoint.blocksPublishUntilReleaseGate ?? checkpoint.blocks_publish_until_release_gate) === true;
+	const blocksWowUiUntilWorkflowProof = booleanFlag(checkpoint.blocksWowUiUntilWorkflowProof ?? checkpoint.blocks_wow_ui_until_workflow_proof) === true;
+	const statusText = cleanText(checkpoint.status, 120);
+	const required = booleanFlag(checkpoint.required) !== false;
+	const blockers = cleanStringList(checkpoint.blockers, 40, 500);
+	if (blocksProductRepairUntilJourneyContract) {
+		blockers.push('Product repair is blocked until the journey contract is valid.');
+	}
+	if (blocksPublishUntilWorkflowProof) {
+		blockers.push('Publish is blocked until workflow business proof passes.');
+	}
+	if (blocksPublishUntilReleaseGate) {
+		blockers.push('Publish is blocked until release gate evidence passes.');
+	}
+	if (blocksWowUiUntilWorkflowProof) {
+		blockers.push('Wow UI polish is blocked until workflow proof exists.');
+	}
+	const gateStatus: AIRunGateResult['status'] = !required || statusText === 'ready_to_continue'
+		? 'pass'
+		: blockers.length
+			? 'blocked'
+			: 'warn';
+	return {
+		key: 'aicoder_workflow_proof_checkpoint',
+		label: 'AICoder workflow proof checkpoint',
+		status: gateStatus,
+		reason: gateStatus === 'pass'
+			? 'AICoder workflow checkpoint allows the next action.'
+			: (blockers.join(' ') || cleanText(checkpoint.nextAction || checkpoint.next_action || statusText, 1200) || 'AICoder workflow checkpoint requires more proof before continuing.'),
+		evidenceRefs: cleanStringList([
+			...asArray(checkpoint.requiredEvidence || checkpoint.required_evidence),
+			...asArray(checkpoint.requiredResetEvidence || checkpoint.required_reset_evidence)
+		], 40, 500),
+		recordedAt: isoNow(now || checkpoint.recordedAt || checkpoint.recorded_at || checkpoint.createdAt || checkpoint.created_at),
+		metadata: {
+			required,
+			status: statusText,
+			readinessStatus: cleanText(checkpoint.readinessStatus || checkpoint.readiness_status, 120),
+			nextGate: cleanText(checkpoint.nextGate || checkpoint.next_gate, 120),
+			nextAction: cleanText(checkpoint.nextAction || checkpoint.next_action, 1000),
+			startingFailureClass: cleanText(checkpoint.startingFailureClass || checkpoint.starting_failure_class, 120),
+			startingBlockerFingerprint: cleanText(checkpoint.startingBlockerFingerprint || checkpoint.starting_blocker_fingerprint, 200),
+			startingEvidenceHash: cleanText(checkpoint.startingEvidenceHash || checkpoint.starting_evidence_hash, 200),
+			workflowProofFingerprint: cleanText(checkpoint.workflowProofFingerprint || checkpoint.workflow_proof_fingerprint, 200),
+			artifactFingerprint: cleanText(checkpoint.artifactFingerprint || checkpoint.artifact_fingerprint, 200),
+			requiredEvidence: cleanStringList(checkpoint.requiredEvidence || checkpoint.required_evidence, 40, 500),
+			requiredResetEvidence: cleanStringList(checkpoint.requiredResetEvidence || checkpoint.required_reset_evidence, 40, 500),
+			successRequiresWorkflowBusinessProof: booleanFlag(checkpoint.successRequiresWorkflowBusinessProof ?? checkpoint.success_requires_workflow_business_proof) === true,
+			blocksProductRepairUntilJourneyContract,
+			blocksPublishUntilWorkflowProof,
+			blocksPublishUntilReleaseGate,
+			blocksWowUiUntilWorkflowProof,
+			blockers
+		}
+	};
+}
+
+function adapterStatusPassed(value: any): boolean {
+	const normalized = cleanText(value, 120).toLowerCase();
+	return !!normalized && /(pass|passed|success|succeeded|ok|done|complete|completed|ready|saved|published|deployed)/i.test(normalized);
+}
+
+function applyAICoderWorkflowProofGate(
+	qa: AIQaRun,
+	readiness: ResolveIOAICoderWorkflowProofReadiness,
+	now?: Date | string
+): AIQaRun {
+	if (
+		readiness.ready
+		|| readiness.status === 'release_blocked'
+		|| qa.outcome === 'infra_failed'
+		|| qa.outcome === 'compile_failed'
+		|| qa.outcome === 'route_failed'
+		|| qa.outcome === 'business_assertion_failed'
+	) {
+		return qa;
+	}
+	const gate = aicoderWorkflowProofReadinessGate(readiness, now);
+	return {
+		...qa,
+		outcome: qa.routeProbes.some((probe) => adapterStatusPassed(probe.status))
+			? 'route_only_pass'
+			: 'incomplete',
+		gateResults: [
+			...qa.gateResults.filter((existing) => !(existing.key === 'qa_business_assertion' && existing.status === 'pass')),
+			gate
+		]
+	};
+}
+
+function assistantQualityObject(input: AssistantAIRunAdapterInput): Record<string, any> {
+	const conversation = input.conversation || {};
+	const latestAssistantMessage = [...asArray<Record<string, any>>(input.messages)]
+		.reverse()
+		.find((message) => /assistant/i.test(cleanText(message.role || message.authorRole || message.type, 80)));
+	return plainObject(
+		input.answerQuality
+		|| conversation.answerQuality
+		|| conversation.answer_quality
+		|| conversation.assistantAnswerQuality
+		|| conversation.assistant_answer_quality
+		|| latestAssistantMessage?.answerQuality
+		|| latestAssistantMessage?.answer_quality
+		|| latestAssistantMessage?.metadata?.answerQuality
+		|| latestAssistantMessage?.metadata?.answer_quality
+	);
+}
+
+function assistantConfidenceLevel(value: any): AssistantAnswerQualityDecision['confidenceLevel'] {
+	const normalized = cleanText(value?.level || value?.confidenceLevel || value?.confidence_level || value, 80).toLowerCase();
+	if (/^high$/.test(normalized)) {
+		return 'high';
+	}
+	if (/^medium$/.test(normalized)) {
+		return 'medium';
+	}
+	if (/^low$/.test(normalized)) {
+		return 'low';
+	}
+	return 'unknown';
+}
+
+function assistantQueryStatus(value: any): AssistantAnswerQualityDecision['queryStatus'] {
+	const normalized = cleanText(value?.status || value?.queryStatus || value?.query_status || value, 120).toLowerCase().replace(/[\s-]+/g, '_');
+	if (/^(ok|success|answered|data_found|data)$/.test(normalized)) {
+		return 'ok';
+	}
+	if (/^(no_data|no_results|empty|not_found)$/.test(normalized)) {
+		return 'no_data';
+	}
+	if (/^(query_error|mongo_error|error|failed)$/.test(normalized)) {
+		return 'query_error';
+	}
+	if (/^(permission_error|permission_denied|forbidden|unauthorized)$/.test(normalized)) {
+		return 'permission_error';
+	}
+	return 'unknown';
+}
+
+function asObjectList(value: any): Record<string, any>[] {
+	return asArray<Record<string, any>>(value).filter((entry) => entry && typeof entry === 'object' && !Array.isArray(entry));
+}
+
+function assistantEvidenceRefs(quality: Record<string, any>): string[] {
+	return cleanStringList([
+		...asArray(quality.evidenceRefs),
+		...asArray(quality.evidence_refs),
+		...asArray(quality.citationRefs),
+		...asArray(quality.citation_refs),
+		...asArray(quality.artifactPaths),
+		...asArray(quality.artifact_paths),
+		...asObjectList(quality.citations).map((citation) => citation.path || citation.url || citation.id || citation.ref),
+		...asObjectList(quality.evidence).map((entry) => entry.path || entry.url || entry.id || entry.ref)
+	], 80, 500);
+}
+
+function assistantCitationRefs(quality: Record<string, any>): string[] {
+	return cleanStringList([
+		...asArray(quality.citationRefs),
+		...asArray(quality.citation_refs),
+		...asObjectList(quality.citations).map((citation) => citation.path || citation.url || citation.id || citation.ref),
+		...asObjectList(quality.evidence).map((entry) => entry.citation || entry.ref || entry.path || entry.url)
+	], 80, 500);
+}
+
+function assistantQueryExecutions(quality: Record<string, any>): Record<string, any>[] {
+	const queryExecution = plainObject(quality.queryExecution || quality.query_execution);
+	const toolResult = plainObject(quality.toolResult || quality.tool_result);
+	return [
+		...asObjectList(quality.queryExecutions),
+		...asObjectList(quality.query_executions),
+		...asObjectList(quality.dataQueries),
+		...asObjectList(quality.data_queries),
+		...asObjectList(quality.toolResults),
+		...asObjectList(quality.tool_results),
+		...asObjectList(quality.mongoReads),
+		...asObjectList(quality.mongo_reads),
+		...asObjectList(quality.mongoAggregations),
+		...asObjectList(quality.mongo_aggregations),
+		...(Object.keys(queryExecution).length ? [queryExecution] : []),
+		...(Object.keys(toolResult).length ? [toolResult] : [])
+	].filter((entry) => Object.keys(entry).length);
+}
+
+function assistantQueryEvidenceRefs(quality: Record<string, any>, executions = assistantQueryExecutions(quality)): string[] {
+	return cleanStringList([
+		...asArray(quality.queryEvidenceRefs),
+		...asArray(quality.query_evidence_refs),
+		...asArray(quality.toolResultRefs),
+		...asArray(quality.tool_result_refs),
+		...asArray(quality.queryResultRefs),
+		...asArray(quality.query_result_refs),
+		...executions.map((execution) => {
+			return execution.id
+				|| execution._id
+				|| execution.ref
+				|| execution.toolResultId
+				|| execution.tool_result_id
+				|| execution.toolCallId
+				|| execution.tool_call_id
+				|| execution.artifactPath
+				|| execution.artifact_path
+				|| execution.path
+				|| execution.url;
+		})
+	], 80, 500);
+}
+
+function assistantNextActions(quality: Record<string, any>): string[] {
+	return cleanStringList([
+		...asArray(quality.nextActions),
+		...asArray(quality.next_actions),
+		...asArray(quality.recommendedActions),
+		...asArray(quality.recommended_actions)
+	], 20, 500);
+}
+
+function normalizedIsoDay(value: any): string {
+	if (!value) {
+		return '';
+	}
+	const date = value instanceof Date ? value : new Date(value);
+	if (!Number.isFinite(date.getTime())) {
+		return cleanText(value, 40).slice(0, 10);
+	}
+	return date.toISOString().slice(0, 10);
+}
+
+function assistantDateWindowObject(quality: Record<string, any>): Record<string, any> {
+	const dateWindow = plainObject(quality.dateWindow || quality.date_window);
+	const nestedWindow = plainObject(quality.verification?.metrics?.window || quality.metrics?.window);
+	return Object.keys(dateWindow).length ? dateWindow : nestedWindow;
+}
+
+function collectMongoProjectionObjects(value: any, result: Record<string, any>[] = []): Record<string, any>[] {
+	if (!value || typeof value !== 'object') {
+		return result;
+	}
+	if (Array.isArray(value)) {
+		for (const entry of value) {
+			collectMongoProjectionObjects(entry, result);
+		}
+		return result;
+	}
+	if (value.projection && typeof value.projection === 'object' && !Array.isArray(value.projection)) {
+		result.push(value.projection);
+	}
+	if (value.options && typeof value.options === 'object' && !Array.isArray(value.options) && value.options.projection) {
+		collectMongoProjectionObjects({ projection: value.options.projection }, result);
+	}
+	if (value.query && typeof value.query === 'object') {
+		collectMongoProjectionObjects(value.query, result);
+	}
+	if (value.mongoQuery && typeof value.mongoQuery === 'object') {
+		collectMongoProjectionObjects(value.mongoQuery, result);
+	}
+	if (value.mongo_query && typeof value.mongo_query === 'object') {
+		collectMongoProjectionObjects(value.mongo_query, result);
+	}
+	return result;
+}
+
+function projectionHasPositionalOperator(projection: Record<string, any>): boolean {
+	return Object.keys(projection || {}).some((key) => /\.(?:\$|\$\[)|\.\$$/.test(key));
+}
+
+function assistantQueryShapeLegal(quality: Record<string, any>): boolean {
+	if (quality.legalQueryShape === true || quality.legal_query_shape === true) {
+		return true;
+	}
+	if (quality.legalQueryShape === false || quality.legal_query_shape === false || quality.illegalQueryShape === true || quality.illegal_query_shape === true) {
+		return false;
+	}
+	const queryShape = plainObject(quality.queryShape || quality.query_shape);
+	if (queryShape.legal === true || queryShape.status === 'pass') {
+		return true;
+	}
+	if (queryShape.legal === false || queryShape.status === 'fail') {
+		return false;
+	}
+	const projections = collectMongoProjectionObjects(quality);
+	if (projections.some(projectionHasPositionalOperator)) {
+		return false;
+	}
+	return true;
+}
+
+function assistantCorrectnessFailed(checks: Array<Record<string, any>>): string[] {
+	return checks
+		.filter((check) => {
+			const status = cleanText(check.status || (check.passed === true ? 'pass' : check.passed === false ? 'fail' : ''), 80).toLowerCase();
+			return /^(fail|failed|blocked|incorrect|wrong|error)$/.test(status);
+		})
+		.map((check) => cleanText(check.assertion || check.name || check.case || check.reason || 'assistant correctness check failed', 300))
+		.slice(0, 20);
+}
+
+export function evaluateAssistantAnswerQuality(input: AssistantAnswerQualityInput = {}): AssistantAnswerQualityDecision {
+	const quality = plainObject(input.answerQuality);
+	const now = isoNow(input.now);
+	const correctnessChecks = asArray<Record<string, any>>(input.correctnessChecks);
+	const failedChecks = assistantCorrectnessFailed(correctnessChecks);
+	const queryStatus = assistantQueryStatus(quality.queryStatus || quality.query_status || quality.queryResult || quality.query_result);
+	const confidenceLevel = assistantConfidenceLevel(quality.confidence || quality.confidenceLevel || quality.confidence_level);
+	const evidenceRefs = assistantEvidenceRefs(quality);
+	const citationRefs = assistantCitationRefs(quality);
+	const queryExecutions = assistantQueryExecutions(quality);
+	const queryEvidenceRefs = assistantQueryEvidenceRefs(quality, queryExecutions);
+	const nextActions = assistantNextActions(quality);
+	const requiresCurrentDate = quality.requiresCurrentDate === true || quality.requires_current_date === true;
+	const dateWindowRequired = quality.requiresDateWindow === true
+		|| quality.requires_date_window === true
+		|| quality.dateWindowRequired === true
+		|| quality.date_window_required === true;
+	const requiresCitations = quality.requiresCitations !== false && quality.requires_citations !== false;
+	const requiresNextAction = quality.requiresNextAction !== false && quality.requires_next_action !== false;
+	const dateWindow = assistantDateWindowObject(quality);
+	const dateWindowStart = cleanText(dateWindow.startDate || dateWindow.start_date || dateWindow.start, 80);
+	const dateWindowEnd = cleanText(dateWindow.endDate || dateWindow.end_date || dateWindow.end, 80);
+	const dateWindowPresent = !!dateWindowStart && !!dateWindowEnd;
+	const dateBasis = cleanText(
+		quality.currentDateUsed
+		|| quality.current_date_used
+		|| quality.dateBasis
+		|| quality.date_basis
+		|| quality.dateWindow?.basisDate
+		|| quality.date_window?.basis_date,
+		80
+	);
+	const expectedCurrentDate = cleanText(quality.expectedCurrentDate || quality.expected_current_date, 80)
+		|| normalizedIsoDay(input.now);
+	const noDataConfirmed = quality.noDataConfirmed === true
+		|| quality.no_data_confirmed === true
+		|| quality.confirmedNoData === true
+		|| quality.confirmed_no_data === true;
+	const legalQueryShape = assistantQueryShapeLegal(quality);
+	const queryEvidenceRequired = quality.requiresQueryEvidence !== false
+		&& quality.requires_query_evidence !== false
+		&& (queryStatus === 'ok' || queryStatus === 'no_data');
+	const queryEvidencePresent = queryExecutions.length > 0 || queryEvidenceRefs.length > 0;
+	const blockers: string[] = [];
+	let status: AssistantAnswerQualityStatus = 'ready';
+	let reason = 'Assistant answer has structured data evidence, legal query shape, citations, confidence, and next action.';
+	if (!Object.keys(quality).length) {
+		status = 'missing_data_source';
+		blockers.push('Assistant answerQuality evidence is missing.');
+		reason = 'Assistant answer cannot be accepted without structured answerQuality evidence.';
+	}
+	else if (failedChecks.length) {
+		status = 'incorrect';
+		blockers.push(...failedChecks);
+		reason = 'Assistant correctness checks failed.';
+	}
+	else if (queryStatus === 'permission_error') {
+		status = 'permission_error';
+		blockers.push('Assistant data query was blocked by permission or authorization.');
+		reason = 'Assistant must report permission-error state and avoid claiming no data or success.';
+	}
+	else if (queryStatus === 'query_error') {
+		status = 'query_error';
+		blockers.push('Assistant data query failed.');
+		reason = 'Assistant must report query-error state and avoid claiming no data or success.';
+	}
+	else if (!legalQueryShape) {
+		status = 'illegal_query_shape';
+		blockers.push('Assistant query shape is illegal or uses an unsafe Mongo projection shape.');
+		reason = 'Assistant must use legal Mongo query/projection shapes before answering.';
+	}
+	else if (requiresCurrentDate && (!dateBasis || normalizedIsoDay(dateBasis) !== normalizedIsoDay(expectedCurrentDate))) {
+		status = 'date_incorrect';
+		blockers.push(`Expected current date ${normalizedIsoDay(expectedCurrentDate) || expectedCurrentDate}, got ${dateBasis || 'missing date basis'}.`);
+		reason = 'Assistant answer did not prove it used the actual current date.';
+	}
+	else if (dateWindowRequired && !dateWindowPresent) {
+		status = 'missing_date_window';
+		blockers.push('Assistant dated answer did not record concrete date-window start and end evidence.');
+		reason = 'Assistant dated answers must record the exact query date window used.';
+	}
+	else if (queryStatus === 'unknown') {
+		status = 'missing_data_source';
+		blockers.push('Assistant answer did not record queryStatus ok/no_data/query_error/permission_error.');
+		reason = 'Assistant answer must classify data access result before acceptance.';
+	}
+	else if (queryStatus === 'no_data' && !noDataConfirmed) {
+		status = 'no_data_unverified';
+		blockers.push('No-data answer was not confirmed by a probe or query evidence.');
+		reason = 'Assistant no-data answers require explicit noDataConfirmed evidence.';
+	}
+	else if (queryEvidenceRequired && !queryEvidencePresent) {
+		status = 'missing_query_proof';
+		blockers.push('Assistant data answer did not record a structured query execution, tool result, or query evidence reference.');
+		reason = 'Assistant answers from system data require structured query/tool execution proof before acceptance.';
+	}
+	else if (requiresCitations && !citationRefs.length && !evidenceRefs.length) {
+		status = 'missing_citations';
+		blockers.push('Assistant answer has no cited evidence or artifact reference.');
+		reason = 'Assistant answer must cite system data evidence.';
+	}
+	else if (confidenceLevel === 'low' || confidenceLevel === 'unknown') {
+		status = 'low_confidence';
+		blockers.push('Assistant answer confidence is low or unknown.');
+		reason = 'Assistant answer requires recorded medium/high confidence.';
+	}
+	else if (requiresNextAction && !nextActions.length) {
+		status = 'missing_next_action';
+		blockers.push('Assistant answer did not record next actions.');
+		reason = 'Assistant answer must provide a next action or explicit no-action state.';
+	}
+	return {
+		ready: status === 'ready',
+		status,
+		reason,
+		blockers,
+		queryStatus,
+		confidenceLevel,
+		dateBasis: dateBasis || undefined,
+		expectedCurrentDate: expectedCurrentDate || undefined,
+		dateWindowRequired,
+		dateWindowPresent,
+		dateWindow: dateWindowPresent ? {
+			startDate: dateWindowStart,
+			endDate: dateWindowEnd,
+			mode: cleanText(dateWindow.mode || dateWindow.type, 80) || undefined,
+			months: typeof dateWindow.months === 'number' ? dateWindow.months : undefined
+		} : undefined,
+		noDataConfirmed,
+		legalQueryShape,
+		citationRefs,
+		queryEvidenceRequired,
+		queryEvidencePresent,
+		queryEvidenceRefs,
+		queryExecutionCount: queryExecutions.length,
+		nextActions,
+		evidenceRefs,
+		failedChecks,
+		recordedAt: now
+	};
+}
+
+function assistantAnswerQualityGate(
+	decision: AssistantAnswerQualityDecision,
+	now?: Date | string
+): AIRunGateResult {
+	const status: AIRunGateResult['status'] = decision.ready
+		? 'pass'
+		: /incorrect|date_incorrect|missing_date_window|illegal_query_shape/.test(decision.status)
+			? 'fail'
+			: 'blocked';
+	return {
+		key: 'assistant_answer_quality',
+		label: 'Assistant answer quality',
+		status,
+		reason: decision.reason,
+		evidenceRefs: decision.evidenceRefs.length ? decision.evidenceRefs : decision.citationRefs,
+		recordedAt: isoNow(now || decision.recordedAt),
+		metadata: {
+			ready: decision.ready,
+			status: decision.status,
+			queryStatus: decision.queryStatus,
+			confidenceLevel: decision.confidenceLevel,
+			dateBasis: decision.dateBasis,
+			expectedCurrentDate: decision.expectedCurrentDate,
+			dateWindowRequired: decision.dateWindowRequired,
+			dateWindowPresent: decision.dateWindowPresent,
+			dateWindow: decision.dateWindow,
+			noDataConfirmed: decision.noDataConfirmed,
+			legalQueryShape: decision.legalQueryShape,
+			citationRefs: decision.citationRefs,
+			queryEvidenceRequired: decision.queryEvidenceRequired,
+			queryEvidencePresent: decision.queryEvidencePresent,
+			queryEvidenceRefs: decision.queryEvidenceRefs,
+			queryExecutionCount: decision.queryExecutionCount,
+			nextActions: decision.nextActions,
+			blockers: decision.blockers,
+			failedChecks: decision.failedChecks
+		}
+	};
+}
+
+function applyAssistantAnswerQualityGate(
+	qa: AIQaRun,
+	decision: AssistantAnswerQualityDecision,
+	now?: Date | string
+): AIQaRun {
+	const gate = assistantAnswerQualityGate(decision, now);
+	if (decision.ready) {
+		return {
+			...qa,
+			gateResults: [...qa.gateResults, gate]
+		};
+	}
+	return {
+		...qa,
+		outcome: /incorrect|date_incorrect|missing_date_window|illegal_query_shape/.test(decision.status)
+			? 'business_assertion_failed'
+			: 'incomplete',
+		gateResults: [
+			...qa.gateResults.filter((existing) => !(existing.key === 'qa_business_assertion' && existing.status === 'pass')),
+			gate
+		]
+	};
+}
+
+export function buildSupportAIRunFromEvidence(input: SupportAIRunAdapterInput): AIRun {
+	const ticket = input.ticket || {};
+	const job = input.job || {};
+	const evidence = buildSupportQaEvidence(input);
+	const events: AIRunEvent[] = [];
+	const gates: AIRunGateResult[] = [];
+	const sourceIds: Record<string, string> = {};
+	addSourceId(sourceIds, 'ticketId', ticket._id || ticket.id || job.ticketId || job.supportTicketId);
+	addSourceId(sourceIds, 'ticketNumber', ticket.ticketNumber || ticket.number || job.ticketNumber);
+	addSourceId(sourceIds, 'jobId', job._id || job.id || job.jobId);
+	addSourceId(sourceIds, 'buildPlanId', job.buildPlanId || ticket.buildPlanId);
+
+	for (const event of asArray<Record<string, any>>(input.taskEvents)) {
+		pushEvent(events, {
+			type: event.type === 'human_intervention' ? 'human_intervention' : 'log',
+			category: cleanText(event.category || event.phase || event.type, 160),
+			message: cleanText(event.message || event.summary || event.text || event.title, 1800),
+			recordedAt: eventDate(event),
+			metadata: {
+				status: event.status,
+				phase: event.phase,
+				taskId: event.taskId || event._id || event.id
+			}
+		});
+	}
+	for (const aiJob of asArray<Record<string, any>>(input.aiJobs)) {
+		pushEvent(events, {
+			type: aiJob.model ? 'model_call' : 'log',
+			category: cleanText(aiJob.category || aiJob.phase || aiJob.runner, 160),
+			message: cleanText(aiJob.summary || aiJob.promptSummary || aiJob.status || aiJob.phase, 1800),
+			recordedAt: eventDate(aiJob),
+			metadata: {
+				id: aiJob._id || aiJob.id,
+				model: aiJob.model,
+				status: aiJob.status,
+				phase: aiJob.phase
+			}
+		});
+	}
+	collectCommitEvents(asArray<Record<string, any>>(input.commits), events);
+	collectHotfixEvidenceEvents([job, ticket, evidence, input.qaEvidence], events, gates, input.now);
+	const noBlindLoopGate = supportManagerNoBlindLoopGate(job, evidence, input.now);
+	if (noBlindLoopGate) {
+		gates.push(noBlindLoopGate);
+		pushEvent(events, {
+			type: 'log',
+			category: 'manager_no_blind_loop_policy',
+			message: noBlindLoopGate.reason,
+			artifactPaths: noBlindLoopGate.evidenceRefs,
+			recordedAt: noBlindLoopGate.recordedAt,
+			metadata: noBlindLoopGate.metadata
+		});
+	}
+	const businessProofReadiness = plainObject(evidence.businessProofReadiness || evidence.business_proof_readiness);
+	const businessProofReadinessGate = supportBusinessProofReadinessGate(businessProofReadiness, input.now);
+	if (businessProofReadinessGate) {
+		gates.push(businessProofReadinessGate);
+		pushEvent(events, {
+			type: 'qa_business_assertion',
+			category: 'support_business_proof_readiness',
+			message: businessProofReadinessGate.reason,
+			artifactPaths: businessProofReadinessGate.evidenceRefs,
+			recordedAt: businessProofReadinessGate.recordedAt,
+			metadata: businessProofReadinessGate.metadata
+		});
+	}
+	const customerReplyPolicy = plainObject(evidence.customerReplyPolicy || evidence.customer_reply_policy);
+	const customerReplyPolicyGate = supportCustomerReplyPolicyGate(customerReplyPolicy, input.now);
+	if (customerReplyPolicyGate) {
+		gates.push(customerReplyPolicyGate);
+		pushEvent(events, {
+			type: 'human_intervention',
+			category: 'support_customer_reply_policy',
+			message: customerReplyPolicyGate.reason,
+			artifactPaths: customerReplyPolicyGate.evidenceRefs,
+			recordedAt: customerReplyPolicyGate.recordedAt,
+			metadata: customerReplyPolicyGate.metadata
+		});
+	}
+	const nextActionContract = supportNextActionContractObject(ticket, job, evidence);
+	const nextActionContractRequired = supportNextActionContractRequired(ticket, job, evidence);
+	const nextActionContractGate = supportNextActionContractGate(nextActionContract, input.now, nextActionContractRequired);
+	if (nextActionContractGate) {
+		gates.push(nextActionContractGate);
+		pushEvent(events, {
+			type: 'log',
+			category: 'support_next_action_contract',
+			message: nextActionContractGate.reason,
+			artifactPaths: nextActionContractGate.evidenceRefs,
+			recordedAt: nextActionContractGate.recordedAt,
+			metadata: nextActionContractGate.metadata
+		});
+	}
+	const ticketAutomation = plainObject(ticket.automation);
+	const ticketManagerState = plainObject(ticketAutomation.manager || ticket.manager);
+	const rootCauseEntryContract = evidenceObject(
+		job.supportRootCauseEntryContract,
+		job.support_root_cause_entry_contract,
+		job.rootCauseEntryContract,
+		ticket.supportRootCauseEntryContract,
+		ticket.rootCauseEntryContract,
+		ticketManagerState.root_cause_entry_contract,
+		ticketManagerState.rootCauseEntryContract,
+		evidence.rootCauseEntryContract,
+		evidence.root_cause_entry_contract
+	);
+	const rootCauseEntryContractGate = supportRootCauseEntryContractGate(rootCauseEntryContract, input.now);
+	if (rootCauseEntryContractGate) {
+		gates.push(rootCauseEntryContractGate);
+		pushEvent(events, {
+			type: 'log',
+			category: 'support_root_cause_entry_contract',
+			message: rootCauseEntryContractGate.reason,
+			artifactPaths: rootCauseEntryContractGate.evidenceRefs,
+			recordedAt: rootCauseEntryContractGate.recordedAt,
+			metadata: rootCauseEntryContractGate.metadata
+		});
+	}
+	const cost = collectUsageEvents(asArray<Record<string, any>>(input.usageLedger), events);
+
+	const diagnosisGate = evidenceObject(
+		job.supportV5DiagnosisGate,
+		job.support_v5_diagnosis_gate,
+		job.diagnosisGate,
+		ticket.supportV5DiagnosisGate,
+		ticket.diagnosisGate,
+		evidence.diagnosisGate,
+		evidence.supportV5DiagnosisGate
+	);
+	const diagnosisEvidencePackSource = supportDiagnosisEvidencePackObject(ticket, job, evidence);
+	const similarFixHints = supportSimilarFixHintsObject(ticket, job, evidence);
+	const diagnosisEvidencePack = Object.keys(diagnosisEvidencePackSource).length
+		? diagnosisEvidencePackSource
+		: (Object.keys(diagnosisGate).length || Object.keys(similarFixHints).length)
+			? buildResolveIOSupportDiagnosisEvidencePack({
+				diagnosisGate,
+				similarCaseHints: similarFixHints,
+				issueClass: diagnosisGate.issue_class || diagnosisGate.issueClass,
+				ownerFiles: diagnosisGate.owner_files || diagnosisGate.ownerFiles,
+				text: [
+					ticket.title,
+					ticket.subject,
+					ticket.summary,
+					job.title,
+					job.summary
+				].filter(Boolean).join(' '),
+				now: input.now
+			}) as Record<string, any>
+			: {};
+	const diagnosisEvidencePackGate = supportDiagnosisEvidencePackGate(diagnosisEvidencePack, input.now);
+	if (diagnosisEvidencePackGate) {
+		gates.push(diagnosisEvidencePackGate);
+		pushEvent(events, {
+			type: 'log',
+			category: 'support_diagnosis_evidence_pack',
+			message: diagnosisEvidencePackGate.reason,
+			artifactPaths: diagnosisEvidencePackGate.evidenceRefs,
+			recordedAt: diagnosisEvidencePackGate.recordedAt,
+			metadata: diagnosisEvidencePackGate.metadata
+		});
+	}
+	const productRepairEvidence = supportProductRepairEvidence(input, evidence);
+	const diagnosisBeforeRepairGate = supportDiagnosisBeforeRepairGate(diagnosisGate, productRepairEvidence, input.now);
+	if (diagnosisBeforeRepairGate) {
+		gates.push(diagnosisBeforeRepairGate);
+		pushEvent(events, {
+			type: 'log',
+			category: 'support_diagnosis_before_repair',
+			message: diagnosisBeforeRepairGate.reason,
+			artifactPaths: diagnosisBeforeRepairGate.evidenceRefs,
+			recordedAt: diagnosisBeforeRepairGate.recordedAt,
+			metadata: diagnosisBeforeRepairGate.metadata
+		});
+	}
+	const qa = applySupportDiagnosisProofGate(buildQaFromEvidence(evidence, input.now), diagnosisGate, input.now);
+	const diagnosisOwnerFiles = asArray<string>(diagnosisGate.owner_files || diagnosisGate.ownerFiles);
+	const diagnosisIssueClass = cleanText(diagnosisGate.issue_class || diagnosisGate.issueClass, 120);
+	if (Object.keys(diagnosisGate).length) {
+		pushEvent(events, {
+			type: 'log',
+			category: 'diagnosis_gate',
+			message: cleanText(diagnosisGate.accepted_hypothesis?.statement || diagnosisGate.acceptedHypothesis?.statement || diagnosisGate.summary || 'Support diagnosis gate recorded.', 1800),
+			metadata: {
+				status: diagnosisGate.status,
+				issueClass: diagnosisIssueClass,
+				ownerFiles: diagnosisOwnerFiles
+			}
+		});
+	}
+	return buildAIRun({
+		source: 'support_ticket',
+		sourceIds,
+		title: firstText(ticket, ['title', 'subject', 'summary']) || firstText(job, ['title', 'summary']),
+		status: firstText(job, ['status', 'state']) || firstText(ticket, ['status', 'state']),
+		phase: firstText(job, ['phase', 'runnerPhase']),
+		startedAt: dateValue(job, ['startedAt', 'createdAt']) || dateValue(ticket, ['createdAt']),
+		completedAt: dateValue(job, ['completedAt', 'finishedAt', 'updatedAt']),
+		events,
+		gates,
+		qa,
+		cost,
+		scorecardPassed: evidence.scorecardPassed === true || evidence.scorecardStatus === 'pass',
+		deployStatus: evidence.deployStatus,
+		publishStatus: evidence.publishStatus,
+		sampleDataStatus: evidence.sampleDataStatus,
+		manualHandoff: evidence.manualHandoff === true || job.manualHandoff === true,
+		stopped: evidence.stopped === true || job.stopped === true,
+		rejected: evidence.rejected === true,
+		explicitAccepted: evidence.explicitAccepted === true || ticket.accepted === true,
+		terminal: /complete|closed|resolved|done|failed|rejected/i.test(`${job.status || ''} ${ticket.status || ''}`),
+		now: input.now,
+		metadata: {
+			versionCount: asArray(input.versions).length,
+			buildPlanCount: asArray(input.buildPlans).length,
+			managerNoBlindLoopPolicy: managerNoBlindLoopMetadata(noBlindLoopGate),
+			diagnosisBeforeRepair: diagnosisBeforeRepairGate ? {
+				status: diagnosisBeforeRepairGate.status,
+				diagnosisValid: diagnosisBeforeRepairGate.metadata?.diagnosisValid === true,
+				diagnosisStatus: cleanText(diagnosisBeforeRepairGate.metadata?.diagnosisStatus, 120),
+				activityCount: Number(diagnosisBeforeRepairGate.metadata?.activityCount || 0),
+				changedFiles: cleanStringList(diagnosisBeforeRepairGate.metadata?.changedFiles, 40, 500),
+				allowedDispatchAction: cleanText(diagnosisBeforeRepairGate.metadata?.allowedDispatchAction, 160),
+				productRepairAllowed: diagnosisBeforeRepairGate.metadata?.productRepairAllowed === true,
+				blockers: cleanStringList(diagnosisBeforeRepairGate.metadata?.blockers, 20, 500)
+			} : undefined,
+			rootCauseEntryContract: Object.keys(rootCauseEntryContract).length ? {
+				contractId: cleanText(rootCauseEntryContract.contract_id || rootCauseEntryContract.contractId, 160),
+				version: cleanText(rootCauseEntryContract.version, 120),
+				status: cleanText(rootCauseEntryContract.status, 120),
+				issueClassProbeCount: asArray(rootCauseEntryContract.issue_class_probes || rootCauseEntryContract.issueClassProbes).length,
+				ownerFileMax: Number(rootCauseEntryContract.owner_file_policy?.max_files || rootCauseEntryContract.ownerFilePolicy?.maxFiles || 0) || 0,
+				requiresBusinessAssertion: rootCauseEntryContract.business_proof_policy?.requires_aiqa_business_assertion === true
+					|| rootCauseEntryContract.businessProofPolicy?.requiresAiqaBusinessAssertion === true
+			} : undefined,
+			diagnosis: Object.keys(diagnosisGate).length ? {
+				status: cleanText(diagnosisGate.status, 80),
+				issueClass: diagnosisIssueClass,
+				ownerFiles: diagnosisOwnerFiles,
+				acceptedHypothesis: cleanText(diagnosisGate.accepted_hypothesis?.statement || diagnosisGate.acceptedHypothesis?.statement, 1000),
+				proofPlan: diagnosisGate.proof_plan || diagnosisGate.proofPlan
+			} : undefined,
+			diagnosisEvidencePack: diagnosisEvidencePackGate ? {
+				status: cleanText(diagnosisEvidencePackGate.metadata?.status, 120),
+				gateStatus: diagnosisEvidencePackGate.status,
+				packId: cleanText(diagnosisEvidencePackGate.metadata?.packId, 180),
+				readOnly: diagnosisEvidencePackGate.metadata?.readOnly !== false,
+				sourceEditsAllowed: diagnosisEvidencePackGate.metadata?.sourceEditsAllowed === true,
+				requiredOutputKey: cleanText(diagnosisEvidencePackGate.metadata?.requiredOutputKey, 120),
+				diagnosisValid: diagnosisEvidencePackGate.metadata?.diagnosisValid === true,
+				issueClassHint: cleanText(diagnosisEvidencePackGate.metadata?.issueClassHint, 120),
+				ownerFileHints: cleanStringList(diagnosisEvidencePackGate.metadata?.ownerFileHints, 20, 500),
+				similarHintCount: Number(diagnosisEvidencePackGate.metadata?.similarHintCount || 0),
+				similarHintsAdvisoryOnly: diagnosisEvidencePackGate.metadata?.similarHintsAdvisoryOnly === true,
+				issueClassProbeCount: Number(diagnosisEvidencePackGate.metadata?.issueClassProbeCount || 0),
+				validationBlockers: cleanStringList(diagnosisEvidencePackGate.metadata?.validationBlockers, 20, 500)
+			} : undefined,
+			businessProofReadiness: Object.keys(businessProofReadiness).length ? {
+				ready: businessProofReadiness.ready === true,
+				status: cleanText(businessProofReadiness.status, 120),
+				reason: cleanText(businessProofReadiness.reason, 1000),
+				blockers: cleanStringList(businessProofReadiness.blockers, 20, 500)
+			} : undefined,
+			nextActionContract: nextActionContractGate ? {
+				status: nextActionContractGate.status,
+				action: cleanText(nextActionContractGate.metadata?.action, 160),
+				primaryCommand: cleanText(nextActionContractGate.metadata?.primaryCommand, 240),
+				safeToAutoRun: nextActionContractGate.metadata?.safeToAutoRun === true,
+				canRunWithoutCodexMonitor: nextActionContractGate.metadata?.canRunWithoutCodexMonitor === true,
+				codexFallbackRequired: nextActionContractGate.metadata?.codexFallbackRequired === true,
+				requiresHumanApproval: nextActionContractGate.metadata?.requiresHumanApproval === true,
+				rootCauseFirstSatisfied: nextActionContractGate.metadata?.rootCauseFirstSatisfied === true,
+				hotfixCommitRequired: nextActionContractGate.metadata?.hotfixCommitRequired === true,
+				liveHotfixBlockedUntilCommit: nextActionContractGate.metadata?.liveHotfixBlockedUntilCommit === true,
+				failureClass: cleanText(nextActionContractGate.metadata?.failureClass, 120),
+				evidenceFreshnessStatus: cleanText(nextActionContractGate.metadata?.evidenceFreshnessStatus, 120),
+				sameFailureCount: Number(nextActionContractGate.metadata?.sameFailureCount || 0),
+				blockers: cleanStringList(nextActionContractGate.metadata?.blockers, 20, 500)
+			} : undefined,
+			customerReplyPolicy: Object.keys(customerReplyPolicy).length ? {
+				action: cleanText(customerReplyPolicy.action, 120),
+				safety: cleanText(customerReplyPolicy.safety, 120),
+				canDraftCustomerReply: customerReplyPolicy.canDraftCustomerReply === true || customerReplyPolicy.can_draft_customer_reply === true,
+				canSendCustomerReply: customerReplyPolicy.canSendCustomerReply === true || customerReplyPolicy.can_send_customer_reply === true,
+				reason: cleanText(customerReplyPolicy.reason, 1000),
+				reviewType: cleanText(
+					customerReplyPolicy.humanReviewPacket?.reviewType
+					|| customerReplyPolicy.human_review_packet?.review_type
+					|| customerReplyPolicy.human_review_packet?.reviewType,
+					160
+				),
+				primaryAction: cleanText(
+					customerReplyPolicy.humanReviewPacket?.primaryAction
+					|| customerReplyPolicy.human_review_packet?.primary_action
+					|| customerReplyPolicy.human_review_packet?.primaryAction,
+					160
+				)
+			} : undefined
+		}
+	});
+}
+
+export function buildAICoderAIRunFromEvidence(input: AICoderAIRunAdapterInput): AIRun {
+	const app = input.app || {};
+	const job = input.job || {};
+	const evidence = buildAICoderQaEvidence(input);
+	const events: AIRunEvent[] = [];
+	const gates: AIRunGateResult[] = [];
+	const sourceIds: Record<string, string> = {};
+	addSourceId(sourceIds, 'appId', app._id || app.id || job.appId || job.aicoderAppId);
+	addSourceId(sourceIds, 'jobId', job._id || job.id || job.jobId);
+	addSourceId(sourceIds, 'domain', app.domain || app.customDomain || job.domain);
+
+	for (const log of asArray<Record<string, any>>(input.logs)) {
+		pushEvent(events, {
+			type: log.type === 'scorecard' ? 'scorecard' : 'log',
+			category: cleanText(log.category || log.phase || log.level, 160),
+			message: cleanText(log.message || log.summary || log.text || log.title, 1800),
+			artifactPaths: asArray<string>(log.artifactPaths || log.artifacts),
+			recordedAt: eventDate(log),
+			metadata: {
+				status: log.status,
+				level: log.level,
+				score: log.score
+			}
+		});
+	}
+	collectCommitEvents(asArray<Record<string, any>>(input.commits), events);
+	collectHotfixEvidenceEvents([job, app, evidence, input.qaEvidence], events, gates, input.now);
+	const noBlindLoopGate = aicoderManagerNoBlindLoopGate(app, job, evidence, input.now);
+	if (noBlindLoopGate) {
+		gates.push(noBlindLoopGate);
+		pushEvent(events, {
+			type: 'log',
+			category: 'manager_no_blind_loop_policy',
+			message: noBlindLoopGate.reason,
+			artifactPaths: noBlindLoopGate.evidenceRefs,
+			recordedAt: noBlindLoopGate.recordedAt,
+			metadata: noBlindLoopGate.metadata
+		});
+	}
+	const cost = collectUsageEvents(asArray<Record<string, any>>(input.usageLedger), events);
+	const journeyContractValidation = aicoderJourneyContractValidationFromEvidence(evidence);
+	const journeyContractGate = aicoderJourneyContractGate(journeyContractValidation, evidence, input.now);
+	gates.push(journeyContractGate);
+	pushEvent(events, {
+		type: 'log',
+		category: 'aicoder_journey_contract',
+		message: journeyContractGate.reason,
+		artifactPaths: journeyContractGate.evidenceRefs,
+		recordedAt: journeyContractGate.recordedAt,
+		metadata: journeyContractGate.metadata
+	});
+	const scorecardPassed = evidence.scorecardPassed === true
+		|| evidence.scorecardStatus === 'pass'
+		|| (Number(evidence.score ?? evidence.qualityScore ?? 0) >= Number(evidence.scoreThreshold ?? job.scoreThreshold ?? 90));
+	const explicitWorkflowReadiness = normalizeAICoderWorkflowProofReadiness(plainObject(
+		evidence.workflowProofReadiness
+		|| evidence.workflow_proof_readiness
+		|| evidence.aicoderWorkflowProofReadiness
+		|| evidence.aicoder_workflow_proof_readiness
+		|| job.workflowProofReadiness
+		|| job.workflow_proof_readiness
+		|| job.aicoderWorkflowProofReadiness
+		|| job.aicoder_workflow_proof_readiness
+	), input.now);
+	const workflowReadiness = explicitWorkflowReadiness || evaluateResolveIOAICoderWorkflowProofReadiness({
+		journeyContract: evidence.journeyContract,
+		journeyContractMarkdown: evidence.journeyContractMarkdown,
+		workflowQaRows: asArray(evidence.workflowQaRows || evidence.workflow_qa_rows),
+		businessAssertions: [
+			...asArray(evidence.businessAssertions),
+			...asArray(evidence.business_assertions),
+			...asArray(evidence.workflowAssertions),
+			...asArray(evidence.workflow_assertions)
+		],
+		routeProbes: [
+			...asArray(evidence.routeProbes),
+			...asArray(evidence.route_probes),
+			...asArray(evidence.workflowProbes),
+			...asArray(evidence.workflow_probes)
+		],
+		artifactPaths: [
+			...asArray(evidence.artifactPaths),
+			...asArray(evidence.artifact_paths)
+		],
+		scorecardPassed,
+		deployStatus: evidence.deployStatus,
+		publishStatus: evidence.publishStatus,
+		sampleDataStatus: evidence.sampleDataStatus,
+		previousWorkflowProofFingerprint: firstNonEmptyText([
+			evidence.previousWorkflowProofFingerprint,
+			evidence.previous_workflow_proof_fingerprint,
+			job.previousWorkflowProofFingerprint,
+			job.previous_workflow_proof_fingerprint,
+			app.previousWorkflowProofFingerprint,
+			app.previous_workflow_proof_fingerprint
+		], 200),
+		previousArtifactFingerprint: firstNonEmptyText([
+			evidence.previousArtifactFingerprint,
+			evidence.previous_artifact_fingerprint,
+			job.previousArtifactFingerprint,
+			job.previous_artifact_fingerprint,
+			app.previousArtifactFingerprint,
+			app.previous_artifact_fingerprint
+		], 200),
+		previousWorkflowProofFingerprints: [
+			...asArray(evidence.previousWorkflowProofFingerprints),
+			...asArray(evidence.previous_workflow_proof_fingerprints),
+			...asArray(job.previousWorkflowProofFingerprints),
+			...asArray(job.previous_workflow_proof_fingerprints),
+			...asArray(app.previousWorkflowProofFingerprints),
+			...asArray(app.previous_workflow_proof_fingerprints)
+		],
+		previousArtifactFingerprints: [
+			...asArray(evidence.previousArtifactFingerprints),
+			...asArray(evidence.previous_artifact_fingerprints),
+			...asArray(job.previousArtifactFingerprints),
+			...asArray(job.previous_artifact_fingerprints),
+			...asArray(app.previousArtifactFingerprints),
+			...asArray(app.previous_artifact_fingerprints)
+		],
+		now: input.now
+	});
+	const workflowReadinessGate = aicoderWorkflowProofReadinessGate(workflowReadiness, input.now);
+	gates.push(workflowReadinessGate);
+	pushEvent(events, {
+		type: 'qa_business_assertion',
+		category: 'aicoder_workflow_proof_readiness',
+		message: workflowReadinessGate.reason,
+		artifactPaths: workflowReadinessGate.evidenceRefs,
+		recordedAt: workflowReadinessGate.recordedAt,
+		metadata: workflowReadinessGate.metadata
+	});
+	const workflowProofCheckpoint = aicoderWorkflowProofCheckpointObject(app, job, evidence);
+	const workflowProofCheckpointGate = aicoderWorkflowProofCheckpointGate(workflowProofCheckpoint, input.now);
+	if (workflowProofCheckpointGate) {
+		gates.push(workflowProofCheckpointGate);
+		pushEvent(events, {
+			type: 'log',
+			category: 'aicoder_workflow_proof_checkpoint',
+			message: workflowProofCheckpointGate.reason,
+			artifactPaths: workflowProofCheckpointGate.evidenceRefs,
+			recordedAt: workflowProofCheckpointGate.recordedAt,
+			metadata: workflowProofCheckpointGate.metadata
+		});
+	}
+	const qa = applyAICoderWorkflowProofGate(buildQaFromEvidence(evidence, input.now), workflowReadiness, input.now);
+
+	return buildAIRun({
+		source: 'aicoder_app',
+		sourceIds,
+		title: firstText(app, ['name', 'title']) || firstText(job, ['appName', 'title', 'goal']),
+		status: firstText(job, ['status', 'state']) || firstText(app, ['status', 'state']),
+		phase: firstText(job, ['phase', 'runnerPhase']),
+		startedAt: dateValue(job, ['startedAt', 'createdAt']) || dateValue(app, ['createdAt']),
+		completedAt: dateValue(job, ['completedAt', 'finishedAt', 'updatedAt']),
+		events,
+		gates,
+		qa,
+		cost,
+		scorecardPassed,
+		deployStatus: evidence.deployStatus || statusFromBoolean(evidence.deployReady),
+		publishStatus: evidence.publishStatus || evidence.pullRequestStatus,
+		sampleDataStatus: evidence.sampleDataStatus || statusFromBoolean(evidence.sampleDataReady ?? evidence.hasSampleData),
+		manualHandoff: evidence.manualHandoff === true || job.manualHandoff === true,
+		stopped: evidence.stopped === true || job.stopped === true,
+		rejected: evidence.rejected === true,
+		explicitAccepted: evidence.explicitAccepted === true || app.accepted === true,
+		terminal: /complete|closed|resolved|done|failed|rejected/i.test(`${job.status || ''} ${job.phase || ''}`),
+		now: input.now,
+		metadata: {
+			domain: app.domain || app.customDomain || job.domain,
+			wowScore: evidence.wowScore ?? job.wowScore,
+			score: evidence.score ?? evidence.qualityScore,
+			managerNoBlindLoopPolicy: managerNoBlindLoopMetadata(noBlindLoopGate),
+			journeyContract: {
+				status: journeyContractGate.status,
+				valid: journeyContractGate.metadata?.valid === true,
+				path: cleanText(journeyContractGate.metadata?.path, 500),
+				primaryWorkflowId: cleanText(journeyContractGate.metadata?.primaryWorkflowId, 200),
+				workflowQaRowCount: Number(journeyContractGate.metadata?.workflowQaRowCount || 0),
+				errorCount: Number(journeyContractGate.metadata?.errorCount || 0),
+				warningCount: Number(journeyContractGate.metadata?.warningCount || 0),
+				issueCodes: cleanStringList(journeyContractGate.metadata?.issueCodes, 40, 120),
+				blocksBuildUntilValid: journeyContractGate.metadata?.blocksBuildUntilValid === true,
+				blocksWorkflowQaUntilValid: journeyContractGate.metadata?.blocksWorkflowQaUntilValid === true,
+				blocksWowUiUntilWorkflowProof: journeyContractGate.metadata?.blocksWowUiUntilWorkflowProof === true,
+				blocksPublishUntilWorkflowProof: journeyContractGate.metadata?.blocksPublishUntilWorkflowProof === true,
+				nextAction: cleanText(journeyContractGate.metadata?.nextAction, 1000)
+			},
+			workflowProofReadiness: {
+				ready: workflowReadiness.ready,
+				status: workflowReadiness.status,
+				reason: workflowReadiness.reason,
+				blockers: workflowReadiness.blockers,
+				primaryWorkflowId: workflowReadiness.primaryWorkflowId,
+				passedWorkflowRows: workflowReadiness.passedWorkflowRows,
+				missingWorkflowRows: workflowReadiness.missingWorkflowRows,
+				failedWorkflowRows: workflowReadiness.failedWorkflowRows,
+				sampleDataReady: workflowReadiness.sampleDataReady,
+				releaseBlockers: workflowReadiness.releaseBlockers,
+				workflowProofFingerprint: workflowReadiness.workflowProofFingerprint,
+				artifactFingerprint: workflowReadiness.artifactFingerprint,
+				proofFreshness: workflowReadiness.proofFreshness
+			},
+			workflowProofCheckpoint: workflowProofCheckpointGate ? {
+				status: cleanText(workflowProofCheckpointGate.metadata?.status, 120),
+				gateStatus: workflowProofCheckpointGate.status,
+				readinessStatus: cleanText(workflowProofCheckpointGate.metadata?.readinessStatus, 120),
+				nextGate: cleanText(workflowProofCheckpointGate.metadata?.nextGate, 120),
+				nextAction: cleanText(workflowProofCheckpointGate.metadata?.nextAction, 1000),
+				blocksProductRepairUntilJourneyContract: workflowProofCheckpointGate.metadata?.blocksProductRepairUntilJourneyContract === true,
+				blocksPublishUntilWorkflowProof: workflowProofCheckpointGate.metadata?.blocksPublishUntilWorkflowProof === true,
+				blocksPublishUntilReleaseGate: workflowProofCheckpointGate.metadata?.blocksPublishUntilReleaseGate === true,
+				blocksWowUiUntilWorkflowProof: workflowProofCheckpointGate.metadata?.blocksWowUiUntilWorkflowProof === true,
+				workflowProofFingerprint: cleanText(workflowProofCheckpointGate.metadata?.workflowProofFingerprint, 200),
+				artifactFingerprint: cleanText(workflowProofCheckpointGate.metadata?.artifactFingerprint, 200),
+				blockers: cleanStringList(workflowProofCheckpointGate.metadata?.blockers, 20, 500)
+			} : undefined
+		}
+	});
+}
+
+export function buildAssistantAIRunFromEvidence(input: AssistantAIRunAdapterInput): AIRun {
+	const conversation = input.conversation || {};
+	const events: AIRunEvent[] = [];
+	const sourceIds: Record<string, string> = {};
+	addSourceId(sourceIds, 'runId', input.runId);
+	addSourceId(sourceIds, 'requestId', input.requestId);
+	addSourceId(sourceIds, 'messageId', input.messageId);
+	addSourceId(sourceIds, 'conversationId', conversation._id || conversation.id || conversation.conversationId);
+	addSourceId(sourceIds, 'userId', conversation.userId || conversation.ownerId);
+
+	for (const message of asArray<Record<string, any>>(input.messages)) {
+		pushEvent(events, {
+			type: 'assistant_message',
+			category: cleanText(message.role || message.authorRole || message.type, 160),
+			message: cleanText(message.content || message.text || message.message || message.summary, 1800),
+			recordedAt: eventDate(message),
+			metadata: {
+				id: message._id || message.id,
+				role: message.role,
+				model: message.model || message?.usage?.model
+			}
+		});
+	}
+	for (const report of asArray<Record<string, any>>(input.issueReports)) {
+		pushEvent(events, {
+			type: 'human_intervention',
+			category: cleanText(report.category || report.status || 'issue_report', 160),
+			message: cleanText(report.summary || report.description || report.message || report.title, 1800),
+			recordedAt: eventDate(report),
+			metadata: {
+				id: report._id || report.id,
+				status: report.status,
+				severity: report.severity
+			}
+		});
+	}
+	const cost = collectUsageEvents(asArray<Record<string, any>>(input.usageLedger), events);
+	const answerQuality = assistantQualityObject(input);
+	for (const execution of assistantQueryExecutions(answerQuality).slice(0, 40)) {
+		const status = cleanText(execution.status || execution.queryStatus || execution.query_status || execution.resultStatus || execution.result_status, 120);
+		const toolName = cleanText(execution.tool || execution.toolName || execution.tool_name || execution.type || 'query', 160);
+		const collection = cleanText(execution.collection || execution.collectionName || execution.collection_name, 240);
+		pushEvent(events, {
+			type: 'assistant_query',
+			category: status || toolName,
+			message: cleanText(execution.summary || execution.message || `${toolName}${collection ? ` ${collection}` : ''}`, 1200),
+			artifactPaths: cleanStringList([
+				execution.artifactPath,
+				execution.artifact_path,
+				execution.path,
+				...asArray(execution.artifactPaths),
+				...asArray(execution.artifact_paths)
+			], 20, 500),
+			recordedAt: eventDate(execution),
+			metadata: {
+				id: execution.id || execution._id || execution.ref,
+				tool: toolName,
+				status,
+				collection,
+				resultCount: execution.resultCount ?? execution.result_count ?? execution.count,
+				queryStatus: execution.queryStatus || execution.query_status,
+				legalQueryShape: execution.legalQueryShape ?? execution.legal_query_shape
+			}
+		});
+	}
+	const answerQualityDecision = evaluateAssistantAnswerQuality({
+		answerQuality,
+		correctnessChecks: input.correctnessChecks,
+		now: input.now
+	});
+	const answerQualityGate = assistantAnswerQualityGate(answerQualityDecision, input.now);
+	pushEvent(events, {
+		type: 'assistant_message',
+		category: 'assistant_answer_quality',
+		message: answerQualityGate.reason,
+		artifactPaths: answerQualityGate.evidenceRefs,
+		recordedAt: answerQualityGate.recordedAt,
+		metadata: answerQualityGate.metadata
+	});
+	const correctnessChecks = asArray<Record<string, any>>(input.correctnessChecks);
+	const hasPassedCorrectnessCheck = correctnessChecks.some((check) => /^(pass|passed|success|ok)$/i.test(cleanText(check.status || (check.passed === true ? 'pass' : ''), 80)));
+	const correctnessEvidence = {
+		businessAssertions: [
+			...correctnessChecks.map((check) => ({
+				assertion: check.assertion || check.name || check.case || 'assistant correctness check',
+				status: check.status || statusFromBoolean(check.passed),
+				expected: check.expected,
+				observed: check.observed || check.actual,
+				dataProof: check.dataProof || check.proof,
+				artifactPaths: check.artifactPaths,
+				message: check.message || check.reason,
+				metadata: check.metadata,
+				recordedAt: eventDate(check)
+			})),
+			...(answerQualityDecision.ready && !hasPassedCorrectnessCheck ? [{
+				assertion: 'Assistant answer quality gate passed.',
+				status: 'pass',
+				expected: 'Correct dates, legal query shape, query result classification, cited evidence, confidence, and next action.',
+				observed: answerQualityDecision.reason,
+				dataProof: answerQualityDecision.evidenceRefs.concat(answerQualityDecision.citationRefs).join(', '),
+				artifactPaths: answerQualityDecision.evidenceRefs,
+				message: answerQualityDecision.reason,
+				metadata: {
+					answerQualityStatus: answerQualityDecision.status,
+					queryStatus: answerQualityDecision.queryStatus,
+					dateWindowRequired: answerQualityDecision.dateWindowRequired,
+					dateWindowPresent: answerQualityDecision.dateWindowPresent,
+					dateWindow: answerQualityDecision.dateWindow
+				}
+			}] : [])
+		]
+	};
+	const qa = applyAssistantAnswerQualityGate(buildQaFromEvidence(correctnessEvidence, input.now), answerQualityDecision, input.now);
+	const failedReports = asArray<Record<string, any>>(input.issueReports)
+		.filter((report) => /open|new|fail|bug|wrong|incorrect|error/i.test(`${report.status || ''} ${report.category || ''} ${report.summary || ''}`));
+
+	return buildAIRun({
+		id: cleanText(input.runId, 240) || undefined,
+		source: 'ai_assistant',
+		sourceIds,
+		title: firstText(conversation, ['title', 'subject', 'summary']) || 'AI assistant conversation',
+		status: firstText(conversation, ['status', 'state']),
+		phase: firstText(conversation, ['phase']),
+		startedAt: dateValue(conversation, ['startedAt', 'createdAt']),
+		completedAt: dateValue(conversation, ['completedAt', 'closedAt', 'updatedAt']),
+		events,
+		qa,
+		cost,
+		rejected: failedReports.length > 0 || conversation.rejected === true,
+		manualHandoff: conversation.manualHandoff === true,
+		stopped: conversation.stopped === true,
+		explicitAccepted: conversation.accepted === true,
+		terminal: /complete|closed|resolved|done|failed|rejected/i.test(`${conversation.status || ''}`),
+		now: input.now,
+		metadata: {
+			issueReportCount: asArray(input.issueReports).length,
+			correctnessCheckCount: correctnessChecks.length,
+			answerQuality: {
+				ready: answerQualityDecision.ready,
+				status: answerQualityDecision.status,
+				queryStatus: answerQualityDecision.queryStatus,
+				confidenceLevel: answerQualityDecision.confidenceLevel,
+				dateBasis: answerQualityDecision.dateBasis,
+				expectedCurrentDate: answerQualityDecision.expectedCurrentDate,
+				dateWindowRequired: answerQualityDecision.dateWindowRequired,
+				dateWindowPresent: answerQualityDecision.dateWindowPresent,
+				dateWindow: answerQualityDecision.dateWindow,
+				noDataConfirmed: answerQualityDecision.noDataConfirmed,
+				legalQueryShape: answerQualityDecision.legalQueryShape,
+				citationRefs: answerQualityDecision.citationRefs,
+				queryEvidenceRequired: answerQualityDecision.queryEvidenceRequired,
+				queryEvidencePresent: answerQualityDecision.queryEvidencePresent,
+				queryEvidenceRefs: answerQualityDecision.queryEvidenceRefs,
+				queryExecutionCount: answerQualityDecision.queryExecutionCount,
+				nextActions: answerQualityDecision.nextActions,
+				blockers: answerQualityDecision.blockers
+			}
+		}
+	});
+}