@resolveio/server-lib 22.3.148 → 22.3.150

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

@@ -0,0 +1,684 @@
+import {
+	AIRun,
+	AIRunCost,
+	AIRunEvent,
+	AIRunGateResult,
+	AIQaArtifact,
+	AIQaBusinessAssertion,
+	AIQaCompileResult,
+	AIQaInfraCheck,
+	AIQaRun,
+	AIQaRouteProbe,
+	buildAIRun,
+	buildAIRunCost,
+	buildAIQaRun,
+	normalizeOpenAIUsageRowsForCosting
+} from './ai-run-evidence';
+
+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 {
+	conversation?: Record<string, any>;
+	messages?: Array<Record<string, any>>;
+	issueReports?: Array<Record<string, any>>;
+	usageLedger?: Array<Record<string, any>>;
+	correctnessChecks?: Array<Record<string, any>>;
+	now?: Date | 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 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 collectUsageEvents(entries: Array<Record<string, any>>, events: AIRunEvent[]): AIRunCost | undefined {
+	if (!entries.length) {
+		return undefined;
+	}
+	const normalizedEntries = normalizeOpenAIUsageRowsForCosting(entries);
+	for (const entry of normalizedEntries) {
+		pushEvent(events, {
+			type: 'usage',
+			category: cleanText(entry.category || entry.kind || entry.phase, 160) || 'usage',
+			message: cleanText(entry.summary || entry.description || entry.model || 'Model usage recorded.', 800),
+			recordedAt: eventDate(entry),
+			metadata: {
+				model: entry.model,
+				inputTokens: entry.inputTokens ?? entry.input_tokens,
+				outputTokens: entry.outputTokens ?? entry.output_tokens,
+				totalTokens: entry.totalTokens ?? entry.total_tokens,
+				estimatedUsd: entry.estimatedUsd ?? entry.cost_estimate,
+				usageSource: entry.usage_source ?? entry.usageSource,
+				usageSurface: entry.usage_surface ?? entry.usageSurface,
+				usagePhase: entry.usage_phase ?? entry.usagePhase,
+				costBasis: entry.cost_basis ?? entry.costBasis,
+				isManual: entry.is_manual ?? entry.isManual,
+				isUntracked: entry.is_untracked ?? entry.isUntracked,
+				untrackedReason: entry.untracked_reason ?? entry.untrackedReason
+			}
+		});
+	}
+	return buildAIRunCost(entries);
+}
+
+function collectCommitEvents(commits: Array<Record<string, any>>, events: AIRunEvent[]): void {
+	for (const commit of commits.slice(0, 80)) {
+		pushEvent(events, {
+			type: 'git_commit',
+			message: cleanText(commit.message || commit.subject || commit.title || commit.hash || commit.sha, 1200),
+			recordedAt: eventDate(commit),
+			metadata: {
+				sha: commit.sha || commit.hash,
+				branch: commit.branch,
+				author: commit.author
+			}
+		});
+	}
+}
+
+function statusFromBoolean(value: any, fallback?: string): string | undefined {
+	if (value === true) {
+		return 'pass';
+	}
+	if (value === false) {
+		return 'fail';
+	}
+	return fallback;
+}
+
+function collectArtifacts(evidence: Record<string, any> | undefined): AIQaArtifact[] {
+	const artifacts: AIQaArtifact[] = [];
+	for (const entry of asArray<any>(evidence?.artifacts)) {
+		artifacts.push({
+			type: entry.type || 'other',
+			path: cleanText(entry.path || entry.file || entry.artifactPath, 500),
+			url: cleanText(entry.url, 500),
+			title: cleanText(entry.title || entry.name, 300),
+			caption: cleanText(entry.caption || entry.message, 800),
+			metadata: entry.metadata
+		});
+	}
+	const screenshots = asArray<any>(evidence?.screenshots || evidence?.qaScreenshots || evidence?.browserScreenshots);
+	for (const screenshot of screenshots.slice(0, 40)) {
+		if (typeof screenshot === 'string') {
+			artifacts.push({ type: 'screenshot', path: screenshot });
+		} else {
+			artifacts.push({
+				type: 'screenshot',
+				path: cleanText(screenshot.path || screenshot.file, 500),
+				url: cleanText(screenshot.url, 500),
+				title: cleanText(screenshot.title || screenshot.route, 300),
+				caption: cleanText(screenshot.caption || screenshot.message, 800),
+				metadata: screenshot.metadata
+			});
+		}
+	}
+	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[] = [];
+	for (const entry of asArray<any>(evidence?.routeProbes || evidence?.routes || evidence?.browserRoutes)) {
+		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[] = [];
+	for (const entry of asArray<any>(evidence?.businessAssertions || evidence?.workflowAssertions || evidence?.assertions)) {
+		assertions.push({
+			assertion: cleanText(entry.assertion || entry.name || entry.workflow || entry.expected, 1000) || 'business assertion',
+			status: entry.status || statusFromBoolean(entry.passed),
+			workflow: cleanText(entry.workflow, 400),
+			route: cleanText(entry.route, 500),
+			action: cleanText(entry.action, 500),
+			expected: cleanText(entry.expected, 1000),
+			observed: cleanText(entry.observed || entry.actual, 1000),
+			dataProof: cleanText(entry.dataProof || entry.proof, 1400),
+			artifactPaths: asArray<string>(entry.artifactPaths || entry.artifacts),
+			message: cleanText(entry.message || entry.error || entry.reason, 1000),
+			recordedAt: eventDate(entry),
+			metadata: entry.metadata
+		});
+	}
+	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)
+		}
+	};
+}
+
+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
+		]
+	};
+}
+
+function evidenceObject(...values: any[]): Record<string, any> {
+	for (const value of values) {
+		if (value && typeof value === 'object' && !Array.isArray(value)) {
+			return value;
+		}
+	}
+	return {};
+}
+
+export function buildSupportAIRunFromEvidence(input: SupportAIRunAdapterInput): AIRun {
+	const ticket = input.ticket || {};
+	const job = input.job || {};
+	const evidence = evidenceObject(input.qaEvidence, job.qaEvidence, job.qa_evidence, ticket.qaEvidence, ticket.qa_evidence);
+	const events: AIRunEvent[] = [];
+	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);
+	const cost = collectUsageEvents(asArray<Record<string, any>>(input.usageLedger), events);
+
+	const diagnosisGate = evidenceObject(
+		job.supportV5DiagnosisGate,
+		job.support_v5_diagnosis_gate,
+		job.diagnosisGate,
+		ticket.supportV5DiagnosisGate,
+		ticket.diagnosisGate,
+		evidence.diagnosisGate,
+		evidence.supportV5DiagnosisGate
+	);
+	const 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,
+		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,
+			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
+		}
+	});
+}
+
+export function buildAICoderAIRunFromEvidence(input: AICoderAIRunAdapterInput): AIRun {
+	const app = input.app || {};
+	const job = input.job || {};
+	const evidence = evidenceObject(input.qaEvidence, job.qaEvidence, job.qa_evidence, app.qaEvidence, app.qa_evidence);
+	const events: AIRunEvent[] = [];
+	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);
+	const cost = collectUsageEvents(asArray<Record<string, any>>(input.usageLedger), events);
+	const qa = buildQaFromEvidence(evidence, input.now);
+	const scorecardPassed = evidence.scorecardPassed === true
+		|| evidence.scorecardStatus === 'pass'
+		|| (Number(evidence.score ?? evidence.qualityScore ?? 0) >= Number(evidence.scoreThreshold ?? job.scoreThreshold ?? 90));
+
+	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,
+		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
+		}
+	});
+}
+
+export function buildAssistantAIRunFromEvidence(input: AssistantAIRunAdapterInput): AIRun {
+	const conversation = input.conversation || {};
+	const events: AIRunEvent[] = [];
+	const sourceIds: Record<string, string> = {};
+	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
+			}
+		});
+	}
+	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 correctnessEvidence = {
+		businessAssertions: asArray<Record<string, any>>(input.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)
+		}))
+	};
+	const qa = buildQaFromEvidence(correctnessEvidence, 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({
+		source: 'ai_assistant',
+		sourceIds,
+		title: firstText(conversation, ['title', 'subject', 'summary']) || 'AI assistant conversation',
+		status: firstText(conversation, ['status', 'state']),
+		phase: firstText(conversation, ['phase']),
+		startedAt: dateValue(conversation, ['startedAt', 'createdAt']),
+		completedAt: dateValue(conversation, ['completedAt', 'closedAt', 'updatedAt']),
+		events,
+		qa,
+		cost,
+		rejected: failedReports.length > 0 || conversation.rejected === true,
+		manualHandoff: conversation.manualHandoff === true,
+		stopped: conversation.stopped === true,
+		explicitAccepted: conversation.accepted === true,
+		terminal: /complete|closed|resolved|done|failed|rejected/i.test(`${conversation.status || ''}`),
+		now: input.now,
+		metadata: {
+			issueReportCount: asArray(input.issueReports).length,
+			correctnessCheckCount: asArray(input.correctnessChecks).length
+		}
+	});
+}