@resolveio/server-lib 22.3.176 → 22.3.178

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

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