@resolveio/server-lib 22.3.142 → 22.3.144

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

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