@resolveio/server-lib 22.3.197 → 22.3.198

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

@@ -1,4642 +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 {
-	buildResolveIOAIManagerHotfixDurabilityContract,
-	decideResolveIOAIManagerPolicy,
-	ResolveIOAIManagerFailureRecord,
-	validateResolveIOAIManagerRecoveryExecutionProofContract,
-	validateResolveIOAIManagerHotfixEvidence
-} from './ai-runner-manager-policy';
-import {
-	buildResolveIOSupportDiagnosisEvidencePack,
-	buildResolveIOSupportIssueClassProbePlan,
-	changedFilesOutsideResolveIOSupportDiagnosisOwnerFiles,
-	validateResolveIOSupportClarificationContract,
-	validateResolveIOSupportCustomerReplyReadinessContract,
-	validateResolveIOSupportIssueClassProbePlan,
-	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;
-}
-
-export type AssistantAnswerActionabilityStatus =
-	| 'ready_to_answer'
-	| 'needs_query_repair'
-	| 'needs_permission'
-	| 'needs_no_data_verification'
-	| 'needs_date_window_repair'
-	| 'needs_query_shape_repair'
-	| 'needs_evidence'
-	| 'needs_confidence_review'
-	| 'needs_next_action'
-	| 'incorrect'
-	| 'blocked';
-
-export interface AssistantAnswerActionabilityContract {
-	contractId: string;
-	status: AssistantAnswerActionabilityStatus;
-	primaryCommand: string;
-	label: string;
-	canAnswerCustomer: boolean;
-	canDraftSupportReply: boolean;
-	canSendCustomerReply: boolean;
-	requiresHumanReview: boolean;
-	canRunWithoutCodexMonitor: boolean;
-	codexFallbackRequired: boolean;
-	costRisk: 'free_or_deterministic' | 'small_model_or_qa' | 'expensive_model' | 'release_or_customer_send' | 'manual_blocked';
-	queryResultClass: AssistantAnswerQualityDecision['queryStatus'];
-	confidenceLevel: AssistantAnswerQualityDecision['confidenceLevel'];
-	decisionBasis: {
-		answerQualityStatus: AssistantAnswerQualityStatus;
-		queryStatus: AssistantAnswerQualityDecision['queryStatus'];
-		queryEvidencePresent: boolean;
-		noDataConfirmed: boolean;
-		legalQueryShape: boolean;
-		dateWindowRequired: boolean;
-		dateWindowPresent: boolean;
-		citationCount: number;
-		nextActionCount: number;
-	};
-	requiredEvidence: string[];
-	successEvidence: string[];
-	blockers: string[];
-	nextActions: string[];
-	nextCommands: string[];
-	forbiddenActions: string[];
-	evidenceRefs: 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 managerRecoveryExecutionProofGate(
-	proof: Record<string, any>,
-	now?: Date | string
-): AIRunGateResult | undefined {
-	if (!proof || !Object.keys(proof).length) {
-		return undefined;
-	}
-	const validation = validateResolveIOAIManagerRecoveryExecutionProofContract(proof);
-	const normalized = validation.normalized;
-	const statusText = cleanText(normalized.status, 120);
-	const gateStatus: AIRunGateResult['status'] = validation.valid && normalized.canContinueRun === true && statusText === 'proof_ready'
-		? 'pass'
-		: statusText === 'manual_handoff'
-			? 'warn'
-			: 'blocked';
-	return {
-		key: 'manager_recovery_execution_proof',
-		label: 'Manager recovery execution proof',
-		status: gateStatus,
-		reason: normalized.blockers[0] || validation.blockers[0] || statusText || 'Manager recovery execution proof recorded.',
-		evidenceRefs: normalized.artifactPaths,
-		recordedAt: isoNow(now || normalized.createdAt),
-		metadata: {
-			contractId: normalized.contractId,
-			directiveId: normalized.directiveId,
-			surface: normalized.surface,
-			dispatchAction: normalized.dispatchAction,
-			phase: normalized.phase,
-			status: statusText,
-			canContinueRun: normalized.canContinueRun,
-			canRunProductRepair: normalized.canRunProductRepair,
-			canRunExpensiveModel: normalized.canRunExpensiveModel,
-			canResetLoopBudget: normalized.canResetLoopBudget,
-			proofRequiredBeforeContinuation: normalized.proofRequiredBeforeContinuation,
-			requiresNewEvidence: normalized.requiresNewEvidence,
-			newEvidence: normalized.newEvidence,
-			materialEvidence: normalized.materialEvidence,
-			evidenceStrength: normalized.evidenceStrength,
-			evidenceSignals: normalized.evidenceSignals,
-			startingFailureClass: normalized.startingFailureClass,
-			startingBlockerFingerprint: normalized.startingBlockerFingerprint,
-			startingEvidenceHash: normalized.startingEvidenceHash,
-			latestFailureClass: normalized.latestFailureClass,
-			latestBlockerFingerprint: normalized.latestBlockerFingerprint,
-			latestEvidenceHash: normalized.latestEvidenceHash,
-			requiredEvidence: normalized.requiredEvidence,
-			missingEvidence: normalized.missingEvidence,
-			changedFiles: normalized.changedFiles,
-			blockers: Array.from(new Set([...normalized.blockers, ...validation.blockers])),
-			nextAllowedAction: normalized.nextAllowedAction,
-			forbiddenActions: normalized.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, passed gitCommitStatus, and passed gitPushStatus.'
-			: (guard.blockers.join('; ') || 'Manager hotfix is blocked until sourceCommitSha, githubCommitUrl, passed gitCommitStatus, and passed gitPushStatus prove the hotfix is committed and 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,
-			commitFirstProtocol: guard.required ? 'commit_first_hotfix' : 'not_required',
-			commitFirstProtocolSatisfied: guard.required ? guard.passed === true : true,
-			liveHotfixBlockedUntilCommit: guard.required === true && guard.passed !== true,
-			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 hotfixDurabilityContractCandidates(...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.hotfixDurabilityContract,
-			value.hotfix_durability_contract,
-			value.supportManagerHotfixDurabilityContract,
-			value.support_manager_hotfix_durability_contract,
-			value.managerRecoveryHotfixDurability,
-			value.manager_recovery_hotfix_durability,
-			value.supportV5RecoveryDirective?.hotfixDurabilityContract,
-			value.supportV5RecoveryDirective?.hotfix_durability_contract
-		].filter(Boolean);
-		if (nestedValues.length) {
-			for (const nestedValue of nestedValues) {
-				pushCandidate(nestedValue);
-			}
-		}
-		const required = value.required === true || value.liveHotfixBlockedUntilCommit === true || value.live_hotfix_blocked_until_commit === true || value.commitProofPassed === true || value.commit_proof_passed === true;
-		if (!required) {
-			return;
-		}
-		const key = cleanText(value.contractId || value.contract_id || JSON.stringify({
-			status: value.status,
-			sha: value.sourceCommitSha || value.source_commit_sha,
-			url: value.githubCommitUrl || value.github_commit_url
-		}), 500);
-		if (seen.has(key)) {
-			return;
-		}
-		seen.add(key);
-		result.push(value);
-	};
-	for (const source of sources) {
-		pushCandidate(source);
-	}
-	return result;
-}
-
-function hotfixDurabilityContractGate(
-	contractValue: Record<string, any>,
-	now?: Date | string
-): AIRunGateResult | undefined {
-	const contract = buildResolveIOAIManagerHotfixDurabilityContract({
-		existing: contractValue,
-		evidence: contractValue.evidence || contractValue.hotfixEvidence || contractValue.hotfix_evidence,
-		action: contractValue.action,
-		reason: contractValue.reason,
-		now
-	});
-	if (!contract.required) {
-		return undefined;
-	}
-	const status: AIRunGateResult['status'] = contract.liveHotfixBlockedUntilCommit
-		? 'blocked'
-		: contract.status === 'ready_for_continuation' || contract.status === 'ready_for_release_gate'
-			? 'pass'
-			: 'warn';
-	return {
-		key: 'hotfix_durability_contract',
-		label: 'Hotfix durability contract',
-		status,
-		reason: contract.liveHotfixBlockedUntilCommit
-			? `Manager hotfix is blocked until GitHub commit proof is recorded: ${contract.missingCommitProofFields.join(', ') || 'sourceCommitSha, githubCommitUrl, gitCommitStatus=passed, gitPushStatus=passed'}`
-			: `Manager hotfix durability contract is ${contract.status}.`,
-		evidenceRefs: cleanStringList([contract.githubCommitUrl], 1, 500),
-		recordedAt: isoNow(now || contract.updatedAt),
-		metadata: {
-			contractId: contract.contractId,
-			status: contract.status,
-			nextSafeAction: contract.nextSafeAction,
-			canPrepareHotfixPatch: contract.canPrepareHotfixPatch,
-			canHotfixBackend: contract.canHotfixBackend,
-			liveHotfixBlockedUntilCommit: contract.liveHotfixBlockedUntilCommit,
-			durabilityProtocol: contract.durabilityProtocol,
-			commitFirstProtocolRequired: contract.commitFirstProtocolRequired,
-			commitFirstProtocolSatisfied: contract.commitFirstProtocolSatisfied,
-			liveHotfixAllowed: contract.liveHotfixAllowed,
-			managerContinuationAllowed: contract.managerContinuationAllowed,
-			commitProofPassed: contract.commitProofPassed,
-			commitProofStatus: contract.commitProofStatus,
-			missingCommitProofFields: contract.missingCommitProofFields,
-			sourceCommitSha: contract.sourceCommitSha,
-			githubCommitUrl: contract.githubCommitUrl,
-			gitCommitStatus: contract.gitCommitStatus,
-			gitPushStatus: contract.gitPushStatus,
-			phaseOrder: contract.phaseOrder,
-			requiredFields: contract.requiredFields,
-			forbiddenActions: contract.forbiddenActions
-		}
-	};
-}
-
-function collectHotfixEvidenceEvents(
-	sources: any[],
-	events: AIRunEvent[],
-	gates: AIRunGateResult[],
-	now?: Date | string
-): void {
-	for (const contract of hotfixDurabilityContractCandidates(...sources)) {
-		const gate = hotfixDurabilityContractGate(contract, now);
-		if (gate) {
-			gates.push(gate);
-			pushEvent(events, {
-				type: 'log',
-				category: 'hotfix_durability_contract',
-				message: gate.reason,
-				artifactPaths: gate.evidenceRefs,
-				recordedAt: gate.recordedAt,
-				metadata: gate.metadata
-			});
-		}
-	}
-	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 hotfixDurabilityMetadata(gates: AIRunGateResult[]): Record<string, any> | undefined {
-	const hotfixGate = gates.find((gate) => gate.key === 'hotfix_evidence');
-	const commitGate = gates.find((gate) => gate.key === 'hotfix_commit_proof');
-	const durabilityGate = gates.find((gate) => gate.key === 'hotfix_durability_contract');
-	if (!hotfixGate && !commitGate && !durabilityGate) {
-		return undefined;
-	}
-	const commitBlocked = (!!commitGate && (commitGate.status === 'blocked' || commitGate.status === 'fail'))
-		|| durabilityGate?.metadata?.liveHotfixBlockedUntilCommit === true;
-	return {
-		durabilityStatus: cleanText(durabilityGate?.metadata?.status, 80),
-		durabilityGateStatus: cleanText(durabilityGate?.status, 80),
-		canPrepareHotfixPatch: durabilityGate?.metadata?.canPrepareHotfixPatch === true,
-		canHotfixBackend: durabilityGate?.metadata?.canHotfixBackend === true,
-		liveHotfixBlockedUntilCommit: durabilityGate?.metadata?.liveHotfixBlockedUntilCommit === true,
-		durabilityProtocol: cleanText(durabilityGate?.metadata?.durabilityProtocol, 120),
-		commitFirstProtocolRequired: durabilityGate?.metadata?.commitFirstProtocolRequired === true,
-		commitFirstProtocolSatisfied: durabilityGate?.metadata?.commitFirstProtocolSatisfied === true || commitGate?.metadata?.commitFirstProtocolSatisfied === true,
-		liveHotfixAllowed: durabilityGate?.metadata?.liveHotfixAllowed === true || (hotfixGate?.metadata?.hotfixSatisfied === true && commitGate?.metadata?.commitFirstProtocolSatisfied === true),
-		managerContinuationAllowed: durabilityGate?.metadata?.managerContinuationAllowed === true,
-		hotfixEvidenceStatus: cleanText(hotfixGate?.status, 80),
-		hotfixSatisfied: hotfixGate?.metadata?.hotfixSatisfied === true,
-		fullDeployBlocked: hotfixGate?.metadata?.fullDeployBlocked === true,
-		fullDeployAllowed: hotfixGate?.metadata?.fullDeployAllowed === true,
-		commitProofRequired: !!commitGate || !!durabilityGate,
-		commitProofStatus: cleanText(commitGate?.status || durabilityGate?.metadata?.commitProofStatus, 80),
-		commitProofPassed: commitGate?.metadata?.passed === true || durabilityGate?.metadata?.commitProofPassed === true,
-		commitBlocked,
-		channel: cleanText(commitGate?.metadata?.channel || hotfixGate?.metadata?.channel, 120),
-		sourceCommitSha: cleanText(commitGate?.metadata?.sourceCommitSha || durabilityGate?.metadata?.sourceCommitSha, 200),
-		githubCommitUrl: cleanText(commitGate?.metadata?.githubCommitUrl || durabilityGate?.metadata?.githubCommitUrl, 500),
-		gitCommitStatus: cleanText(commitGate?.metadata?.gitCommitStatus || durabilityGate?.metadata?.gitCommitStatus, 120),
-		gitPushStatus: cleanText(commitGate?.metadata?.gitPushStatus || durabilityGate?.metadata?.gitPushStatus, 120),
-		blockers: cleanStringList([
-			...asArray(durabilityGate?.metadata?.missingCommitProofFields),
-			...asArray(commitGate?.metadata?.blockers),
-			...asArray(hotfixGate?.metadata?.blockers)
-		], 20, 500),
-		requiredEvidence: cleanStringList(commitGate?.metadata?.requiredEvidence || durabilityGate?.metadata?.requiredFields, 20, 500),
-		nextCommands: cleanStringList(commitGate?.metadata?.nextCommands, 20, 240),
-		nextAction: commitBlocked
-			? cleanText(durabilityGate?.metadata?.nextSafeAction, 200) || 'Commit and push the hotfix to GitHub, record sourceCommitSha/githubCommitUrl/gitCommitStatus/gitPushStatus, then rerun the smallest verification gate.'
-			: cleanText(hotfixGate?.metadata?.nextAction, 1000)
-	};
-}
-
-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 costObservabilityGate(cost: AIRunCost | undefined, source: AIRun['source'], now?: Date | string): AIRunGateResult {
-	const manualEstimatedUsd = Number(cost?.manualEstimatedUsd || 0);
-	const untrackedEstimatedUsd = Number(cost?.untrackedEstimatedUsd || 0);
-	const warnings = cleanStringList(cost?.untrackedWarnings, 20, 500);
-	const manualSources = Object.entries(cost?.sources || {})
-		.filter(([, value]) => Number(value.manualCount || 0) > 0)
-		.map(([key]) => key);
-	const untrackedSources = Object.entries(cost?.sources || {})
-		.filter(([, value]) => Number(value.untrackedCount || 0) > 0)
-		.map(([key]) => key);
-	const missingLedger = !cost;
-	const externalCodexMonitorUsed = manualEstimatedUsd > 0
-		|| untrackedEstimatedUsd > 0
-		|| manualSources.some((sourceKey) => /codex|manual/i.test(sourceKey))
-		|| warnings.some((warning) => /codex|sidecar|monitor/i.test(warning));
-	const status: AIRunGateResult['status'] = missingLedger
-		? 'skipped'
-		: (manualEstimatedUsd > 0 || untrackedEstimatedUsd > 0 || warnings.length ? 'warn' : 'pass');
-	return {
-		key: 'cost_observability',
-		label: 'Cost observability',
-		status,
-		reason: missingLedger
-			? 'No usage ledger was supplied for this run, so cost per accepted run cannot be fully evaluated.'
-			: status === 'warn'
-				? `Runner cost includes manual or untracked usage: manual=$${manualEstimatedUsd.toFixed(2)}, untracked=$${untrackedEstimatedUsd.toFixed(2)}.`
-				: 'Runner usage is tracked in the unified cost ledger.',
-		evidenceRefs: warnings,
-		recordedAt: isoNow(now),
-		metadata: {
-			source,
-			missingLedger,
-			estimatedUsd: Number(cost?.estimatedUsd || 0),
-			manualEstimatedUsd,
-			untrackedEstimatedUsd,
-			externalCodexMonitorUsed,
-			manualSources,
-			untrackedSources,
-			models: cleanStringList(cost?.models, 40, 120),
-			categories: Object.keys(cost?.categories || {}).slice(0, 40),
-			surfaces: Object.keys(cost?.surfaces || {}).slice(0, 40),
-			warnings
-		}
-	};
-}
-
-function costObservabilityMetadata(gate: AIRunGateResult | undefined): Record<string, any> | undefined {
-	if (!gate) {
-		return undefined;
-	}
-	return {
-		status: gate.status,
-		missingLedger: gate.metadata?.missingLedger === true,
-		estimatedUsd: Number(gate.metadata?.estimatedUsd || 0),
-		manualEstimatedUsd: Number(gate.metadata?.manualEstimatedUsd || 0),
-		untrackedEstimatedUsd: Number(gate.metadata?.untrackedEstimatedUsd || 0),
-		externalCodexMonitorUsed: gate.metadata?.externalCodexMonitorUsed === true,
-		manualSources: cleanStringList(gate.metadata?.manualSources, 20, 120),
-		untrackedSources: cleanStringList(gate.metadata?.untrackedSources, 20, 120),
-		models: cleanStringList(gate.metadata?.models, 40, 120),
-		categories: cleanStringList(gate.metadata?.categories, 40, 120),
-		surfaces: cleanStringList(gate.metadata?.surfaces, 40, 120),
-		warnings: cleanStringList(gate.metadata?.warnings, 20, 500),
-		nextAction: gate.status === 'warn'
-			? 'Record manual Codex sidecar usage in the unified ledger and replace external monitoring with a validated next-action contract.'
-			: gate.status === 'skipped'
-				? 'Attach runner, assistant, manual Codex, retry, and deploy usage rows before comparing cost per accepted run.'
-				: 'Continue tracking cost in the unified ledger.'
-	};
-}
-
-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 supportOwnerFileScopeGate(
-	diagnosisGate: Record<string, any>,
-	repairEvidence: ReturnType<typeof supportProductRepairEvidence>,
-	now?: Date | string
-): AIRunGateResult | undefined {
-	if (!repairEvidence.attempted) {
-		return undefined;
-	}
-	const validation = validateResolveIOSupportDiagnosisGate(diagnosisGate);
-	if (!validation.valid || !validation.normalized) {
-		return undefined;
-	}
-	const outsideOwnerFiles = changedFilesOutsideResolveIOSupportDiagnosisOwnerFiles(
-		validation.normalized,
-		repairEvidence.changedFiles,
-		{ allowTests: true }
-	);
-	const status: AIRunGateResult['status'] = outsideOwnerFiles.length ? 'blocked' : 'pass';
-	return {
-		key: 'support_owner_file_scope',
-		label: 'Support owner-file scope',
-		status,
-		reason: outsideOwnerFiles.length
-			? `Support repair changed files outside diagnosis owner_files; revise diagnosis with new evidence before broadening edits: ${outsideOwnerFiles.join(', ')}`
-			: 'Support repair stayed within diagnosis owner_files; test-only changes are allowed as supporting evidence.',
-		evidenceRefs: outsideOwnerFiles.length ? outsideOwnerFiles : repairEvidence.changedFiles,
-		recordedAt: isoNow(now),
-		metadata: {
-			repairAttempted: true,
-			diagnosisValid: true,
-			issueClass: validation.normalized.issue_class,
-			ownerFiles: validation.normalized.owner_files,
-			changedFiles: repairEvidence.changedFiles,
-			outsideOwnerFiles,
-			allowedTestFilesOutsideOwnerScope: true,
-			productRepairAllowed: outsideOwnerFiles.length === 0,
-			allowedDispatchAction: outsideOwnerFiles.length ? 'run_read_only_diagnosis' : 'run_business_proof_qa',
-			requiredEvidence: outsideOwnerFiles.length
-				? ['revised SupportDiagnosisGate with evidence for each new owner file', 'updated failing_path and proof_plan matching broadened scope']
-				: ['compile/unit proof', 'AIQaBusinessAssertion mapped to diagnosis proof_plan']
-		}
-	};
-}
-
-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 ticketAutomation = plainObject(ticket.automation);
-	const ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
-	const preflightGate = supportPreflightGateObject(ticket, job, {
-		...plainObject(input.qaEvidence),
-		supportV5AutonomousDecision: autonomousDecision
-	});
-	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 customerReplyReadiness = plainObject(
-		autonomousDecision.customerReplyReadiness
-		|| autonomousDecision.customer_reply_readiness
-		|| customerReplyPolicy.readinessContract
-		|| customerReplyPolicy.readiness_contract
-		|| job.customerReplyReadiness
-		|| job.customer_reply_readiness
-	);
-	const managerRecoveryExecutionProof = plainObject(
-		job.managerRecoveryExecutionProof
-		|| job.manager_recovery_execution_proof
-		|| job.supportManagerRecoveryExecutionProof
-		|| job.support_manager_recovery_execution_proof
-		|| autonomousDecision.recoveryExecutionProof
-		|| autonomousDecision.recovery_execution_proof
-		|| ticketManager.last_recovery_execution_proof
-		|| ticketManager.recovery_execution_proof
-	);
-	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 };
-	}
-	if (Object.keys(customerReplyReadiness).length) {
-		evidence.customerReplyReadiness = customerReplyReadiness;
-	}
-	if (Object.keys(managerRecoveryExecutionProof).length) {
-		evidence.managerRecoveryExecutionProof = managerRecoveryExecutionProof;
-	}
-	if (Object.keys(preflightGate).length) {
-		evidence.supportV5PreflightGate = preflightGate;
-		applySupportPreflightGateToQaEvidence(evidence, preflightGate);
-	}
-	return evidence;
-}
-
-function supportPreflightGateObject(ticket: Record<string, any>, job: Record<string, any>, evidence: Record<string, any>): Record<string, any> {
-	const autonomousDecision = plainObject(
-		job.supportV5AutonomousDecision
-		|| job.support_v5_autonomous_decision
-		|| evidence.supportV5AutonomousDecision
-		|| evidence.support_v5_autonomous_decision
-		|| ticket.supportV5AutonomousDecision
-		|| ticket.support_v5_autonomous_decision
-	);
-	const ticketAutomation = plainObject(ticket.automation);
-	const ticketManager = plainObject(ticketAutomation.manager || ticket.manager);
-	return evidenceObject(
-		job.supportV5PreflightGate,
-		job.support_v5_preflight_gate,
-		job.preflightGate,
-		job.preflight_gate,
-		evidence.supportV5PreflightGate,
-		evidence.support_v5_preflight_gate,
-		evidence.preflightGate,
-		evidence.preflight_gate,
-		autonomousDecision.preflightGate,
-		autonomousDecision.preflight_gate,
-		autonomousDecision.rootCauseReadiness?.preflightGate,
-		autonomousDecision.root_cause_readiness?.preflight_gate,
-		ticket.supportV5PreflightGate,
-		ticket.support_v5_preflight_gate,
-		ticketManager.supportV5PreflightGate,
-		ticketManager.support_v5_preflight_gate,
-		ticketManager.preflightGate,
-		ticketManager.preflight_gate
-	);
-}
-
-function supportPreflightStatus(value: any): string {
-	return cleanText(value, 120).toLowerCase();
-}
-
-function supportPreflightFailedChecks(preflightGate: Record<string, any>): Record<string, any>[] {
-	const failed = [
-		...asArray<Record<string, any>>(preflightGate.failedChecks || preflightGate.failed_checks),
-		...asArray<Record<string, any>>(preflightGate.checks).filter((check) => {
-			const status = supportPreflightStatus(check.status || check.state || check.outcome);
-			return /fail|failed|blocked|missing|error/.test(status);
-		})
-	];
-	const seen = new Set<string>();
-	return failed.filter((check) => {
-		const key = `${cleanText(check.name || check.check || check.key, 160)}:${cleanText(check.summary || check.message || check.error || check.reason, 500)}`;
-		if (seen.has(key)) {
-			return false;
-		}
-		seen.add(key);
-		return true;
-	});
-}
-
-function supportPreflightArtifactPaths(preflightGate: Record<string, any>, checks: Record<string, any>[]): string[] {
-	return Array.from(new Set([
-		...cleanStringList(preflightGate.artifactPaths || preflightGate.artifact_paths, 60, 500),
-		...checks.flatMap((check) => cleanStringList(check.artifactPaths || check.artifact_paths || check.artifacts, 20, 500)),
-		...checks.map((check) => cleanText(check.artifactPath || check.artifact_path || check.path || check.file, 500)).filter(Boolean)
-	])).slice(0, 80);
-}
-
-function supportPreflightCheckMessage(check: Record<string, any>): string {
-	return cleanText(check.summary || check.message || check.error || check.reason || check.status, 1000);
-}
-
-function applySupportPreflightGateToQaEvidence(evidence: Record<string, any>, preflightGate: Record<string, any>): void {
-	const status = supportPreflightStatus(preflightGate.status);
-	const failureClass = supportPreflightStatus(preflightGate.failureClass || preflightGate.failure_class);
-	const failedChecks = supportPreflightFailedChecks(preflightGate);
-	const artifactPaths = supportPreflightArtifactPaths(preflightGate, failedChecks);
-	const compileResult = plainObject(preflightGate.compileResult || preflightGate.compile_result);
-	const compileFailed = status === 'compile_failed'
-		|| failureClass === 'compile'
-		|| cleanText(compileResult.failureClass || compileResult.failure_class, 120).toLowerCase() === 'compile'
-		|| failedChecks.some((check) => {
-			const name = supportPreflightStatus(check.name || check.check || check.key);
-			const checkClass = supportPreflightStatus(check.failureClass || check.failure_class);
-			return name === 'compile' || checkClass === 'compile';
-		});
-	if (compileFailed) {
-		const compileCheck = Object.keys(compileResult).length ? compileResult : failedChecks[0] || {};
-		evidence.compile = {
-			...plainObject(evidence.compile || evidence.build || evidence.buildResult || evidence.build_result),
-			status: cleanText(compileCheck.status || preflightGate.status || 'fail', 80) || 'fail',
-			command: cleanText(compileCheck.command || preflightGate.command || preflightGate.nextCommand || preflightGate.next_command, 500),
-			artifactPath: artifactPaths[0] || cleanText(compileCheck.artifactPath || compileCheck.artifact_path || compileCheck.path, 500),
-			message: supportPreflightCheckMessage(compileCheck) || cleanText(preflightGate.reason || preflightGate.blockers?.[0] || 'Support compile preflight failed before browser QA.', 1000),
-			metadata: {
-				source: 'supportV5PreflightGate',
-				preflightStatus: status,
-				preflightEvidenceHash: cleanText(preflightGate.evidenceHash || preflightGate.evidence_hash, 200),
-				nextCommand: cleanText(preflightGate.nextCommand || preflightGate.next_command, 180)
-			}
-		};
-		return;
-	}
-	const blocksRepair = preflightGate.blocksProductRepair === true || preflightGate.blocks_product_repair === true || /infra_failed|blocked|missing/.test(status);
-	const checks = failedChecks.length
-		? failedChecks
-		: Object.keys(preflightGate).length && (blocksRepair || status === 'passed')
-			? [{
-				name: 'support_preflight',
-				status: status === 'passed' ? 'pass' : 'blocked',
-				summary: cleanStringList(preflightGate.blockers, 4, 500).join('; ') || cleanText(preflightGate.reason || preflightGate.status, 1000),
-				artifactPaths
-			}]
-			: [];
-	if (!checks.length) {
-		return;
-	}
-	evidence.infraChecks = [
-		...asArray(evidence.infraChecks),
-		...checks.map((check) => ({
-			name: cleanText(check.name || check.check || check.key, 160) || 'support_preflight',
-			status: cleanText(check.status || check.state || check.outcome || (status === 'passed' ? 'pass' : 'blocked'), 80),
-			message: supportPreflightCheckMessage(check) || cleanStringList(preflightGate.blockers, 3, 500).join('; '),
-			path: cleanText(check.path || check.artifactPath || check.artifact_path, 500) || artifactPaths[0],
-			metadata: {
-				source: 'supportV5PreflightGate',
-				preflightStatus: status,
-				preflightFailureClass: failureClass,
-				preflightEvidenceHash: cleanText(preflightGate.evidenceHash || preflightGate.evidence_hash, 200),
-				nextCommand: cleanText(preflightGate.nextCommand || preflightGate.next_command, 180)
-			}
-		}))
-	];
-}
-
-function supportPreflightGateResult(
-	preflightGate: Record<string, any>,
-	now?: Date | string
-): AIRunGateResult | undefined {
-	if (!preflightGate || !Object.keys(preflightGate).length) {
-		return undefined;
-	}
-	const statusText = supportPreflightStatus(preflightGate.status);
-	const ready = preflightGate.ready === true;
-	const blocksProductRepair = preflightGate.blocksProductRepair === true || preflightGate.blocks_product_repair === true;
-	const failedChecks = supportPreflightFailedChecks(preflightGate);
-	const artifactPaths = supportPreflightArtifactPaths(preflightGate, failedChecks);
-	const gateStatus: AIRunGateResult['status'] = ready || statusText === 'passed'
-		? 'pass'
-		: /compile_failed|infra_failed|fail|failed/.test(statusText)
-			? 'fail'
-			: blocksProductRepair || /missing|blocked/.test(statusText)
-				? 'blocked'
-				: 'warn';
-	const blockers = cleanStringList(preflightGate.blockers, 20, 500);
-	return {
-		key: 'support_preflight_gate',
-		label: 'Support preflight gate',
-		status: gateStatus,
-		reason: gateStatus === 'pass'
-			? 'Support deterministic preflight passed before product-code repair.'
-			: cleanText(blockers.join('; ') || preflightGate.reason || `Support deterministic preflight is ${statusText || 'not ready'} before product-code repair.`, 1200),
-		evidenceRefs: artifactPaths,
-		recordedAt: isoNow(now || preflightGate.recordedAt || preflightGate.recorded_at),
-		metadata: {
-			ready,
-			required: preflightGate.required === true,
-			status: statusText,
-			failureClass: cleanText(preflightGate.failureClass || preflightGate.failure_class, 120),
-			nextCommand: cleanText(preflightGate.nextCommand || preflightGate.next_command, 180),
-			blocksProductRepair,
-			blocksModelRepair: preflightGate.blocksModelRepair === true || preflightGate.blocks_model_repair === true,
-			failedChecks: failedChecks.map((check) => cleanText(check.name || check.check || check.key, 160)).filter(Boolean),
-			requiredEvidence: cleanStringList(preflightGate.requiredEvidence || preflightGate.required_evidence, 20, 500),
-			evidenceHash: cleanText(preflightGate.evidenceHash || preflightGate.evidence_hash, 200)
-		}
-	};
-}
-
-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 draftBasis = plainObject(policy.draftBasis || policy.draft_basis);
-	const clarificationValidation = validateResolveIOSupportClarificationContract(policy.clarificationContract || policy.clarification_contract || {});
-	const clarificationContract = clarificationValidation.normalized;
-	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
-				? (clarificationValidation.valid ? 'warn' : 'blocked')
-				: 'blocked';
-	const mergedBlockers = Array.from(new Set([
-		...blockers,
-		...(action === 'ask_clarification' ? clarificationValidation.blockers : [])
-	]));
-	return {
-		key: 'support_customer_reply_policy',
-		label: 'Support customer reply policy',
-		status: gateStatus,
-		reason: reason || mergedBlockers.join('; ') || 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),
-			issueClass: cleanText(draftBasis.issueClass || draftBasis.issue_class, 120),
-			issueClassProbePlanId: cleanText(draftBasis.issueClassProbePlanId || draftBasis.issue_class_probe_plan_id, 180),
-			issueClassProbePlanStatus: cleanText(draftBasis.issueClassProbePlanStatus || draftBasis.issue_class_probe_plan_status, 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),
-			clarificationContractStatus: cleanText(clarificationContract.status, 120),
-			clarificationMissingField: cleanText(clarificationContract.missingField, 120),
-			clarificationOneQuestionOnly: clarificationContract.oneQuestionOnly === true,
-			clarificationParksTicket: clarificationContract.parksTicketUntilCustomerReply === true,
-			blockers: mergedBlockers
-		}
-	};
-}
-
-function supportCustomerReplyReadinessGate(
-	contract: Record<string, any>,
-	now?: Date | string
-): AIRunGateResult | undefined {
-	if (!contract || !Object.keys(contract).length) {
-		return undefined;
-	}
-	const validation = validateResolveIOSupportCustomerReplyReadinessContract(contract);
-	const normalized = validation.normalized;
-	const status = cleanText(normalized.status, 120);
-	const gateStatus: AIRunGateResult['status'] = normalized.canSendCustomerReply
-		? 'blocked'
-		: validation.valid && (status === 'draft_ready' || status === 'clarification_required')
-			? 'warn'
-			: 'blocked';
-	return {
-		key: 'support_customer_reply_readiness',
-		label: 'Support customer reply readiness',
-		status: gateStatus,
-		reason: normalized.reason || validation.blockers.join('; ') || status || 'Support customer reply readiness recorded.',
-		evidenceRefs: normalized.evidenceRefs,
-		recordedAt: isoNow(now || normalized.createdAt),
-		metadata: {
-			contractId: normalized.contractId,
-			status,
-			policyAction: normalized.policyAction,
-			reviewType: normalized.reviewType,
-			primaryCommand: normalized.primaryCommand,
-			canDraftCustomerReply: normalized.canDraftCustomerReply,
-			canSendCustomerReply: normalized.canSendCustomerReply,
-			requiresHumanApproval: normalized.requiresHumanApproval,
-			proofBacked: normalized.proofBacked,
-			businessProofReady: normalized.businessProofReady,
-			releaseReady: normalized.releaseReady,
-			diagnosisReady: normalized.diagnosisReady,
-			issueClassProbePlanReady: normalized.issueClassProbePlanReady,
-			clarificationRequired: normalized.clarificationRequired,
-			blockers: Array.from(new Set([
-				...normalized.blockers,
-				...validation.blockers
-			])),
-			requiredEvidence: normalized.requiredEvidence,
-			nextCommands: normalized.nextCommands,
-			forbiddenActions: normalized.forbiddenActions
-		}
-	};
-}
-
-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),
-		preflightReady: booleanFlag(decisionBasis.preflightReady ?? decisionBasis.preflight_ready),
-		preflightStatus: cleanText(decisionBasis.preflightStatus || decisionBasis.preflight_status, 120),
-		preflightFailureClass: cleanText(decisionBasis.preflightFailureClass || decisionBasis.preflight_failure_class, 120),
-		preflightEvidenceHash: cleanText(decisionBasis.preflightEvidenceHash || decisionBasis.preflight_evidence_hash, 200),
-		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 supportIssueClassProbePlanObject(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.issueClassProbePlan,
-		autonomousDecision.issue_class_probe_plan,
-		job.supportV5IssueClassProbePlan,
-		job.support_v5_issue_class_probe_plan,
-		job.issueClassProbePlan,
-		job.issue_class_probe_plan,
-		evidence.supportV5IssueClassProbePlan,
-		evidence.support_v5_issue_class_probe_plan,
-		evidence.issueClassProbePlan,
-		evidence.issue_class_probe_plan,
-		ticket.supportV5IssueClassProbePlan,
-		ticket.support_v5_issue_class_probe_plan,
-		ticket.issueClassProbePlan,
-		ticket.issue_class_probe_plan,
-		ticketManager.issueClassProbePlan,
-		ticketManager.issue_class_probe_plan
-	);
-}
-
-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 supportIssueClassProbePlanGate(plan: Record<string, any>, diagnosisGate: Record<string, any>, now?: Date | string, required = false): AIRunGateResult | undefined {
-	if (!plan || !Object.keys(plan).length) {
-		if (!required) {
-			return undefined;
-		}
-		const blocker = 'Support V5 run is missing IssueClassProbePlan, so business proof cannot be accepted from route-only or generic QA.';
-		return {
-			key: 'support_issue_class_probe_plan',
-			label: 'Support issue-class probe plan',
-			status: 'blocked',
-			reason: blocker,
-			evidenceRefs: [],
-			recordedAt: isoNow(now),
-			metadata: {
-				required: true,
-				missingPlan: true,
-				issueClassProbePlanReady: false,
-				acceptanceGate: 'aiqa_business_assertion',
-				blockers: [blocker],
-				falsePassBlockers: ['route load only', 'generic clickthrough only', 'scorecard-only pass']
-			}
-		};
-	}
-	const validation = validateResolveIOSupportIssueClassProbePlan(plan, diagnosisGate, now);
-	const normalized = plainObject(validation.normalized || plan);
-	const activeProbe = plainObject(validation.activeProbe || normalized.activeProbe || normalized.active_probe);
-	const blockers = cleanStringList(validation.blockers || normalized.blockers, 40, 500);
-	const requiredArtifacts = cleanStringList(
-		normalized.requiredArtifacts
-		|| normalized.required_artifacts
-		|| activeProbe.required_artifacts,
-		30,
-		500
-	);
-	const falsePassBlockers = cleanStringList(
-		normalized.falsePassBlockers
-		|| normalized.false_pass_blockers
-		|| activeProbe.false_pass_blockers,
-		30,
-		500
-	);
-	const status: AIRunGateResult['status'] = validation.valid ? 'pass' : 'blocked';
-	const issueClass = cleanText(normalized.issue_class || normalized.issueClass || activeProbe.issue_class, 120);
-	const route = cleanText(activeProbe.route, 500);
-	const action = cleanText(activeProbe.action, 1000);
-	return {
-		key: 'support_issue_class_probe_plan',
-		label: 'Support issue-class probe plan',
-		status,
-		reason: validation.valid
-			? `Support issue-class probe plan is ready for ${issueClass || 'the diagnosed issue'} and requires AIQaBusinessAssertion proof.`
-			: blockers.join('; ') || 'Support issue-class probe plan is incomplete.',
-		evidenceRefs: requiredArtifacts,
-		recordedAt: isoNow(now || normalized.generatedAt || normalized.generated_at),
-		metadata: {
-			planId: cleanText(normalized.planId || normalized.plan_id, 180),
-			status: cleanText(validation.status || normalized.status, 120),
-			issueClass,
-			diagnosisValid: normalized.diagnosisValid === true || normalized.diagnosis_valid === true,
-			issueClassProbePlanReady: validation.valid === true && validation.status === 'ready',
-			activeRoute: route,
-			action,
-			expectedEvidence: cleanText(activeProbe.expected_evidence || activeProbe.expectedEvidence, 1200),
-			expectedBusinessProof: cleanText(activeProbe.expected_business_proof || activeProbe.expectedBusinessProof, 1200),
-			acceptanceGate: cleanText(normalized.acceptanceGate || normalized.acceptance_gate || activeProbe.acceptance_gate, 120),
-			requiredArtifacts,
-			falsePassBlockers,
-			blockers,
-			activeProbe: {
-				issueClass,
-				route,
-				action,
-				probeType: cleanText(activeProbe.probe_type || activeProbe.probeType, 120),
-				failureClass: cleanText(activeProbe.failure_class || activeProbe.failureClass, 120),
-				blocksAcceptanceWithoutBusinessAssertion: activeProbe.blocks_acceptance_without_business_assertion === true
-					|| activeProbe.blocksAcceptanceWithoutBusinessAssertion === true
-			}
-		}
-	};
-}
-
-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,
-			workflowQaCoverageTags: cleanStringList(validation.workflowQaRows.flatMap((row: any) => asArray(row.coverageTags || row.coverage_tags)), 80, 120),
-			workflowQaProofKinds: cleanStringList(validation.workflowQaRows.map((row: any) => row.proofKind || row.proof_kind), 80, 120),
-			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 aicoderNextActionContractObject(app: Record<string, any>, job: Record<string, any>, evidence: Record<string, any>): Record<string, any> {
-	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.nextActionContract,
-		continuationDecision.next_action_contract,
-		job.nextActionContract,
-		job.next_action_contract,
-		job.aicoderNextActionContract,
-		job.aicoder_next_action_contract,
-		job.aiCoderNextActionContract,
-		job.ai_coder_next_action_contract,
-		app.nextActionContract,
-		app.next_action_contract,
-		evidence.nextActionContract,
-		evidence.next_action_contract,
-		evidence.aicoderNextActionContract,
-		evidence.aicoder_next_action_contract
-	);
-}
-
-function aicoderNextActionContractGate(contract: Record<string, any>, now?: Date | string): AIRunGateResult | undefined {
-	if (!contract || !Object.keys(contract).length) {
-		return undefined;
-	}
-	const safeToAutoRun = booleanFlag(contract.safeToAutoRun ?? contract.safe_to_auto_run) === true;
-	const requiresHumanApproval = booleanFlag(contract.requiresHumanApproval ?? contract.requires_human_approval) === true;
-	const canRunWithoutCodexMonitor = booleanFlag(contract.canRunWithoutCodexMonitor ?? contract.can_run_without_codex_monitor) === true;
-	const codexFallbackRequired = booleanFlag(contract.codexFallbackRequired ?? contract.codex_fallback_required) === true;
-	const sourceBlockers = cleanStringList(contract.blockers, 40, 500);
-	const primaryCommand = cleanText(contract.primaryCommand || contract.primary_command, 200);
-	const liveHotfixBlockedUntilCommit = booleanFlag(contract.liveHotfixBlockedUntilCommit ?? contract.live_hotfix_blocked_until_commit ?? plainObject(contract.decisionBasis || contract.decision_basis).liveHotfixBlockedUntilCommit ?? plainObject(contract.decisionBasis || contract.decision_basis).live_hotfix_blocked_until_commit) === true;
-	const safetyBlockers = Array.from(new Set([
-		...(safeToAutoRun ? [] : ['AICoder next action is not marked safe to auto-run.']),
-		...(canRunWithoutCodexMonitor ? [] : ['AICoder next action requires Codex fallback/monitoring instead of manager-only execution.']),
-		...(codexFallbackRequired ? [cleanText(contract.codexFallbackReason || contract.codex_fallback_reason, 1000) || 'AICoder next action contract requires Codex fallback.'] : []),
-		...(requiresHumanApproval ? ['AICoder next action requires human approval.'] : []),
-		...(liveHotfixBlockedUntilCommit ? ['Live AICoder hotfix is blocked until GitHub commit and push proof is recorded.'] : [])
-	])).filter(Boolean).slice(0, 40);
-	const contractBlockers = safetyBlockers.length
-		? Array.from(new Set([...sourceBlockers, ...safetyBlockers])).slice(0, 40)
-		: [];
-	const missingSafetyFlags = [
-		contract.safeToAutoRun === undefined && contract.safe_to_auto_run === undefined ? 'safeToAutoRun' : '',
-		contract.canRunWithoutCodexMonitor === undefined && contract.can_run_without_codex_monitor === undefined ? 'canRunWithoutCodexMonitor' : '',
-		contract.codexFallbackRequired === undefined && contract.codex_fallback_required === undefined ? 'codexFallbackRequired' : ''
-	].filter(Boolean);
-	const gateStatus: AIRunGateResult['status'] = contractBlockers.length
-		? 'blocked'
-		: missingSafetyFlags.length
-			? 'warn'
-			: 'pass';
-	return {
-		key: 'aicoder_next_action_contract',
-		label: 'AICoder next action contract',
-		status: gateStatus,
-		reason: gateStatus === 'pass'
-			? `AICoder can run ${primaryCommand || 'the next action'} without a Codex monitor.`
-			: (contractBlockers.join(' ') || cleanText(contract.codexFallbackReason || contract.codex_fallback_reason || contract.expectedStateTransition || contract.expected_state_transition, 1200) || 'AICoder next action is not safe to run unattended.'),
-		evidenceRefs: cleanStringList([
-			...asArray(contract.preconditions),
-			...asArray(contract.successEvidence || contract.success_evidence),
-			...asArray(contract.stopConditions || contract.stop_conditions)
-		], 40, 500),
-		recordedAt: isoNow(now || contract.createdAt || contract.created_at || contract.recordedAt || contract.recorded_at),
-		metadata: {
-			contractId: cleanText(contract.contractId || contract.contract_id, 200),
-			action: cleanText(contract.action, 120),
-			label: cleanText(contract.label, 200),
-			primaryCommand,
-			lane: cleanText(contract.lane, 120),
-			stepType: cleanText(contract.stepType || contract.step_type, 120),
-			safeToAutoRun,
-			requiresHumanApproval,
-			canRunWithoutCodexMonitor,
-			codexFallbackRequired,
-			codexFallbackReason: cleanText(contract.codexFallbackReason || contract.codex_fallback_reason, 1000),
-			costRisk: cleanText(contract.costRisk || contract.cost_risk, 120),
-			workflowFirstSatisfied: booleanFlag(contract.workflowFirstSatisfied ?? contract.workflow_first_satisfied) === true,
-			hotfixCommitRequired: booleanFlag(contract.hotfixCommitRequired ?? contract.hotfix_commit_required ?? plainObject(contract.decisionBasis || contract.decision_basis).hotfixCommitRequired ?? plainObject(contract.decisionBasis || contract.decision_basis).hotfix_commit_required) === true,
-			liveHotfixBlockedUntilCommit,
-			decisionBasis: plainObject(contract.decisionBasis || contract.decision_basis),
-			preconditions: cleanStringList(contract.preconditions, 40, 500),
-			expectedStateTransition: cleanText(contract.expectedStateTransition || contract.expected_state_transition, 1000),
-			successEvidence: cleanStringList(contract.successEvidence || contract.success_evidence, 40, 500),
-			requiredHotfixCommitProof: cleanStringList(contract.requiredHotfixCommitProof || contract.required_hotfix_commit_proof, 20, 240),
-			stopConditions: cleanStringList(contract.stopConditions || contract.stop_conditions, 40, 500),
-			forbiddenActions: cleanStringList(contract.forbiddenActions || contract.forbidden_actions, 40, 500),
-			nextCommands: cleanStringList(contract.nextCommands || contract.next_commands, 40, 240),
-			blockers: contractBlockers,
-			contextBlockers: sourceBlockers,
-			safetyBlockers,
-			missingSafetyFlags,
-			ownerFiles: cleanStringList(contract.ownerFiles || contract.owner_files, 40, 500)
-		}
-	};
-}
-
-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 assistantActionabilityStatus(decision: AssistantAnswerQualityDecision): AssistantAnswerActionabilityStatus {
-	switch (decision.status) {
-		case 'ready':
-			return 'ready_to_answer';
-		case 'query_error':
-			return 'needs_query_repair';
-		case 'permission_error':
-			return 'needs_permission';
-		case 'no_data_unverified':
-			return 'needs_no_data_verification';
-		case 'date_incorrect':
-		case 'missing_date_window':
-			return 'needs_date_window_repair';
-		case 'illegal_query_shape':
-			return 'needs_query_shape_repair';
-		case 'missing_data_source':
-		case 'missing_query_proof':
-		case 'missing_citations':
-			return 'needs_evidence';
-		case 'low_confidence':
-			return 'needs_confidence_review';
-		case 'missing_next_action':
-			return 'needs_next_action';
-		case 'incorrect':
-			return 'incorrect';
-		default:
-			return 'blocked';
-	}
-}
-
-function assistantActionabilityCommand(status: AssistantAnswerActionabilityStatus): string {
-	switch (status) {
-		case 'ready_to_answer':
-			return 'answer_from_verified_system_data';
-		case 'needs_query_repair':
-			return 'repair_assistant_query_and_rerun';
-		case 'needs_permission':
-			return 'request_assistant_data_permission';
-		case 'needs_no_data_verification':
-			return 'verify_no_data_with_scoped_probe';
-		case 'needs_date_window_repair':
-			return 'repair_assistant_date_window_and_rerun';
-		case 'needs_query_shape_repair':
-			return 'repair_assistant_mongo_query_shape';
-		case 'needs_confidence_review':
-			return 'review_assistant_confidence_evidence';
-		case 'needs_next_action':
-			return 'add_assistant_next_action';
-		case 'incorrect':
-			return 'repair_assistant_answer_from_failed_check';
-		case 'needs_evidence':
-		case 'blocked':
-		default:
-			return 'collect_assistant_answer_evidence';
-	}
-}
-
-function assistantActionabilityLabel(status: AssistantAnswerActionabilityStatus): string {
-	switch (status) {
-		case 'ready_to_answer':
-			return 'Answer From Verified Data';
-		case 'needs_query_repair':
-			return 'Repair Query';
-		case 'needs_permission':
-			return 'Request Data Permission';
-		case 'needs_no_data_verification':
-			return 'Verify No Data';
-		case 'needs_date_window_repair':
-			return 'Repair Date Window';
-		case 'needs_query_shape_repair':
-			return 'Repair Query Shape';
-		case 'needs_confidence_review':
-			return 'Review Confidence';
-		case 'needs_next_action':
-			return 'Add Next Action';
-		case 'incorrect':
-			return 'Repair Incorrect Answer';
-		default:
-			return 'Collect Answer Evidence';
-	}
-}
-
-export function buildAssistantAnswerActionabilityContract(
-	decision: AssistantAnswerQualityDecision,
-	now?: Date | string
-): AssistantAnswerActionabilityContract {
-	const status = assistantActionabilityStatus(decision);
-	const primaryCommand = assistantActionabilityCommand(status);
-	const ready = status === 'ready_to_answer';
-	const noDataReady = ready && decision.queryStatus === 'no_data' && decision.noDataConfirmed;
-	const canAnswerCustomer = ready && (
-		decision.queryStatus === 'ok'
-		|| noDataReady
-		|| decision.queryEvidenceRequired === false
-	);
-	const canDraftSupportReply = canAnswerCustomer && decision.confidenceLevel === 'high';
-	const requiresHumanReview = !canAnswerCustomer || canDraftSupportReply;
-	const cheapRepair = /needs_(?:no_data|date_window|query_shape|next_action)|needs_evidence/.test(status);
-	const blockers = decision.blockers.length
-		? decision.blockers
-		: (ready ? [] : [decision.reason]);
-	const requiredEvidence = Array.from(new Set([
-		...(decision.queryEvidenceRequired ? ['structured query/tool execution proof'] : []),
-		...(decision.dateWindowRequired ? ['concrete date-window start and end'] : []),
-		...(decision.queryStatus === 'no_data' ? ['noDataConfirmed=true from scoped probe or query evidence'] : []),
-		...(decision.legalQueryShape ? [] : ['legal Mongo query/projection shape']),
-		...(decision.citationRefs.length || decision.evidenceRefs.length ? [] : ['citationRefs or evidenceRefs']),
-		...(decision.nextActions.length ? [] : ['one explicit next action or no-action state']),
-		...(decision.confidenceLevel === 'low' || decision.confidenceLevel === 'unknown' ? ['medium/high confidence evidence'] : [])
-	])).slice(0, 20);
-	return {
-		contractId: `assistant-actionability:${decision.status}:${decision.queryStatus}:${decision.recordedAt}`,
-		status,
-		primaryCommand,
-		label: assistantActionabilityLabel(status),
-		canAnswerCustomer,
-		canDraftSupportReply,
-		canSendCustomerReply: false,
-		requiresHumanReview,
-		canRunWithoutCodexMonitor: ready || cheapRepair,
-		codexFallbackRequired: !ready && !cheapRepair,
-		costRisk: ready
-			? 'free_or_deterministic'
-			: status === 'needs_permission'
-				? 'manual_blocked'
-				: (status === 'needs_query_repair' || status === 'incorrect' ? 'small_model_or_qa' : 'free_or_deterministic'),
-		queryResultClass: decision.queryStatus,
-		confidenceLevel: decision.confidenceLevel,
-		decisionBasis: {
-			answerQualityStatus: decision.status,
-			queryStatus: decision.queryStatus,
-			queryEvidencePresent: decision.queryEvidencePresent,
-			noDataConfirmed: decision.noDataConfirmed,
-			legalQueryShape: decision.legalQueryShape,
-			dateWindowRequired: decision.dateWindowRequired,
-			dateWindowPresent: decision.dateWindowPresent,
-			citationCount: decision.citationRefs.length + decision.evidenceRefs.length,
-			nextActionCount: decision.nextActions.length
-		},
-		requiredEvidence,
-		successEvidence: Array.from(new Set([
-			...(ready ? ['assistant answer quality gate passed'] : []),
-			...(decision.queryEvidenceRefs.length ? decision.queryEvidenceRefs : []),
-			...(decision.citationRefs.length ? decision.citationRefs : []),
-			...(decision.evidenceRefs.length ? decision.evidenceRefs : [])
-		])).slice(0, 20),
-		blockers,
-		nextActions: decision.nextActions,
-		nextCommands: Array.from(new Set([
-			primaryCommand,
-			...(status === 'needs_query_repair' ? ['fix_query_error', 'rerun_assistant_query'] : []),
-			...(status === 'needs_no_data_verification' ? ['run_tiny_shape_probe', 'record_no_data_confirmed'] : []),
-			...(status === 'needs_date_window_repair' ? ['resolve_current_date', 'record_concrete_date_window', 'rerun_assistant_query'] : []),
-			...(status === 'needs_query_shape_repair' ? ['rewrite_illegal_projection', 'rerun_query_shape_validator'] : []),
-			...(status === 'needs_permission' ? ['request_permission_or_choose_allowed_route'] : []),
-			'record_assistant_actionability_result'
-		])).slice(0, 20),
-		forbiddenActions: Array.from(new Set([
-			'Do not answer from keyword or route guesses without verified query evidence.',
-			'Do not claim no data when queryStatus is query_error or permission_error.',
-			...(decision.queryStatus === 'no_data' && !decision.noDataConfirmed ? ['Do not present no-data answer until noDataConfirmed=true.'] : []),
-			...(decision.legalQueryShape ? [] : ['Do not answer from illegal Mongo projection/query shape.']),
-			...(decision.dateWindowRequired && !decision.dateWindowPresent ? ['Do not answer dated questions without concrete start/end date evidence.'] : []),
-			...(decision.confidenceLevel === 'low' || decision.confidenceLevel === 'unknown' ? ['Do not draft support/customer reply from low or unknown confidence.'] : [])
-		])).slice(0, 20),
-		evidenceRefs: Array.from(new Set([
-			...decision.queryEvidenceRefs,
-			...decision.citationRefs,
-			...decision.evidenceRefs
-		])).slice(0, 40),
-		recordedAt: isoNow(now || decision.recordedAt)
-	};
-}
-
-function assistantAnswerActionabilityGate(
-	contract: AssistantAnswerActionabilityContract,
-	now?: Date | string
-): AIRunGateResult {
-	const status: AIRunGateResult['status'] = contract.status === 'ready_to_answer'
-		? 'pass'
-		: contract.status === 'incorrect' || contract.status === 'needs_query_shape_repair' || contract.status === 'needs_date_window_repair'
-			? 'fail'
-			: 'blocked';
-	return {
-		key: 'assistant_answer_actionability',
-		label: 'Assistant answer actionability',
-		status,
-		reason: status === 'pass'
-			? 'Assistant answer can proceed from verified structured evidence.'
-			: (contract.blockers.join(' ') || 'Assistant answer is blocked until actionability evidence is complete.'),
-		evidenceRefs: contract.evidenceRefs,
-		recordedAt: isoNow(now || contract.recordedAt),
-		metadata: {
-			contractId: contract.contractId,
-			status: contract.status,
-			primaryCommand: contract.primaryCommand,
-			label: contract.label,
-			canAnswerCustomer: contract.canAnswerCustomer,
-			canDraftSupportReply: contract.canDraftSupportReply,
-			canSendCustomerReply: contract.canSendCustomerReply,
-			requiresHumanReview: contract.requiresHumanReview,
-			canRunWithoutCodexMonitor: contract.canRunWithoutCodexMonitor,
-			codexFallbackRequired: contract.codexFallbackRequired,
-			costRisk: contract.costRisk,
-			queryResultClass: contract.queryResultClass,
-			confidenceLevel: contract.confidenceLevel,
-			decisionBasis: contract.decisionBasis,
-			requiredEvidence: contract.requiredEvidence,
-			successEvidence: contract.successEvidence,
-			blockers: contract.blockers,
-			nextActions: contract.nextActions,
-			nextCommands: contract.nextCommands,
-			forbiddenActions: contract.forbiddenActions
-		}
-	};
-}
-
-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 customerReplyReadiness = plainObject(
-		evidence.customerReplyReadiness
-		|| evidence.customer_reply_readiness
-		|| customerReplyPolicy.readinessContract
-		|| customerReplyPolicy.readiness_contract
-	);
-	const customerReplyReadinessGate = supportCustomerReplyReadinessGate(customerReplyReadiness, input.now);
-	if (customerReplyReadinessGate) {
-		gates.push(customerReplyReadinessGate);
-		pushEvent(events, {
-			type: 'human_intervention',
-			category: 'support_customer_reply_readiness',
-			message: customerReplyReadinessGate.reason,
-			artifactPaths: customerReplyReadinessGate.evidenceRefs,
-			recordedAt: customerReplyReadinessGate.recordedAt,
-			metadata: customerReplyReadinessGate.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 managerRecoveryExecutionProof = plainObject(evidence.managerRecoveryExecutionProof || evidence.manager_recovery_execution_proof);
-	const recoveryExecutionProofGate = managerRecoveryExecutionProofGate(managerRecoveryExecutionProof, input.now);
-	if (recoveryExecutionProofGate) {
-		gates.push(recoveryExecutionProofGate);
-		pushEvent(events, {
-			type: 'log',
-			category: 'manager_recovery_execution_proof',
-			message: recoveryExecutionProofGate.reason,
-			artifactPaths: recoveryExecutionProofGate.evidenceRefs,
-			recordedAt: recoveryExecutionProofGate.recordedAt,
-			metadata: recoveryExecutionProofGate.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 costGate = costObservabilityGate(cost, 'support_ticket', input.now);
-	gates.push(costGate);
-	pushEvent(events, {
-		type: 'usage',
-		category: 'cost_observability',
-		message: costGate.reason,
-		artifactPaths: costGate.evidenceRefs,
-		recordedAt: costGate.recordedAt,
-		metadata: costGate.metadata
-	});
-	const preflightGateSource = supportPreflightGateObject(ticket, job, evidence);
-	const preflightGate = supportPreflightGateResult(preflightGateSource, input.now);
-	if (preflightGate) {
-		gates.push(preflightGate);
-		pushEvent(events, {
-			type: preflightGate.metadata?.failureClass === 'compile' || preflightGateSource.status === 'compile_failed' ? 'qa_compile' : 'qa_infra',
-			category: 'support_preflight_gate',
-			message: preflightGate.reason,
-			artifactPaths: preflightGate.evidenceRefs,
-			recordedAt: preflightGate.recordedAt,
-			metadata: preflightGate.metadata
-		});
-	}
-
-	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 issueClassProbePlanSource = supportIssueClassProbePlanObject(ticket, job, evidence);
-	const issueClassProbePlan = Object.keys(issueClassProbePlanSource).length
-		? issueClassProbePlanSource
-		: Object.keys(diagnosisGate).length
-			? buildResolveIOSupportIssueClassProbePlan(diagnosisGate, input.now) as Record<string, any>
-			: {};
-	const issueClassProbePlanRequired = nextActionContractRequired || Object.keys(diagnosisGate).length > 0;
-	const issueClassProbePlanGate = supportIssueClassProbePlanGate(
-		issueClassProbePlan,
-		diagnosisGate,
-		input.now,
-		issueClassProbePlanRequired
-	);
-	if (issueClassProbePlanGate) {
-		gates.push(issueClassProbePlanGate);
-		pushEvent(events, {
-			type: 'log',
-			category: 'support_issue_class_probe_plan',
-			message: issueClassProbePlanGate.reason,
-			artifactPaths: issueClassProbePlanGate.evidenceRefs,
-			recordedAt: issueClassProbePlanGate.recordedAt,
-			metadata: issueClassProbePlanGate.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 ownerFileScopeGate = supportOwnerFileScopeGate(diagnosisGate, productRepairEvidence, input.now);
-	if (ownerFileScopeGate) {
-		gates.push(ownerFileScopeGate);
-		pushEvent(events, {
-			type: 'log',
-			category: 'support_owner_file_scope',
-			message: ownerFileScopeGate.reason,
-			artifactPaths: ownerFileScopeGate.evidenceRefs,
-			recordedAt: ownerFileScopeGate.recordedAt,
-			metadata: ownerFileScopeGate.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,
-			costObservability: costObservabilityMetadata(costGate),
-			hotfixDurability: hotfixDurabilityMetadata(gates),
-			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,
-			ownerFileScope: ownerFileScopeGate ? {
-				status: ownerFileScopeGate.status,
-				productRepairAllowed: ownerFileScopeGate.metadata?.productRepairAllowed === true,
-				allowedDispatchAction: cleanText(ownerFileScopeGate.metadata?.allowedDispatchAction, 160),
-				ownerFiles: cleanStringList(ownerFileScopeGate.metadata?.ownerFiles, 40, 500),
-				changedFiles: cleanStringList(ownerFileScopeGate.metadata?.changedFiles, 60, 500),
-				outsideOwnerFiles: cleanStringList(ownerFileScopeGate.metadata?.outsideOwnerFiles, 40, 500),
-				allowedTestFilesOutsideOwnerScope: ownerFileScopeGate.metadata?.allowedTestFilesOutsideOwnerScope === true,
-				requiredEvidence: cleanStringList(ownerFileScopeGate.metadata?.requiredEvidence, 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,
-			issueClassProbePlan: issueClassProbePlanGate ? {
-				status: cleanText(issueClassProbePlanGate.metadata?.status, 120),
-				gateStatus: issueClassProbePlanGate.status,
-				planId: cleanText(issueClassProbePlanGate.metadata?.planId, 180),
-				issueClass: cleanText(issueClassProbePlanGate.metadata?.issueClass, 120),
-				diagnosisValid: issueClassProbePlanGate.metadata?.diagnosisValid === true,
-				issueClassProbePlanReady: issueClassProbePlanGate.metadata?.issueClassProbePlanReady === true,
-				activeRoute: cleanText(issueClassProbePlanGate.metadata?.activeRoute, 500),
-				action: cleanText(issueClassProbePlanGate.metadata?.action, 1000),
-				expectedBusinessProof: cleanText(issueClassProbePlanGate.metadata?.expectedBusinessProof, 1200),
-				acceptanceGate: cleanText(issueClassProbePlanGate.metadata?.acceptanceGate, 120),
-				requiredArtifacts: cleanStringList(issueClassProbePlanGate.metadata?.requiredArtifacts, 20, 500),
-				falsePassBlockers: cleanStringList(issueClassProbePlanGate.metadata?.falsePassBlockers, 20, 500),
-				blockers: cleanStringList(issueClassProbePlanGate.metadata?.blockers, 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,
-			managerRecoveryExecutionProof: recoveryExecutionProofGate ? {
-					status: cleanText(recoveryExecutionProofGate.metadata?.status, 120),
-					gateStatus: recoveryExecutionProofGate.status,
-					canContinueRun: recoveryExecutionProofGate.metadata?.canContinueRun === true,
-					canRunProductRepair: recoveryExecutionProofGate.metadata?.canRunProductRepair === true,
-					canRunExpensiveModel: recoveryExecutionProofGate.metadata?.canRunExpensiveModel === true,
-					canResetLoopBudget: recoveryExecutionProofGate.metadata?.canResetLoopBudget === true,
-					newEvidence: recoveryExecutionProofGate.metadata?.newEvidence === true,
-					materialEvidence: recoveryExecutionProofGate.metadata?.materialEvidence === true,
-					evidenceStrength: cleanText(recoveryExecutionProofGate.metadata?.evidenceStrength, 120),
-					nextAllowedAction: cleanText(recoveryExecutionProofGate.metadata?.nextAllowedAction, 180),
-					missingEvidence: cleanStringList(recoveryExecutionProofGate.metadata?.missingEvidence, 20, 500),
-					blockers: cleanStringList(recoveryExecutionProofGate.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
-				),
-					clarificationContract: customerReplyPolicy.clarificationContract || customerReplyPolicy.clarification_contract ? {
-						status: cleanText(customerReplyPolicy.clarificationContract?.status || customerReplyPolicy.clarification_contract?.status, 120),
-						missingField: cleanText(customerReplyPolicy.clarificationContract?.missingField || customerReplyPolicy.clarification_contract?.missing_field, 120),
-						oneQuestionOnly: customerReplyPolicy.clarificationContract?.oneQuestionOnly === true || customerReplyPolicy.clarification_contract?.one_question_only === true,
-						parksTicketUntilCustomerReply: customerReplyPolicy.clarificationContract?.parksTicketUntilCustomerReply === true || customerReplyPolicy.clarification_contract?.parks_ticket_until_customer_reply === true
-					} : undefined
-				} : undefined,
-				customerReplyReadiness: customerReplyReadinessGate ? {
-					status: cleanText(customerReplyReadinessGate.metadata?.status, 120),
-					gateStatus: customerReplyReadinessGate.status,
-					primaryCommand: cleanText(customerReplyReadinessGate.metadata?.primaryCommand, 180),
-					policyAction: cleanText(customerReplyReadinessGate.metadata?.policyAction, 120),
-					canDraftCustomerReply: customerReplyReadinessGate.metadata?.canDraftCustomerReply === true,
-					canSendCustomerReply: customerReplyReadinessGate.metadata?.canSendCustomerReply === true,
-					requiresHumanApproval: customerReplyReadinessGate.metadata?.requiresHumanApproval === true,
-					proofBacked: customerReplyReadinessGate.metadata?.proofBacked === true,
-					businessProofReady: customerReplyReadinessGate.metadata?.businessProofReady === true,
-					releaseReady: customerReplyReadinessGate.metadata?.releaseReady === true,
-					blockers: cleanStringList(customerReplyReadinessGate.metadata?.blockers, 20, 500)
-				} : 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 costGate = costObservabilityGate(cost, 'aicoder_app', input.now);
-	gates.push(costGate);
-	pushEvent(events, {
-		type: 'usage',
-		category: 'cost_observability',
-		message: costGate.reason,
-		artifactPaths: costGate.evidenceRefs,
-		recordedAt: costGate.recordedAt,
-		metadata: costGate.metadata
-	});
-	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 nextActionContract = aicoderNextActionContractObject(app, job, evidence);
-	const nextActionContractGate = aicoderNextActionContractGate(nextActionContract, input.now);
-	if (nextActionContractGate) {
-		gates.push(nextActionContractGate);
-		pushEvent(events, {
-			type: 'log',
-			category: 'aicoder_next_action_contract',
-			message: nextActionContractGate.reason,
-			artifactPaths: nextActionContractGate.evidenceRefs,
-			recordedAt: nextActionContractGate.recordedAt,
-			metadata: nextActionContractGate.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,
-			costObservability: costObservabilityMetadata(costGate),
-			hotfixDurability: hotfixDurabilityMetadata(gates),
-			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),
-				workflowQaCoverageTags: cleanStringList(journeyContractGate.metadata?.workflowQaCoverageTags, 80, 120),
-				workflowQaProofKinds: cleanStringList(journeyContractGate.metadata?.workflowQaProofKinds, 80, 120),
-				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,
-			nextActionContract: nextActionContractGate ? {
-				gateStatus: nextActionContractGate.status,
-				contractId: cleanText(nextActionContractGate.metadata?.contractId, 200),
-				action: cleanText(nextActionContractGate.metadata?.action, 120),
-				label: cleanText(nextActionContractGate.metadata?.label, 200),
-				primaryCommand: cleanText(nextActionContractGate.metadata?.primaryCommand, 200),
-				lane: cleanText(nextActionContractGate.metadata?.lane, 120),
-				stepType: cleanText(nextActionContractGate.metadata?.stepType, 120),
-				safeToAutoRun: nextActionContractGate.metadata?.safeToAutoRun === true,
-				requiresHumanApproval: nextActionContractGate.metadata?.requiresHumanApproval === true,
-				canRunWithoutCodexMonitor: nextActionContractGate.metadata?.canRunWithoutCodexMonitor === true,
-				codexFallbackRequired: nextActionContractGate.metadata?.codexFallbackRequired === true,
-				costRisk: cleanText(nextActionContractGate.metadata?.costRisk, 120),
-				workflowFirstSatisfied: nextActionContractGate.metadata?.workflowFirstSatisfied === true,
-				hotfixCommitRequired: nextActionContractGate.metadata?.hotfixCommitRequired === true,
-				liveHotfixBlockedUntilCommit: nextActionContractGate.metadata?.liveHotfixBlockedUntilCommit === true,
-				decisionBasis: plainObject(nextActionContractGate.metadata?.decisionBasis),
-				preconditions: cleanStringList(nextActionContractGate.metadata?.preconditions, 20, 500),
-				successEvidence: cleanStringList(nextActionContractGate.metadata?.successEvidence, 20, 500),
-				requiredHotfixCommitProof: cleanStringList(nextActionContractGate.metadata?.requiredHotfixCommitProof, 20, 240),
-				stopConditions: cleanStringList(nextActionContractGate.metadata?.stopConditions, 20, 500),
-				forbiddenActions: cleanStringList(nextActionContractGate.metadata?.forbiddenActions, 20, 500),
-				nextCommands: cleanStringList(nextActionContractGate.metadata?.nextCommands, 20, 240),
-				blockers: cleanStringList(nextActionContractGate.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 costGate = costObservabilityGate(cost, 'ai_assistant', input.now);
-	pushEvent(events, {
-		type: 'usage',
-		category: 'cost_observability',
-		message: costGate.reason,
-		artifactPaths: costGate.evidenceRefs,
-		recordedAt: costGate.recordedAt,
-		metadata: costGate.metadata
-	});
-	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 answerActionabilityContract = buildAssistantAnswerActionabilityContract(answerQualityDecision, input.now);
-	const answerActionabilityGate = assistantAnswerActionabilityGate(answerActionabilityContract, input.now);
-	pushEvent(events, {
-		type: 'assistant_message',
-		category: 'assistant_answer_actionability',
-		message: answerActionabilityGate.reason,
-		artifactPaths: answerActionabilityGate.evidenceRefs,
-		recordedAt: answerActionabilityGate.recordedAt,
-		metadata: answerActionabilityGate.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,
-		gates: [answerActionabilityGate, costGate],
-		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,
-			costObservability: costObservabilityMetadata(costGate),
-			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
-			},
-			answerActionability: {
-				contractId: answerActionabilityContract.contractId,
-				status: answerActionabilityContract.status,
-				primaryCommand: answerActionabilityContract.primaryCommand,
-				label: answerActionabilityContract.label,
-				canAnswerCustomer: answerActionabilityContract.canAnswerCustomer,
-				canDraftSupportReply: answerActionabilityContract.canDraftSupportReply,
-				canSendCustomerReply: answerActionabilityContract.canSendCustomerReply,
-				requiresHumanReview: answerActionabilityContract.requiresHumanReview,
-				canRunWithoutCodexMonitor: answerActionabilityContract.canRunWithoutCodexMonitor,
-				codexFallbackRequired: answerActionabilityContract.codexFallbackRequired,
-				costRisk: answerActionabilityContract.costRisk,
-				queryResultClass: answerActionabilityContract.queryResultClass,
-				confidenceLevel: answerActionabilityContract.confidenceLevel,
-				decisionBasis: answerActionabilityContract.decisionBasis,
-				requiredEvidence: answerActionabilityContract.requiredEvidence,
-				successEvidence: answerActionabilityContract.successEvidence,
-				blockers: answerActionabilityContract.blockers,
-				nextActions: answerActionabilityContract.nextActions,
-				nextCommands: answerActionabilityContract.nextCommands,
-				forbiddenActions: answerActionabilityContract.forbiddenActions
-			}
-		}
-	});
-}