@resolveio/server-lib 22.3.219 → 22.3.221

package/tests/ai-assistant-data-parity-e2e.ts

@@ -0,0 +1,1989 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { ResolveIOServer } from '../src/resolveio-server-app';
+import {
+	buildAssistantDatedPivotDisplay,
+	buildDisplayTable
+} from '../src/methods/ai-terminal';
+
+type ParityCaseExpected = {
+	rows: Array<Record<string, any>>;
+	meta?: Record<string, any>;
+};
+
+type ParityCase = {
+	id: string;
+	prompt: string;
+	runExpected: (context: ParityContext) => Promise<ParityCaseExpected>;
+	compare: (params: {
+		toolResult: any;
+		assistantContent: string;
+		expected: ParityCaseExpected;
+		context: ParityContext;
+	}) => string[];
+};
+
+type ParityCaseResult = {
+	id: string;
+	prompt: string;
+	pass: boolean;
+	errors: string[];
+	conversationId?: string;
+	toolSource?: string;
+	directive?: {
+		type?: string;
+		collection?: string;
+		source?: string;
+	};
+	tool?: {
+		type?: string;
+		collection?: string;
+		rowCount?: number;
+		total?: number | null;
+		columns?: string[];
+	};
+	replay?: {
+		pass: boolean;
+		errors: string[];
+	};
+	expected?: {
+		rows: number;
+		meta?: Record<string, any>;
+	};
+};
+
+type ParityContext = {
+	db: any;
+	now: Date;
+	startOfWeek: Date;
+	last6MonthsStart: Date;
+	last6FullMonthsStart: Date;
+	startOfCurrentMonth: Date;
+	methodManager: any;
+	idUser: string;
+	appId: string;
+};
+
+type AssistantDirective = {
+	type: 'read' | 'aggregate';
+	payload: Record<string, any>;
+	source: 'metadata.debug.directive' | 'assistant.directive_line';
+};
+
+function parseBoolean(value: any): boolean {
+	return ['true', '1', 'yes', 'y', 'on'].includes(String(value || '').trim().toLowerCase());
+}
+
+function normalizeOptionalString(value: any): string {
+	return String(value ?? '').trim();
+}
+
+function loadDotEnvFile(filePath: string): Record<string, string> {
+	const parsed: Record<string, string> = {};
+	if (!fs.existsSync(filePath)) {
+		return parsed;
+	}
+	const content = fs.readFileSync(filePath, 'utf8');
+	content.split(/\r?\n/g).forEach((lineRaw) => {
+		const line = lineRaw.trim();
+		if (!line || line.startsWith('#')) {
+			return;
+		}
+		const jsonLike = line.match(/^"([A-Za-z_][A-Za-z0-9_]*)"\s*:\s*(.+?)\s*,?$/);
+		if (jsonLike?.[1]) {
+			const key = jsonLike[1];
+			let value = String(jsonLike[2] || '').trim();
+			if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith('\'') && value.endsWith('\''))) {
+				value = value.slice(1, -1);
+			}
+			if (key) {
+				parsed[key] = value;
+			}
+			return;
+		}
+		const separator = line.indexOf('=');
+		if (separator <= 0) {
+			return;
+		}
+		const key = line.slice(0, separator).trim();
+		let value = line.slice(separator + 1).trim();
+		if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith('\'') && value.endsWith('\''))) {
+			value = value.slice(1, -1);
+		}
+		if (key) {
+			parsed[key] = value;
+		}
+	});
+	return parsed;
+}
+
+function applyEnvFromServerDir(serverDir: string): void {
+	const envFiles = [
+		path.join(serverDir, '.env.codex'),
+		path.join(serverDir, '.env.production'),
+		path.join(serverDir, '.env')
+	];
+	envFiles.forEach((filePath) => {
+		const values = loadDotEnvFile(filePath);
+		Object.keys(values).forEach((key) => {
+			if (!process.env[key]) {
+				process.env[key] = values[key];
+			}
+		});
+	});
+}
+
+function addDaysUtc(date: Date, days: number): Date {
+	return new Date(Date.UTC(
+		date.getUTCFullYear(),
+		date.getUTCMonth(),
+		date.getUTCDate() + days,
+		date.getUTCHours(),
+		date.getUTCMinutes(),
+		date.getUTCSeconds(),
+		date.getUTCMilliseconds()
+	));
+}
+
+function addMonthsUtc(date: Date, months: number): Date {
+	return new Date(Date.UTC(
+		date.getUTCFullYear(),
+		date.getUTCMonth() + months,
+		date.getUTCDate(),
+		date.getUTCHours(),
+		date.getUTCMinutes(),
+		date.getUTCSeconds(),
+		date.getUTCMilliseconds()
+	));
+}
+
+function startOfDayUtc(date: Date): Date {
+	return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), 0, 0, 0, 0));
+}
+
+function startOfWeekUtcMonday(date: Date): Date {
+	const day = date.getUTCDay();
+	const diff = (day + 6) % 7;
+	return startOfDayUtc(addDaysUtc(date, -diff));
+}
+
+function startOfMonthUtc(date: Date): Date {
+	return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1, 0, 0, 0, 0));
+}
+
+function toNormalizedKey(value: string): string {
+	return String(value || '').toLowerCase().replace(/[^a-z0-9]+/g, '');
+}
+
+function parseNumericLoose(value: any): number | null {
+	if (typeof value === 'number' && Number.isFinite(value)) {
+		return value;
+	}
+	if (typeof value !== 'string') {
+		return null;
+	}
+	const trimmed = value.trim();
+	if (!trimmed) {
+		return null;
+	}
+	const normalized = trimmed
+		.replace(/\$/g, '')
+		.replace(/,/g, '')
+		.replace(/%/g, '')
+		.replace(/\s+/g, '');
+	if (!normalized || !/^[-+]?\d*\.?\d+$/.test(normalized)) {
+		return null;
+	}
+	const parsed = Number(normalized);
+	return Number.isFinite(parsed) ? parsed : null;
+}
+
+function normalizeCellValue(value: any): any {
+	const numeric = parseNumericLoose(value);
+	if (numeric !== null) {
+		return Number(numeric.toFixed(6));
+	}
+	if (value instanceof Date) {
+		return value.toISOString();
+	}
+	if (typeof value === 'string') {
+		return value.trim();
+	}
+	if (value === undefined) {
+		return null;
+	}
+	return value;
+}
+
+function normalizeDisplayRows(display: any): Array<Record<string, any>> {
+	const rows = Array.isArray(display?.rows) ? display.rows : [];
+	return rows.map((row: any) => {
+		const next: Record<string, any> = {};
+		Object.keys(row || {}).forEach((key) => {
+			next[toNormalizedKey(key)] = normalizeCellValue((row as any)[key]);
+		});
+		return next;
+	});
+}
+
+function compareDisplayParity(sourceDisplay: any, replayDisplay: any): string[] {
+	const sourceRows = normalizeDisplayRows(sourceDisplay);
+	const replayRows = normalizeDisplayRows(replayDisplay);
+	const sortRows = (rows: Array<Record<string, any>>) => rows
+		.map(row => JSON.stringify(row, Object.keys(row).sort()))
+		.sort();
+
+	const sourceSorted = sortRows(sourceRows);
+	const replaySorted = sortRows(replayRows);
+	if (sourceSorted.length === replaySorted.length) {
+		let strictMismatch = false;
+		for (let index = 0; index < sourceSorted.length; index += 1) {
+			if (sourceSorted[index] !== replaySorted[index]) {
+				strictMismatch = true;
+				break;
+			}
+		}
+		if (!strictMismatch) {
+			return [];
+		}
+	}
+
+	// Dated outputs can be pivoted into a different row shape but still contain matching totals.
+	const sourceMonthly = parseMonthlyTotalsFromDisplay(sourceDisplay);
+	const replayMonthly = parseMonthlyTotalsFromDisplay(replayDisplay);
+	if (sourceMonthly && replayMonthly) {
+		const monthErrors = compareNumericMaps('Replay monthly totals', sourceMonthly, replayMonthly, 0.05);
+		if (!monthErrors.length) {
+			return [];
+		}
+	}
+
+	const sourceCustomer = parseCustomerMonthTotalsFromDisplay(sourceDisplay);
+	const replayCustomer = parseCustomerMonthTotalsFromDisplay(replayDisplay);
+	if (sourceCustomer && replayCustomer) {
+		const customerErrors = compareNumericMaps('Replay customer monthly totals', sourceCustomer.monthTotals, replayCustomer.monthTotals, 0.05);
+		if (!customerErrors.length) {
+			return [];
+		}
+	}
+
+	return [
+		`Replay display mismatch: tool_result rows=${sourceRows.length}, replay rows=${replayRows.length}.`
+	];
+}
+
+function findFirstMarkdownTable(content: string): { header: string[]; rows: string[][] } | null {
+	const lines = String(content || '').split('\n');
+	for (let index = 0; index < lines.length - 1; index += 1) {
+		const header = lines[index]?.trim();
+		const separator = lines[index + 1]?.trim();
+		if (!header || !separator) {
+			continue;
+		}
+		if (!/^\|.+\|$/.test(header)) {
+			continue;
+		}
+		if (!/^\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/.test(separator)) {
+			continue;
+		}
+		const headerCells = header.split('|').map(value => value.trim()).filter(Boolean);
+		const dataRows: string[][] = [];
+		for (let rowIndex = index + 2; rowIndex < lines.length; rowIndex += 1) {
+			const line = String(lines[rowIndex] || '');
+			if (!line.trim() || !line.includes('|')) {
+				break;
+			}
+			dataRows.push(line.split('|').map(value => value.trim()).filter(Boolean));
+		}
+		return { header: headerCells, rows: dataRows };
+	}
+	return null;
+}
+
+function collectCommonFormattingErrors(content: string): string[] {
+	const errors: string[] = [];
+	const table = findFirstMarkdownTable(content);
+	if (table && table.rows.length === 0) {
+		errors.push('Assistant response contains an empty markdown table header with no data rows.');
+	}
+	return errors;
+}
+
+function collectMonthColumns(columns: string[]): string[] {
+	return columns.filter(column => /^\d{4}-\d{2}$/.test(String(column || '').trim()));
+}
+
+function parseMonthlyTotalsFromDisplay(display: any): Map<string, number> | null {
+	if (!display || !Array.isArray(display.columns) || !Array.isArray(display.rows) || !display.rows.length) {
+		return null;
+	}
+	const columns = display.columns.map((column: any) => String(column || '').trim());
+	const monthColumns = collectMonthColumns(columns);
+	if (monthColumns.length) {
+		const firstColumn = columns[0] || '';
+		const normalizedFirst = toNormalizedKey(firstColumn);
+		if (normalizedFirst === 'metric') {
+			const metricRow = display.rows.find((row: any) => {
+				const metricValue = String(row?.[firstColumn] || '').toLowerCase();
+				return metricValue.includes('revenue') || metricValue.includes('total');
+			}) || display.rows[0];
+			const result = new Map<string, number>();
+			monthColumns.forEach((month) => {
+				const numeric = parseNumericLoose(metricRow?.[month]);
+				if (numeric !== null) {
+					result.set(month, numeric);
+				}
+			});
+			return result.size ? result : null;
+		}
+		const result = new Map<string, number>();
+		monthColumns.forEach((month) => {
+			let sum = 0;
+			display.rows.forEach((row: any) => {
+				const numeric = parseNumericLoose(row?.[month]);
+				if (numeric !== null) {
+					sum += numeric;
+				}
+			});
+			result.set(month, sum);
+		});
+		return result;
+	}
+	const normalizedColumns = columns.map(toNormalizedKey);
+	const monthColumnIndex = normalizedColumns.findIndex((column) => column.includes('month'));
+	const totalColumnIndex = normalizedColumns.findIndex((column) => column.includes('revenue') || column.includes('total'));
+	if (monthColumnIndex === -1 || totalColumnIndex === -1) {
+		return null;
+	}
+	const monthColumn = columns[monthColumnIndex];
+	const totalColumn = columns[totalColumnIndex];
+	const result = new Map<string, number>();
+	display.rows.forEach((row: any) => {
+		const monthValue = String(row?.[monthColumn] || '').trim();
+		if (!/^\d{4}-\d{2}$/.test(monthValue)) {
+			return;
+		}
+		const numeric = parseNumericLoose(row?.[totalColumn]);
+		if (numeric === null) {
+			return;
+		}
+		result.set(monthValue, (result.get(monthValue) || 0) + numeric);
+	});
+	return result.size ? result : null;
+}
+
+function parseCustomerMonthTotalsFromDisplay(display: any): {
+	entries: Array<{ customer: string; month: string; total: number }>;
+	nonUnknownCustomers: Set<string>;
+	monthTotals: Map<string, number>;
+} | null {
+	if (!display || !Array.isArray(display.columns) || !Array.isArray(display.rows) || !display.rows.length) {
+		return null;
+	}
+	const columns = display.columns.map((column: any) => String(column || '').trim());
+	const normalizedColumns = columns.map(toNormalizedKey);
+	const monthColumns = collectMonthColumns(columns);
+	const entries: Array<{ customer: string; month: string; total: number }> = [];
+
+	if (monthColumns.length && normalizedColumns[0]?.includes('customer')) {
+		const customerColumn = columns[0];
+		display.rows.forEach((row: any) => {
+			const customer = String(row?.[customerColumn] || '').trim() || 'Unknown Customer';
+			monthColumns.forEach((month) => {
+				const total = parseNumericLoose(row?.[month]);
+				if (total === null) {
+					return;
+				}
+				entries.push({ customer, month, total });
+			});
+		});
+	}
+	else {
+		const customerColumnIndex = normalizedColumns.findIndex((column) => column.includes('customer'));
+		const monthColumnIndex = normalizedColumns.findIndex((column) => column.includes('month'));
+		const totalColumnIndex = normalizedColumns.findIndex((column) => column.includes('revenue') || column.includes('total'));
+		if (customerColumnIndex === -1 || monthColumnIndex === -1 || totalColumnIndex === -1) {
+			return null;
+		}
+		const customerColumn = columns[customerColumnIndex];
+		const monthColumn = columns[monthColumnIndex];
+		const totalColumn = columns[totalColumnIndex];
+		display.rows.forEach((row: any) => {
+			const customer = String(row?.[customerColumn] || '').trim() || 'Unknown Customer';
+			const month = String(row?.[monthColumn] || '').trim();
+			if (!/^\d{4}-\d{2}$/.test(month)) {
+				return;
+			}
+			const total = parseNumericLoose(row?.[totalColumn]);
+			if (total === null) {
+				return;
+			}
+			entries.push({ customer, month, total });
+		});
+	}
+	if (!entries.length) {
+		return null;
+	}
+	const nonUnknownCustomers = new Set<string>();
+	const monthTotals = new Map<string, number>();
+	entries.forEach((entry) => {
+		if (!/^unknown customer$/i.test(entry.customer)) {
+			nonUnknownCustomers.add(entry.customer.toLowerCase());
+		}
+		monthTotals.set(entry.month, (monthTotals.get(entry.month) || 0) + entry.total);
+	});
+	return {
+		entries,
+		nonUnknownCustomers,
+		monthTotals
+	};
+}
+
+function parseDimensionMonthTotalsFromDisplay(
+	display: any,
+	dimensionCandidates: string[]
+): {
+	entries: Array<{ dimension: string; month: string; total: number }>;
+	nonUnknownDimensions: Set<string>;
+	monthTotals: Map<string, number>;
+	dimensionTotals: Map<string, number>;
+} | null {
+	if (!display || !Array.isArray(display.columns) || !Array.isArray(display.rows) || !display.rows.length) {
+		return null;
+	}
+	const columns = display.columns.map((column: any) => String(column || '').trim());
+	const normalizedColumns = columns.map(toNormalizedKey);
+	const normalizedDimensionCandidates = (Array.isArray(dimensionCandidates) ? dimensionCandidates : [])
+		.map(candidate => toNormalizedKey(candidate))
+		.filter(Boolean);
+	const isDimensionColumn = (value: string): boolean => {
+		return normalizedDimensionCandidates.some((candidate) => value === candidate || value.includes(candidate));
+	};
+	const monthColumns = collectMonthColumns(columns);
+	const entries: Array<{ dimension: string; month: string; total: number }> = [];
+
+	if (monthColumns.length && isDimensionColumn(normalizedColumns[0] || '')) {
+		const dimensionColumn = columns[0];
+		display.rows.forEach((row: any) => {
+			const dimension = String(row?.[dimensionColumn] || '').trim() || 'Unknown';
+			monthColumns.forEach((month) => {
+				const total = parseNumericLoose(row?.[month]);
+				if (total === null) {
+					return;
+				}
+				entries.push({ dimension, month, total });
+			});
+		});
+	}
+	else {
+		const dimensionColumnIndex = normalizedColumns.findIndex(column => isDimensionColumn(column));
+		const monthColumnIndex = normalizedColumns.findIndex(column => column.includes('month'));
+		const totalColumnIndex = normalizedColumns.findIndex((column) => (
+			column.includes('revenue')
+			|| column.includes('total')
+			|| column.includes('hour')
+			|| column.includes('amount')
+			|| column.includes('billable')
+		));
+		if (dimensionColumnIndex === -1 || monthColumnIndex === -1 || totalColumnIndex === -1) {
+			return null;
+		}
+		const dimensionColumn = columns[dimensionColumnIndex];
+		const monthColumn = columns[monthColumnIndex];
+		const totalColumn = columns[totalColumnIndex];
+		display.rows.forEach((row: any) => {
+			const dimension = String(row?.[dimensionColumn] || '').trim() || 'Unknown';
+			const month = String(row?.[monthColumn] || '').trim();
+			if (!/^\d{4}-\d{2}$/.test(month)) {
+				return;
+			}
+			const total = parseNumericLoose(row?.[totalColumn]);
+			if (total === null) {
+				return;
+			}
+			entries.push({ dimension, month, total });
+		});
+	}
+	if (!entries.length) {
+		return null;
+	}
+	const nonUnknownDimensions = new Set<string>();
+	const monthTotals = new Map<string, number>();
+	const dimensionTotals = new Map<string, number>();
+	entries.forEach((entry) => {
+		if (!/^(unknown|unassigned)(\s|$)/i.test(entry.dimension)) {
+			nonUnknownDimensions.add(entry.dimension.toLowerCase());
+		}
+		monthTotals.set(entry.month, (monthTotals.get(entry.month) || 0) + entry.total);
+		dimensionTotals.set(entry.dimension, (dimensionTotals.get(entry.dimension) || 0) + entry.total);
+	});
+	return {
+		entries,
+		nonUnknownDimensions,
+		monthTotals,
+		dimensionTotals
+	};
+}
+
+function mapExpectedStatusCounts(rows: Array<Record<string, any>>): Map<string, number> {
+	const map = new Map<string, number>();
+	rows.forEach((row) => {
+		const status = String(row?.status || row?.state || row?._id || 'Unknown').trim() || 'Unknown';
+		const count = Number(row?.work_order_count || row?.count || 0);
+		map.set(status, count);
+	});
+	return map;
+}
+
+function mapDisplayStatusCounts(display: any): Map<string, number> | null {
+	if (!display || !Array.isArray(display.columns) || !Array.isArray(display.rows)) {
+		return null;
+	}
+	const columns = display.columns.map((column: any) => String(column || '').trim());
+	const normalizedColumns = columns.map(toNormalizedKey);
+	const statusIndex = normalizedColumns.findIndex((column) => column.includes('status') || column.includes('state') || column === 'group');
+	const countIndex = normalizedColumns.findIndex((column) => column.includes('count') || column.includes('total') || column.includes('workorder'));
+	if (statusIndex === -1 || countIndex === -1) {
+		return null;
+	}
+	const statusColumn = columns[statusIndex];
+	const countColumn = columns[countIndex];
+	const map = new Map<string, number>();
+	display.rows.forEach((row: any) => {
+		const status = String(row?.[statusColumn] || 'Unknown').trim() || 'Unknown';
+		const count = parseNumericLoose(row?.[countColumn]);
+		if (count === null) {
+			return;
+		}
+		map.set(status, count);
+	});
+	return map;
+}
+
+function resolveFirstExistingField(row: Record<string, any>, candidates: string[]): string | null {
+	const keys = Object.keys(row || {});
+	const normalizedToRaw = new Map<string, string>();
+	keys.forEach((key) => {
+		normalizedToRaw.set(toNormalizedKey(key), key);
+	});
+	for (const candidate of candidates) {
+		const raw = normalizedToRaw.get(toNormalizedKey(candidate));
+		if (raw) {
+			return raw;
+		}
+	}
+	return null;
+}
+
+function mapExpectedByDimension(
+	rows: Array<Record<string, any>>,
+	dimensionCandidates: string[],
+	valueCandidates: string[]
+): Map<string, number> | null {
+	const firstRow = rows.find(row => row && typeof row === 'object') || null;
+	if (!firstRow) {
+		return new Map<string, number>();
+	}
+	const dimensionField = resolveFirstExistingField(firstRow, dimensionCandidates);
+	const valueField = resolveFirstExistingField(firstRow, valueCandidates);
+	if (!dimensionField || !valueField) {
+		return null;
+	}
+	const map = new Map<string, number>();
+	rows.forEach((row) => {
+		const key = normalizeOptionalString(row?.[dimensionField]);
+		if (!key) {
+			return;
+		}
+		const numeric = parseNumericLoose(row?.[valueField]);
+		if (numeric === null) {
+			return;
+		}
+		map.set(key, (map.get(key) || 0) + numeric);
+	});
+	return map;
+}
+
+function mapDisplayByDimension(
+	display: any,
+	dimensionCandidates: string[],
+	valueCandidates: string[]
+): Map<string, number> | null {
+	if (!display || !Array.isArray(display.columns) || !Array.isArray(display.rows)) {
+		return null;
+	}
+	const columns = display.columns.map((column: any) => String(column || '').trim());
+	const normalizedColumns = columns.map(toNormalizedKey);
+	const dimensionIndex = dimensionCandidates
+		.map(candidate => normalizedColumns.findIndex(column => column === toNormalizedKey(candidate) || column.includes(toNormalizedKey(candidate))))
+		.find(index => index !== undefined && index >= 0);
+	const valueIndex = valueCandidates
+		.map(candidate => normalizedColumns.findIndex(column => column === toNormalizedKey(candidate) || column.includes(toNormalizedKey(candidate))))
+		.find(index => index !== undefined && index >= 0);
+	if (dimensionIndex === undefined || dimensionIndex < 0 || valueIndex === undefined || valueIndex < 0) {
+		return null;
+	}
+	const dimensionColumn = columns[dimensionIndex];
+	const valueColumn = columns[valueIndex];
+	const map = new Map<string, number>();
+	display.rows.forEach((row: any) => {
+		const key = normalizeOptionalString(row?.[dimensionColumn]);
+		if (!key) {
+			return;
+		}
+		const numeric = parseNumericLoose(row?.[valueColumn]);
+		if (numeric === null) {
+			return;
+		}
+		map.set(key, (map.get(key) || 0) + numeric);
+	});
+	return map;
+}
+
+function parseSingleCountFromDisplay(display: any): number | null {
+	if (!display || !Array.isArray(display.columns) || !Array.isArray(display.rows) || !display.rows.length) {
+		return null;
+	}
+	const columns = display.columns.map((column: any) => String(column || '').trim());
+	const normalizedColumns = columns.map(toNormalizedKey);
+	const countIndex = normalizedColumns.findIndex((column) => (
+		column.includes('count')
+		|| column.includes('total')
+		|| column.includes('active')
+		|| column.includes('clients')
+		|| column.includes('customers')
+	));
+	if (countIndex === -1) {
+		return null;
+	}
+	const countColumn = columns[countIndex];
+	for (const row of display.rows) {
+		const numeric = parseNumericLoose(row?.[countColumn]);
+		if (numeric !== null) {
+			return numeric;
+		}
+	}
+	return null;
+}
+
+function compareNumericMaps(
+	label: string,
+	expected: Map<string, number>,
+	actual: Map<string, number>,
+	tolerance = 0.01
+): string[] {
+	const errors: string[] = [];
+	const keys = new Set<string>([...Array.from(expected.keys()), ...Array.from(actual.keys())]);
+	keys.forEach((key) => {
+		const left = expected.get(key);
+		const right = actual.get(key);
+		if (left === undefined) {
+			errors.push(`${label}: unexpected key "${key}" in AI output.`);
+			return;
+		}
+		if (right === undefined) {
+			errors.push(`${label}: missing key "${key}" in AI output.`);
+			return;
+		}
+		if (Math.abs(left - right) > tolerance) {
+			errors.push(`${label}: mismatch for "${key}" expected=${left} actual=${right}.`);
+		}
+	});
+	return errors;
+}
+
+async function sleep(ms: number): Promise<void> {
+	return await new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function findSuperAdminUserId(db: any): Promise<string> {
+	const user = await db.collection('users').findOne(
+		{ 'roles.super_admin': true },
+		{ projection: { _id: 1 }, sort: { updatedAt: -1, createdAt: -1 } }
+	);
+	if (!user?._id) {
+		throw new Error('Could not find super admin user.');
+	}
+	return String(user._id);
+}
+
+async function resolveExistingCollection(db: any, candidates: string[]): Promise<string | null> {
+	const rows = await db.listCollections({}, { nameOnly: true }).toArray();
+	const names = new Set(rows.map((row: any) => normalizeOptionalString(row?.name)));
+	for (const candidate of candidates) {
+		if (names.has(candidate)) {
+			return candidate;
+		}
+	}
+	return null;
+}
+
+async function detectFieldPresence(db: any, collection: string, fields: string[]): Promise<Record<string, boolean>> {
+	const projection = fields.reduce((acc: Record<string, number>, field) => {
+		acc[field] = 1;
+		return acc;
+	}, {});
+	const docs = await db.collection(collection).find({}, { projection, limit: 200 }).toArray();
+	const result: Record<string, boolean> = {};
+	fields.forEach((field) => {
+		result[field] = docs.some((doc: any) => doc && doc[field] !== undefined && doc[field] !== null && String(doc[field]).trim() !== '');
+	});
+	return result;
+}
+
+async function pollFinalAssistantMessage(db: any, idConversation: string, timeoutMs = 180000): Promise<any> {
+	const started = Date.now();
+	while (Date.now() - started < timeoutMs) {
+		const message = await db.collection('ai-terminal-messages').findOne(
+			{ id_conversation: idConversation, role: 'assistant' },
+			{ sort: { createdAt: -1 } }
+		);
+		if (message && message?.metadata?.pending !== true) {
+			return message;
+		}
+		await sleep(1200);
+	}
+	throw new Error(`Timed out waiting for final assistant message (${idConversation}).`);
+}
+
+function buildMongoCommonContext(methodManager: any, idUser: string): any {
+	return Object.assign({}, methodManager, Object.getPrototypeOf(methodManager), {
+		id_user: idUser,
+		user: 'AI Parity Runner',
+		id_ws: 'ai-assistant-data-parity-e2e'
+	});
+}
+
+async function callMethodAsUser(methodManager: any, idUser: string, method: string, payload: Record<string, any>): Promise<any> {
+	const ctx = buildMongoCommonContext(methodManager, idUser);
+	return await methodManager.callMethod.call(ctx, method, payload);
+}
+
+async function runPrompt(methodManager: any, db: any, idUser: string, prompt: string, appId: string): Promise<{ conversationId: string; message: any }> {
+	const model = String(process.env.AI_ASSISTANT_CODEX_MODEL || process.env.OPENAI_MODEL || '').trim();
+	const payload = {
+		message: prompt,
+		id_app: appId,
+		max_history: 0,
+		config: {
+			...(model ? { model } : {})
+		}
+	};
+	const response = await callMethodAsUser(methodManager, idUser, 'aiCoderTerminalRunCodex', payload);
+	const conversationId = String(response?.conversation?._id || response?.conversation?.id_conversation || '').trim();
+	if (!conversationId) {
+		throw new Error('No conversation id returned from aiCoderTerminalRunCodex.');
+	}
+	const message = await pollFinalAssistantMessage(db, conversationId);
+	return { conversationId, message };
+}
+
+function parseDirectiveLine(content: string): AssistantDirective | null {
+	const lines = String(content || '').split(/\r?\n/g);
+	for (const lineRaw of lines) {
+		const line = lineRaw.trim();
+		if (!line) {
+			continue;
+		}
+		const readPrefix = 'REPORT_BUILDER_READ:';
+		const aggPrefix = 'REPORT_BUILDER_AGG:';
+		let type: AssistantDirective['type'] | null = null;
+		let jsonText = '';
+		if (line.startsWith(readPrefix)) {
+			type = 'read';
+			jsonText = line.slice(readPrefix.length).trim();
+		}
+		else if (line.startsWith(aggPrefix)) {
+			type = 'aggregate';
+			jsonText = line.slice(aggPrefix.length).trim();
+		}
+		if (!type || !jsonText) {
+			continue;
+		}
+		try {
+			const payload = JSON.parse(jsonText);
+			if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+				continue;
+			}
+			return {
+				type,
+				payload,
+				source: 'assistant.directive_line'
+			};
+		}
+		catch {
+			continue;
+		}
+	}
+	return null;
+}
+
+function extractDirectiveFromMessage(message: any): AssistantDirective | null {
+	const debugDirective = message?.metadata?.debug?.directive;
+	if (debugDirective && typeof debugDirective === 'object') {
+		const normalizedType = normalizeOptionalString(debugDirective?.type).toLowerCase();
+		if ((normalizedType === 'read' || normalizedType === 'aggregate')
+			&& debugDirective.payload
+			&& typeof debugDirective.payload === 'object'
+			&& !Array.isArray(debugDirective.payload)) {
+			return {
+				type: normalizedType as AssistantDirective['type'],
+				payload: debugDirective.payload,
+				source: 'metadata.debug.directive'
+			};
+		}
+		const rawLineDirective = parseDirectiveLine(normalizeOptionalString(debugDirective?.rawLine));
+		if (rawLineDirective) {
+			return {
+				...rawLineDirective,
+				source: 'metadata.debug.directive'
+			};
+		}
+	}
+	return parseDirectiveLine(normalizeOptionalString(message?.content));
+}
+
+function buildSyntheticToolResultFromDirective(directive: AssistantDirective, methodResponse: any): any {
+	const display = methodResponse?.display && typeof methodResponse.display === 'object'
+		? methodResponse.display
+		: {
+			columns: [] as string[],
+			rows: [] as Array<Record<string, any>>,
+			rowCount: 0,
+			truncated: false
+		};
+	const rowCount = Array.isArray(methodResponse?.documents)
+		? methodResponse.documents.length
+		: Number(display?.rowCount || 0);
+	const total = typeof methodResponse?.total === 'number' ? methodResponse.total : undefined;
+	const verification = methodResponse?.verification && typeof methodResponse.verification === 'object'
+		? methodResponse.verification
+		: undefined;
+	const collection = normalizeOptionalString(methodResponse?.debug?.collectionResolved)
+		|| normalizeOptionalString(methodResponse?.debug?.collection)
+		|| normalizeOptionalString(directive.payload?.collection);
+	return {
+		type: directive.type === 'aggregate' ? 'mongo_agg' : 'mongo_read',
+		input: directive.payload,
+		output: {
+			display,
+			total,
+			collection: collection || undefined,
+			rowCount,
+			columns: Array.isArray(display?.columns) ? display.columns : [],
+			truncated: display?.truncated === true,
+			verification,
+			debug: methodResponse?.debug && typeof methodResponse.debug === 'object' ? methodResponse.debug : undefined
+		}
+	};
+}
+
+function resolveParityCases(): ParityCase[] {
+	return [
+		{
+			id: 'active_clients_count',
+			prompt: 'How many active clients do I have right now?',
+			runExpected: async (context) => {
+				const collection = await resolveExistingCollection(context.db, ['clients', 'customers']);
+				if (!collection) {
+					return { rows: [], meta: { activeCount: 0, collection: null, basis: 'missing_collection' } };
+				}
+				const collectionFamily = normalizeOptionalString(collection).toLowerCase();
+				const activeFields = ['status', 'active', 'is_active', 'isactive', 'enabled', 'is_enabled', 'isenabled'];
+				if (!['clients', 'customers'].includes(collectionFamily)) {
+					activeFields.splice(1, 0, 'state');
+				}
+				const fieldPresence = await detectFieldPresence(context.db, collection, activeFields);
+				const hasAnyActiveField = activeFields.some(field => fieldPresence[field] === true);
+				let query: Record<string, any> = {};
+				let basis = 'all_records_default_active';
+				if (hasAnyActiveField) {
+					const activeBranches: Record<string, any>[] = [
+						{ status: { $regex: '^active$', $options: 'i' } },
+						{ active: true },
+						{ is_active: true },
+						{ isactive: true },
+						{ enabled: true },
+						{ is_enabled: true },
+						{ isenabled: true }
+					];
+					if (!['clients', 'customers'].includes(collectionFamily)) {
+						activeBranches.splice(1, 0, { state: { $regex: '^active$', $options: 'i' } });
+					}
+					query = {
+						$or: activeBranches
+					};
+					basis = 'status_or_active_field';
+				}
+				const count = await context.db.collection(collection).countDocuments(query);
+				const rows = await context.db.collection(collection).find(
+					query,
+					{
+						projection: {
+							status: 1,
+							state: 1,
+							active: 1,
+							is_active: 1,
+							isactive: 1,
+							enabled: 1,
+							is_enabled: 1,
+							isenabled: 1
+						},
+						limit: 50
+					}
+				).toArray();
+				return { rows, meta: { activeCount: count, collection, basis } };
+			},
+			compare: ({ toolResult, assistantContent, expected }) => {
+				const errors: string[] = [];
+				const expectedCount = Number(expected?.meta?.activeCount || 0);
+				const displayCount = parseSingleCountFromDisplay(toolResult?.output?.display);
+				const actualTotal = typeof toolResult?.output?.total === 'number'
+					? toolResult.output.total
+					: (displayCount !== null ? displayCount : Number(toolResult?.output?.rowCount || 0));
+				if (actualTotal !== expectedCount) {
+					errors.push(
+						`Active client count mismatch: expected=${expectedCount}, ai=${actualTotal}, basis=${String(expected?.meta?.basis || 'unknown')}, collection=${String(expected?.meta?.collection || 'unknown')}.`
+					);
+				}
+				errors.push(...collectCommonFormattingErrors(assistantContent));
+				return errors;
+			}
+		},
+		{
+			id: 'wo_last20_this_week_group_status',
+			prompt: 'Show me the last 20 work orders created this week, grouped by status.',
+			runExpected: async (context) => {
+				const rows = await context.db.collection('work-order-dynamics').aggregate([
+					{
+						$match: {
+							date_created: { $gte: context.startOfWeek, $lt: context.now }
+						}
+					},
+					{ $sort: { date_created: -1 } },
+					{ $limit: 20 },
+					{
+						$group: {
+							_id: { $ifNull: ['$status', 'Unknown'] },
+							work_order_count: { $sum: 1 }
+						}
+					},
+					{ $sort: { work_order_count: -1, _id: 1 } },
+					{
+						$project: {
+							_id: 0,
+							status: '$_id',
+							work_order_count: 1
+						}
+					}
+				]).toArray();
+				return { rows };
+			},
+			compare: ({ toolResult, assistantContent, expected }) => {
+				const errors: string[] = [];
+				const expectedMap = mapExpectedStatusCounts(expected.rows || []);
+				const actualRowCount = Number(toolResult?.output?.rowCount || 0);
+				if (expectedMap.size === 0 && actualRowCount === 0) {
+					// No rows in either source; status grouping table may be absent by design.
+				}
+				else {
+					const actualMap = mapDisplayStatusCounts(toolResult?.output?.display);
+					if (!actualMap) {
+						errors.push('Could not parse status/count columns from AI display.');
+					}
+					else {
+						errors.push(...compareNumericMaps('Status counts', expectedMap, actualMap, 0));
+					}
+				}
+				errors.push(...collectCommonFormattingErrors(assistantContent));
+				return errors;
+			}
+		},
+		{
+			id: 'wo_last20_this_week_by_status_alias',
+			prompt: 'Show me the last 20 work orders created this week by status.',
+			runExpected: async (context) => {
+				const rows = await context.db.collection('work-order-dynamics').aggregate([
+					{
+						$match: {
+							date_created: { $gte: context.startOfWeek, $lt: context.now }
+						}
+					},
+					{ $sort: { date_created: -1 } },
+					{ $limit: 20 },
+					{
+						$group: {
+							_id: { $ifNull: ['$status', 'Unknown'] },
+							work_order_count: { $sum: 1 }
+						}
+					},
+					{ $sort: { work_order_count: -1, _id: 1 } },
+					{
+						$project: {
+							_id: 0,
+							status: '$_id',
+							work_order_count: 1
+						}
+					}
+				]).toArray();
+				return { rows };
+			},
+			compare: ({ toolResult, assistantContent, expected }) => {
+				const errors: string[] = [];
+				const expectedMap = mapExpectedStatusCounts(expected.rows || []);
+				const actualRowCount = Number(toolResult?.output?.rowCount || 0);
+				if (expectedMap.size === 0 && actualRowCount === 0) {
+					// No rows in either source; status grouping table may be absent by design.
+				}
+				else {
+					const actualMap = mapDisplayStatusCounts(toolResult?.output?.display);
+					if (!actualMap) {
+						errors.push('Could not parse status/count columns from AI display.');
+					}
+					else {
+						errors.push(...compareNumericMaps('Status counts', expectedMap, actualMap, 0));
+					}
+				}
+				errors.push(...collectCommonFormattingErrors(assistantContent));
+				return errors;
+			}
+		},
+		{
+			id: 'wo_completed_per_day_last_30d',
+			prompt: 'For the last 30 days, how many work orders were completed per day?',
+			runExpected: async (context) => {
+				const last30Days = addDaysUtc(context.now, -30);
+				const rows = await context.db.collection('work-order-dynamics').aggregate([
+					{
+						$match: {
+							date_completed: { $gte: last30Days, $lt: context.now }
+						}
+					},
+					{
+						$group: {
+							_id: {
+								$dateToString: { format: '%Y-%m-%d', date: '$date_completed', timezone: 'UTC' }
+							},
+							completed_work_orders: { $sum: 1 }
+						}
+					},
+					{ $sort: { _id: 1 } },
+					{
+						$project: {
+							_id: 0,
+							day_utc: '$_id',
+							completed_work_orders: 1
+						}
+					}
+				]).toArray();
+				return { rows };
+			},
+			compare: ({ toolResult, assistantContent, expected }) => {
+				const errors: string[] = [];
+				const expectedRows = Array.isArray(expected.rows) ? expected.rows.length : 0;
+				const actualRows = Number(toolResult?.output?.rowCount || 0);
+				if (expectedRows === 0 && actualRows === 0) {
+					errors.push(...collectCommonFormattingErrors(assistantContent));
+					return errors;
+				}
+				const expectedMap = mapExpectedByDimension(expected.rows || [], ['day_utc', 'day'], ['completed_work_orders', 'work_order_count', 'count']);
+				const actualMap = mapDisplayByDimension(toolResult?.output?.display, ['day', 'day_utc', 'date'], ['completed', 'count', 'work_order_count', 'total']);
+				if (!expectedMap || !actualMap) {
+					errors.push('Could not parse day/count map for completed work orders.');
+				}
+				else {
+					errors.push(...compareNumericMaps('Completed work orders per day', expectedMap, actualMap, 0));
+				}
+				errors.push(...collectCommonFormattingErrors(assistantContent));
+				return errors;
+			}
+		},
+		{
+			id: 'wo_top_customers_last_6m',
+			prompt: 'List the top 10 customers by number of work orders in the last 6 months.',
+			runExpected: async (context) => {
+				const collectionRows = await context.db.listCollections({}, { nameOnly: true }).toArray();
+				const collectionNames = new Set(collectionRows.map((row: any) => normalizeOptionalString(row?.name)));
+				const collectionCandidates = ['work-order-dynamics', 'maintenance-orders', 'orders']
+					.filter(name => collectionNames.has(name));
+				if (!collectionCandidates.length) {
+					return {
+						rows: [],
+						meta: { collection: null, basis: 'missing_collection' }
+					};
+				}
+				for (const candidate of collectionCandidates) {
+					const rows = await context.db.collection(candidate).aggregate([
+						{
+							$addFields: {
+								effective_date: {
+									$ifNull: [
+										'$date_created',
+										{ $ifNull: ['$date_create', '$createdAt'] }
+									]
+								},
+								customer_label: {
+									$ifNull: [
+										'$customer',
+										{
+											$ifNull: [
+												'$customer_name',
+												{
+													$ifNull: [
+														'$client_name',
+														{
+															$ifNull: [
+																{ $toString: '$id_customer' },
+																{ $ifNull: ['$qb_ListID_class', 'Unknown'] }
+															]
+														}
+													]
+												}
+											]
+										}
+									]
+								}
+							}
+						},
+						{
+							$match: {
+								effective_date: { $gte: context.last6MonthsStart, $lt: context.now },
+								'deleted.date': { $exists: false }
+							}
+						},
+						{
+							$group: {
+								_id: '$customer_label',
+								work_order_count: { $sum: 1 }
+							}
+						},
+						{ $sort: { work_order_count: -1, _id: 1 } },
+						{ $limit: 10 },
+						{
+							$project: {
+								_id: 0,
+								customer: '$_id',
+								work_order_count: 1
+							}
+						}
+					]).toArray();
+					if (rows.length) {
+						return { rows, meta: { collection: candidate, basis: 'first_non_empty_candidate' } };
+					}
+				}
+				return { rows: [], meta: { collection: collectionCandidates[0], basis: 'zero_rows_all_candidates' } };
+			},
+			compare: ({ toolResult, assistantContent, expected }) => {
+				const errors: string[] = [];
+				const expectedRows = Array.isArray(expected.rows) ? expected.rows.length : 0;
+				const actualRows = Number(toolResult?.output?.rowCount || 0);
+				if (expectedRows === 0 && actualRows === 0) {
+					errors.push(...collectCommonFormattingErrors(assistantContent));
+					return errors;
+				}
+				if (expectedRows > 0 && actualRows === 0) {
+					errors.push(`Expected top-customer work-order rows (${expectedRows}), but AI returned zero rows.`);
+				}
+				const expectedMap = mapExpectedByDimension(expected.rows || [], ['customer'], ['work_order_count', 'count']);
+				const actualMap = mapDisplayByDimension(toolResult?.output?.display, ['customer', 'client', 'account'], ['work_order_count', 'count', 'total']);
+				if (!expectedMap || !actualMap) {
+					errors.push('Could not parse customer/count map for top work-order customers.');
+				}
+				else {
+					errors.push(...compareNumericMaps('Top customers by work-order count', expectedMap, actualMap, 0));
+				}
+				errors.push(...collectCommonFormattingErrors(assistantContent));
+				return errors;
+			}
+		},
+		{
+			id: 'blend_last10_summary',
+			prompt: 'For blending: summarize the last 10 blend tickets with product, total volume, and created date.',
+			runExpected: async (context) => {
+				const rows = await context.db.collection('chemical-blends').aggregate([
+					{ $sort: { date: -1, createdAt: -1 } },
+					{ $limit: 10 },
+					{
+						$project: {
+							_id: 1,
+							product: { $ifNull: ['$blend_name', '$chemical'] },
+							total_volume: '$chemical_recipe_quantity',
+							volume_unit: { $cond: [{ $eq: ['$blend_in_pounds', true] }, 'lb', 'gal'] },
+							created_date: { $ifNull: ['$date', '$createdAt'] },
+							batch_number: 1
+						}
+					}
+				]).toArray();
+				return { rows };
+			},
+			compare: ({ toolResult, assistantContent, expected }) => {
+				const errors: string[] = [];
+				const expectedCount = Array.isArray(expected.rows) ? expected.rows.length : 0;
+				const actualCount = Number(toolResult?.output?.rowCount || 0);
+				if (actualCount !== expectedCount) {
+					errors.push(`Blend last-10 row count mismatch: expected=${expectedCount}, ai=${actualCount}.`);
+				}
+				const normalizedColumns = (toolResult?.output?.columns || []).map((column: string) => toNormalizedKey(column));
+				if (!normalizedColumns.some((column: string) => column.includes('product') || column.includes('blend') || column.includes('chemical'))) {
+					errors.push('Blend summary missing a product/blend column.');
+				}
+				if (!normalizedColumns.some((column: string) => column.includes('volume') || column.includes('quantity'))) {
+					errors.push('Blend summary missing a volume column.');
+				}
+				errors.push(...collectCommonFormattingErrors(assistantContent));
+				return errors;
+			}
+		},
+		{
+			id: 'invoice_top_customers_total_last_6m',
+			prompt: 'Show top 10 customers by invoice total in the last 6 months.',
+			runExpected: async (context) => {
+				const rows = await context.db.collection('invoices').aggregate([
+					{
+						$addFields: {
+							effective_date: {
+								$ifNull: [
+									'$date_paid',
+									{ $ifNull: ['$date_invoiced', '$createdAt'] }
+								]
+							},
+							effective_total: { $ifNull: ['$paid_total', '$grand_total'] },
+							customer_label: {
+								$ifNull: [
+									'$customer_name',
+									{
+										$ifNull: [
+											'$customer.fullname',
+											{
+												$ifNull: [
+													'$customer.name',
+													{
+														$ifNull: [
+															'$customer',
+															{ $ifNull: ['$client_name', { $ifNull: ['$client.fullname', { $ifNull: ['$client.name', { $ifNull: ['$client', 'Unknown Customer'] }] }] }] }
+														]
+													}
+												]
+											}
+										]
+									}
+								]
+							}
+						}
+					},
+					{
+						$match: {
+							effective_date: { $gte: context.last6MonthsStart, $lt: context.now }
+						}
+					},
+					{
+						$group: {
+							_id: '$customer_label',
+							invoice_total: { $sum: { $ifNull: ['$effective_total', 0] } },
+							invoice_count: { $sum: 1 }
+						}
+					},
+					{
+						$project: {
+							_id: 0,
+							customer: '$_id',
+							invoice_total: 1,
+							invoice_count: 1
+						}
+					},
+					{ $sort: { invoice_total: -1, invoice_count: -1 } },
+					{ $limit: 10 }
+				]).toArray();
+				return { rows };
+			},
+			compare: ({ toolResult, assistantContent, expected }) => {
+				const errors: string[] = [];
+				const expectedMap = mapExpectedByDimension(expected.rows || [], ['customer'], ['invoice_total', 'total_revenue', 'total']);
+				const actualMap = mapDisplayByDimension(toolResult?.output?.display, ['customer', 'client', 'account'], ['invoice_total', 'total_revenue', 'total', 'revenue']);
+				if (!expectedMap || !actualMap) {
+					errors.push('Could not parse customer/total map for invoice top customers.');
+				}
+				else {
+					errors.push(...compareNumericMaps('Top customers by invoice total', expectedMap, actualMap, 0.05));
+				}
+				errors.push(...collectCommonFormattingErrors(assistantContent));
+				return errors;
+			}
+		},
+		{
+			id: 'deliveries_per_driver_last_month',
+			prompt: 'Break down the number of deliveries per driver last month',
+			runExpected: async (context) => {
+				const thisMonthStart = startOfMonthUtc(context.now);
+				const lastMonthStart = startOfMonthUtc(addMonthsUtc(thisMonthStart, -1));
+				const rows = await context.db.collection('work-order-dynamics').aggregate([
+					{
+						$match: {
+							date_completed: { $gte: lastMonthStart, $lt: thisMonthStart },
+							status: { $in: ['Completed', 'Closed'] }
+						}
+					},
+					{ $unwind: { path: '$drivers', preserveNullAndEmptyArrays: true } },
+					{
+						$group: {
+							_id: { $ifNull: ['$drivers.user', 'Unassigned'] },
+							delivery_count: { $sum: 1 }
+						}
+					},
+					{ $sort: { delivery_count: -1, _id: 1 } },
+					{
+						$project: {
+							_id: 0,
+							driver: '$_id',
+							delivery_count: 1
+						}
+					}
+				]).toArray();
+				return { rows };
+			},
+			compare: ({ toolResult, assistantContent, expected }) => {
+				const errors: string[] = [];
+				const expectedMap = mapExpectedByDimension(expected.rows || [], ['driver', 'user'], ['delivery_count', 'count']);
+				const actualMap = mapDisplayByDimension(toolResult?.output?.display, ['driver', 'user', 'name'], ['delivery_count', 'count', 'total']);
+				if (!expectedMap || !actualMap) {
+					errors.push('Could not parse driver/delivery-count map.');
+				}
+				else {
+					errors.push(...compareNumericMaps('Deliveries per driver', expectedMap, actualMap, 0));
+				}
+				errors.push(...collectCommonFormattingErrors(assistantContent));
+				return errors;
+			}
+		},
+		{
+			id: 'invoice_revenue_monthly_grid_last_6m',
+			prompt: 'Break down my total revenue over the last 6 month by month',
+			runExpected: async (context) => {
+				const rows = await context.db.collection('invoices').aggregate([
+					{
+						$addFields: {
+							effective_date: {
+								$ifNull: [
+									'$date_paid',
+									{ $ifNull: ['$date_invoiced', '$createdAt'] }
+								]
+							},
+							effective_total: { $ifNull: ['$paid_total', '$grand_total'] }
+						}
+					},
+					{
+						$match: {
+							$expr: {
+								$and: [
+									{ $gte: ['$effective_date', context.last6FullMonthsStart] },
+									{ $lt: ['$effective_date', context.startOfCurrentMonth] }
+								]
+							}
+						}
+					},
+					{
+						$group: {
+							_id: {
+								bucket: {
+									$dateTrunc: {
+										date: '$effective_date',
+										unit: 'month'
+									}
+								}
+							},
+							total_revenue: {
+								$sum: { $ifNull: ['$effective_total', 0] }
+							}
+						}
+					},
+					{
+						$project: {
+							_id: 0,
+							month: { $dateToString: { format: '%Y-%m', date: '$_id.bucket' } },
+							total_revenue: 1
+						}
+					},
+					{ $sort: { month: 1 } }
+				]).toArray();
+				return { rows };
+			},
+			compare: ({ toolResult, assistantContent, expected }) => {
+				const errors: string[] = [];
+				const expectedDisplay = buildDisplayTable(expected.rows || [], { maxColumns: 40, maxRows: 1000 });
+				const expectedPivot = buildAssistantDatedPivotDisplay(expectedDisplay);
+				const expectedTotals = expectedPivot
+					? parseMonthlyTotalsFromDisplay(expectedPivot)
+					: parseMonthlyTotalsFromDisplay(expectedDisplay);
+				const actualTotals = parseMonthlyTotalsFromDisplay(toolResult?.output?.display);
+				if (!expectedTotals || !actualTotals) {
+					errors.push('Could not parse monthly totals for expected or AI display.');
+				}
+				else {
+					errors.push(...compareNumericMaps('Monthly revenue totals', expectedTotals, actualTotals, 0.05));
+				}
+				errors.push(...collectCommonFormattingErrors(assistantContent));
+				return errors;
+			}
+		},
+		{
+			id: 'invoice_revenue_monthly_customer_grid_last_6m',
+			prompt: 'Break down my total revenue over the last 6 month by month by each customer',
+			runExpected: async (context) => {
+				const rows = await context.db.collection('invoices').aggregate([
+					{
+						$addFields: {
+							effective_date: {
+								$ifNull: [
+									'$date_paid',
+									{ $ifNull: ['$date_invoiced', '$createdAt'] }
+								]
+							},
+							effective_total: { $ifNull: ['$paid_total', '$grand_total'] }
+						}
+					},
+					{
+						$match: {
+							$expr: {
+								$and: [
+									{ $gte: ['$effective_date', context.last6FullMonthsStart] },
+									{ $lt: ['$effective_date', context.startOfCurrentMonth] }
+								]
+							}
+						}
+					},
+					{
+						$group: {
+							_id: {
+								customer: {
+									$ifNull: [
+										'$customer_name',
+										{
+											$ifNull: [
+												'$customer.fullname',
+												{
+													$ifNull: [
+														'$customer.name',
+														{
+															$ifNull: [{ $toString: '$id_customer' }, 'Unknown Customer']
+														}
+													]
+												}
+											]
+										}
+									]
+								},
+								bucket: {
+									$dateTrunc: {
+										date: '$effective_date',
+										unit: 'month'
+									}
+								}
+							},
+							total_revenue: { $sum: { $ifNull: ['$effective_total', 0] } }
+						}
+					},
+					{
+						$project: {
+							_id: 0,
+							customer: '$_id.customer',
+							month: { $dateToString: { format: '%Y-%m', date: '$_id.bucket' } },
+							total_revenue: 1
+						}
+					},
+					{ $sort: { customer: 1, month: 1 } }
+				]).toArray();
+				return { rows };
+			},
+			compare: ({ toolResult, assistantContent, expected }) => {
+				const errors: string[] = [];
+				const expectedDisplay = buildDisplayTable(expected.rows || [], { maxColumns: 50, maxRows: 5000 });
+				const expectedPivot = buildAssistantDatedPivotDisplay(expectedDisplay) || expectedDisplay;
+				const expectedParsed = parseCustomerMonthTotalsFromDisplay(expectedPivot);
+				const actualParsed = parseCustomerMonthTotalsFromDisplay(toolResult?.output?.display);
+				if (!expectedParsed || !actualParsed) {
+					errors.push('Could not parse customer-month totals for expected or AI display.');
+				}
+				else {
+					errors.push(...compareNumericMaps('Customer monthly totals (summed by month)', expectedParsed.monthTotals, actualParsed.monthTotals, 0.05));
+					if (expectedParsed.nonUnknownCustomers.size >= 2 && actualParsed.nonUnknownCustomers.size < 2) {
+						errors.push(
+							`Expected multiple named customers (${expectedParsed.nonUnknownCustomers.size}), but AI returned ${actualParsed.nonUnknownCustomers.size}.`
+						);
+					}
+					const expectedCustomerCount = new Set(expectedParsed.entries.map(entry => entry.customer.toLowerCase())).size;
+					const actualCustomerCount = new Set(actualParsed.entries.map(entry => entry.customer.toLowerCase())).size;
+					const outputRowCount = Number(toolResult?.output?.rowCount || 0);
+					const outputDisplayRows = Array.isArray(toolResult?.output?.display?.rows) ? toolResult.output.display.rows.length : 0;
+					const outputTruncated = toolResult?.output?.truncated === true || toolResult?.output?.display?.truncated === true;
+					if (outputTruncated && outputRowCount > outputDisplayRows && expectedCustomerCount > actualCustomerCount) {
+						errors.push(
+							`Customer breakdown display is truncated (${outputDisplayRows} shown of ${outputRowCount} rows); expected ${expectedCustomerCount} customers but output shows ${actualCustomerCount}.`
+						);
+					}
+				}
+				errors.push(...collectCommonFormattingErrors(assistantContent));
+				return errors;
+			}
+		},
+		{
+				id: 'invoice_revenue_monthly_customer_grid_last_6m_per_customer',
+				prompt: 'Break down my total revenue over the last 6 month per month per customer',
+				runExpected: async (context) => {
+					const rows = await context.db.collection('invoices').aggregate([
+						{
+							$addFields: {
+								effective_date: {
+									$ifNull: [
+										'$date_paid',
+										{ $ifNull: ['$date_invoiced', '$createdAt'] }
+									]
+								},
+								effective_total: { $ifNull: ['$paid_total', '$grand_total'] }
+							}
+						},
+						{
+							$match: {
+								$expr: {
+									$and: [
+										{ $gte: ['$effective_date', context.last6FullMonthsStart] },
+										{ $lt: ['$effective_date', context.startOfCurrentMonth] }
+									]
+								}
+							}
+						},
+						{
+							$group: {
+								_id: {
+									customer: {
+										$ifNull: [
+											'$customer_name',
+											{
+												$ifNull: [
+													'$customer.fullname',
+													{
+														$ifNull: [
+															'$customer.name',
+															{
+																$ifNull: [{ $toString: '$id_customer' }, 'Unknown Customer']
+															}
+														]
+													}
+												]
+											}
+										]
+									},
+									bucket: {
+										$dateTrunc: {
+											date: '$effective_date',
+											unit: 'month'
+										}
+									}
+								},
+								total_revenue: { $sum: { $ifNull: ['$effective_total', 0] } }
+							}
+						},
+						{
+							$project: {
+								_id: 0,
+								customer: '$_id.customer',
+								month: { $dateToString: { format: '%Y-%m', date: '$_id.bucket' } },
+								total_revenue: 1
+							}
+						},
+						{ $sort: { customer: 1, month: 1 } }
+					]).toArray();
+					return { rows };
+				},
+			compare: ({ toolResult, assistantContent, expected }) => {
+					const errors: string[] = [];
+					const expectedDisplay = buildDisplayTable(expected.rows || [], { maxColumns: 50, maxRows: 5000 });
+					const expectedPivot = buildAssistantDatedPivotDisplay(expectedDisplay) || expectedDisplay;
+					const expectedParsed = parseCustomerMonthTotalsFromDisplay(expectedPivot);
+					const actualParsed = parseCustomerMonthTotalsFromDisplay(toolResult?.output?.display);
+					if (!expectedParsed || !actualParsed) {
+						errors.push('Could not parse customer-month totals for expected or AI display.');
+					}
+					else {
+						errors.push(...compareNumericMaps('Customer monthly totals (summed by month)', expectedParsed.monthTotals, actualParsed.monthTotals, 0.05));
+						if (expectedParsed.nonUnknownCustomers.size >= 2 && actualParsed.nonUnknownCustomers.size < 2) {
+							errors.push(
+								`Expected multiple named customers (${expectedParsed.nonUnknownCustomers.size}), but AI returned ${actualParsed.nonUnknownCustomers.size}.`
+							);
+						}
+						const expectedCustomerCount = new Set(expectedParsed.entries.map(entry => entry.customer.toLowerCase())).size;
+						const actualCustomerCount = new Set(actualParsed.entries.map(entry => entry.customer.toLowerCase())).size;
+						const outputRowCount = Number(toolResult?.output?.rowCount || 0);
+						const outputDisplayRows = Array.isArray(toolResult?.output?.display?.rows) ? toolResult.output.display.rows.length : 0;
+						const outputTruncated = toolResult?.output?.truncated === true || toolResult?.output?.display?.truncated === true;
+						if (outputTruncated && outputRowCount > outputDisplayRows && expectedCustomerCount > actualCustomerCount) {
+							errors.push(
+								`Customer breakdown display is truncated (${outputDisplayRows} shown of ${outputRowCount} rows); expected ${expectedCustomerCount} customers but output shows ${actualCustomerCount}.`
+							);
+						}
+					}
+				errors.push(...collectCommonFormattingErrors(assistantContent));
+				return errors;
+			}
+		},
+			{
+				id: 'support_ticket_billable_hours_per_user_per_month_last_6m',
+				prompt: 'Break up the support tickets last 6 months, give me a total per user per month of the amount of hours they are billing for',
+				runExpected: async (context) => {
+					const collection = await resolveExistingCollection(context.db, ['support-tickets', 'supporttickets', 'support-ticket']);
+					if (!collection) {
+						return {
+							rows: [],
+							meta: { collection: null, basis: 'missing_collection' }
+						};
+					}
+					const rows = await context.db.collection(collection).aggregate([
+						{
+							$addFields: {
+								effective_date: { $ifNull: ['$date_created', '$createdAt'] },
+								effective_hours: { $ifNull: ['$billable_hours', { $ifNull: ['$estimated_billable_hours', 0] }] },
+								assigned_user_first: {
+									$let: {
+										vars: {
+											first_assigned: { $arrayElemAt: [{ $ifNull: ['$users_assigned', []] }, 0] }
+										},
+										in: {
+											$ifNull: ['$$first_assigned.user', '$$first_assigned.id_user']
+										}
+									}
+								}
+							}
+						},
+						{
+							$match: {
+								$expr: {
+									$and: [
+										{ $gte: ['$effective_date', context.last6FullMonthsStart] },
+										{ $lt: ['$effective_date', context.startOfCurrentMonth] }
+									]
+								}
+							}
+						},
+						{
+							$group: {
+								_id: {
+									user: {
+										$ifNull: [
+											'$user_created',
+											{
+												$ifNull: [
+													'$client_user.user',
+													{
+														$ifNull: [
+															'$assigned_user_first',
+															{ $ifNull: [{ $toString: '$id_user_created' }, 'Unknown User'] }
+														]
+													}
+												]
+											}
+										]
+									},
+									bucket: {
+										$dateTrunc: {
+											date: '$effective_date',
+											unit: 'month'
+										}
+									}
+								},
+								billable_hours: { $sum: { $ifNull: ['$effective_hours', 0] } }
+							}
+						},
+						{
+							$project: {
+								_id: 0,
+								user: '$_id.user',
+								month: { $dateToString: { format: '%Y-%m', date: '$_id.bucket' } },
+								billable_hours: 1
+							}
+						},
+						{ $sort: { user: 1, month: 1 } }
+					]).toArray();
+					return {
+						rows,
+						meta: { collection, basis: 'billable_hours_or_estimated_billable_hours' }
+					};
+				},
+				compare: ({ toolResult, assistantContent, expected }) => {
+					const errors: string[] = [];
+					const collection = normalizeOptionalString(expected?.meta?.collection);
+					if (!collection) {
+						const rowCount = Number(toolResult?.output?.rowCount || 0);
+						if (rowCount > 0) {
+							errors.push(`Expected zero rows because support ticket collection is missing, but AI returned ${rowCount} rows.`);
+						}
+						errors.push(...collectCommonFormattingErrors(assistantContent));
+						return errors;
+					}
+					const expectedRows = Array.isArray(expected.rows) ? expected.rows.length : 0;
+					const actualRowCount = Number(toolResult?.output?.rowCount || 0);
+					if (expectedRows === 0 && actualRowCount === 0) {
+						errors.push(...collectCommonFormattingErrors(assistantContent));
+						return errors;
+					}
+					const expectedDisplay = buildDisplayTable(expected.rows || [], { maxColumns: 60, maxRows: 5000 });
+					const expectedPivot = buildAssistantDatedPivotDisplay(expectedDisplay) || expectedDisplay;
+					const expectedParsed = parseDimensionMonthTotalsFromDisplay(expectedPivot, ['user', 'assignee', 'assigned', 'technician', 'owner']);
+					const actualParsed = parseDimensionMonthTotalsFromDisplay(toolResult?.output?.display, ['user', 'assignee', 'assigned', 'technician', 'owner']);
+					if (!expectedParsed || !actualParsed) {
+						errors.push('Could not parse user-month billable-hours totals for expected or AI display.');
+					}
+					else {
+						errors.push(...compareNumericMaps('Support ticket billable hours by month (summed)', expectedParsed.monthTotals, actualParsed.monthTotals, 0.05));
+						errors.push(...compareNumericMaps('Support ticket billable hours by user (summed)', expectedParsed.dimensionTotals, actualParsed.dimensionTotals, 0.05));
+						if (expectedParsed.nonUnknownDimensions.size >= 2 && actualParsed.nonUnknownDimensions.size < 2) {
+							errors.push(
+								`Expected multiple named users (${expectedParsed.nonUnknownDimensions.size}), but AI returned ${actualParsed.nonUnknownDimensions.size}.`
+							);
+						}
+					}
+					errors.push(...collectCommonFormattingErrors(assistantContent));
+					return errors;
+				}
+			}
+		];
+	}
+
+async function runCase(context: ParityContext, parityCase: ParityCase): Promise<ParityCaseResult> {
+	const result: ParityCaseResult = {
+		id: parityCase.id,
+		prompt: parityCase.prompt,
+		pass: false,
+		errors: []
+	};
+	try {
+		const ai = await runPrompt(context.methodManager, context.db, context.idUser, parityCase.prompt, context.appId);
+		result.conversationId = ai.conversationId;
+		const assistantContent = String(ai.message?.content || '');
+		const directive = extractDirectiveFromMessage(ai.message);
+		if (directive) {
+			result.directive = {
+				type: directive.type,
+				collection: normalizeOptionalString(directive.payload?.collection),
+				source: directive.source
+			};
+		}
+		let toolResult = ai.message?.metadata?.tool_result;
+		let toolSource = 'metadata.tool_result';
+		if (!toolResult?.input || !toolResult?.output) {
+			if (!directive) {
+				result.errors.push('No tool_result found in assistant metadata and no directive line was recoverable.');
+				return result;
+			}
+			const replayMethod = directive.type === 'aggregate' ? 'aiAssistantMongoAggregate' : 'aiAssistantMongoRead';
+			try {
+				const directiveReplay = await callMethodAsUser(context.methodManager, context.idUser, replayMethod, directive.payload || {});
+				toolResult = buildSyntheticToolResultFromDirective(directive, directiveReplay);
+				toolSource = `synthetic_from_${directive.source}`;
+			}
+			catch (directiveError: any) {
+				result.errors.push(
+					`No tool_result found; directive replay failed: ${String(directiveError?.message || directiveError || 'unknown error')}`
+				);
+				return result;
+			}
+		}
+		result.toolSource = toolSource;
+		result.tool = {
+			type: normalizeOptionalString(toolResult?.type),
+			collection: normalizeOptionalString(toolResult?.output?.collection) || normalizeOptionalString(toolResult?.input?.collection),
+			rowCount: Number(toolResult?.output?.rowCount || 0),
+			total: typeof toolResult?.output?.total === 'number' ? toolResult.output.total : null,
+			columns: Array.isArray(toolResult?.output?.columns) ? toolResult.output.columns : []
+		};
+
+		if (toolSource === 'metadata.tool_result') {
+			const replayMethod = toolResult.type === 'mongo_agg' ? 'aiAssistantMongoAggregate' : 'aiAssistantMongoRead';
+			const replay = await callMethodAsUser(context.methodManager, context.idUser, replayMethod, toolResult.input || {});
+			const replayErrors = compareDisplayParity(toolResult?.output?.display, replay?.display);
+			const toolRowCount = Number(toolResult?.output?.rowCount || 0);
+			const replayRowCount = Array.isArray(replay?.documents)
+				? replay.documents.length
+				: Number(replay?.display?.rowCount || 0);
+			if (toolRowCount > 0 && replayRowCount > 0 && toolRowCount !== replayRowCount) {
+				replayErrors.push(`Replay rowCount mismatch: tool_result=${toolRowCount}, replay=${replayRowCount}.`);
+			}
+			result.replay = {
+				pass: replayErrors.length === 0,
+				errors: replayErrors
+			};
+			if (replayErrors.length) {
+				result.errors.push(...replayErrors);
+			}
+		}
+		else {
+			result.replay = {
+				pass: true,
+				errors: []
+			};
+		}
+
+		const expected = await parityCase.runExpected(context);
+		result.expected = {
+			rows: Array.isArray(expected?.rows) ? expected.rows.length : 0,
+			meta: expected?.meta
+		};
+		const caseErrors = parityCase.compare({
+			toolResult,
+			assistantContent,
+			expected,
+			context
+		});
+		if (caseErrors.length) {
+			result.errors.push(...caseErrors);
+		}
+
+		result.pass = result.errors.length === 0;
+		return result;
+	}
+	catch (error: any) {
+		result.errors.push(String(error?.message || error || 'Unknown error'));
+		result.pass = false;
+		return result;
+	}
+}
+
+async function run(): Promise<void> {
+	const repoRoot = process.cwd();
+	const defaultServerDir = path.resolve(repoRoot, '../resolveio-all/geochem/server');
+	const serverDir = normalizeOptionalString(process.env.AI_ASSISTANT_PARITY_SERVER_DIR) || defaultServerDir;
+	const settingsPath = path.join(serverDir, normalizeOptionalString(process.env.AI_ASSISTANT_PARITY_SETTINGS) || 'settings.local.json');
+	const appId = normalizeOptionalString(process.env.AI_ASSISTANT_PARITY_APP_ID) || path.basename(path.dirname(serverDir));
+	const dryRun = parseBoolean(process.env.AI_ASSISTANT_PARITY_DRY_RUN);
+
+	if (!fs.existsSync(settingsPath)) {
+		throw new Error(`Settings file not found: ${settingsPath}`);
+	}
+
+	const allCases = resolveParityCases();
+	const caseFilter = normalizeOptionalString(process.env.AI_ASSISTANT_PARITY_CASES)
+		.split(',')
+		.map(value => value.trim())
+		.filter(Boolean);
+	const selectedCases = caseFilter.length
+		? allCases.filter(parityCase => caseFilter.includes(parityCase.id))
+		: allCases;
+	if (!selectedCases.length) {
+		throw new Error('No parity cases selected.');
+	}
+
+	if (dryRun) {
+		console.log(JSON.stringify({
+			mode: 'dry-run',
+			serverDir,
+			settingsPath,
+			appId,
+			cases: selectedCases.map(parityCase => parityCase.id)
+		}, null, 2));
+		return;
+	}
+
+	applyEnvFromServerDir(serverDir);
+	process.env.AI_ASSISTANT_WORKSPACE_ROOT = process.env.AI_ASSISTANT_WORKSPACE_ROOT || path.resolve(serverDir, '../..');
+	if (!process.env.OPENAI_API_KEY) {
+		throw new Error('OPENAI_API_KEY is required for parity E2E run.');
+	}
+
+	const runtimeTmpDir = path.join(serverDir, 'tmp');
+	const runtimeSrcDir = path.join(serverDir, 'src');
+	const runtimeDir = fs.existsSync(path.join(runtimeTmpDir, 'server-app.js')) ? runtimeTmpDir : runtimeSrcDir;
+	const clientRoutesPath = path.join(runtimeDir, 'client-routes');
+	if (!fs.existsSync(clientRoutesPath) && !fs.existsSync(`${clientRoutesPath}.js`)) {
+		throw new Error(`client-routes module not found under runtime dir: ${runtimeDir}`);
+	}
+	const { CLIENT_ROUTES } = require(clientRoutesPath);
+	const serverConfig = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+	const envDatabase = normalizeOptionalString(process.env.DATABASE);
+	const envMongoUrl = normalizeOptionalString(process.env.MONGO_URL);
+	const envOplogUrl = normalizeOptionalString(process.env.OPLOG_URL);
+	if (envDatabase) {
+		serverConfig.DATABASE = envDatabase;
+	}
+	if (envMongoUrl) {
+		serverConfig.MONGO_URL = envMongoUrl;
+	}
+	if (envOplogUrl) {
+		serverConfig.OPLOG_URL = envOplogUrl;
+	}
+
+	const codexHome = process.env.CODEX_HOME || path.join(repoRoot, 'tmp', '.codex-ai-parity');
+	const codexSessions = path.join(codexHome, 'sessions');
+	const codexZdotdir = process.env.AI_DASHBOARD_CODEX_ZDOTDIR || path.join(repoRoot, 'tmp', '.codex-zdotdir-parity');
+	fs.mkdirSync(codexSessions, { recursive: true });
+	fs.mkdirSync(codexZdotdir, { recursive: true });
+	process.env.CODEX_HOME = codexHome;
+	process.env.AI_DASHBOARD_CODEX_ZDOTDIR = codexZdotdir;
+	process.env.IS_WORKERS_ENABLED = 'false';
+	process.env.IS_WORKER_INSTANCE = 'false';
+	process.env.WORKER_INDEX = '';
+	process.env.NODE_APP_INSTANCE = process.env.NODE_APP_INSTANCE || '8';
+	process.env.AI_ASSISTANT_WORKER_DEBUG = process.env.AI_ASSISTANT_WORKER_DEBUG || 'false';
+
+	await ResolveIOServer.create(serverConfig, CLIENT_ROUTES(), appId.toUpperCase(), runtimeDir, false, false);
+	const mainServer = ResolveIOServer.getMainServer();
+	const methodManager = mainServer?.getMethodManager();
+	if (!methodManager) {
+		throw new Error('MethodManager unavailable after ResolveIOServer initialization.');
+	}
+	await methodManager.waitUntilReady(120000);
+
+	const dbName = normalizeOptionalString(serverConfig.DATABASE) || 'resolveio';
+	const db = ResolveIOServer.getMongoConnection().db(dbName);
+	const idUser = normalizeOptionalString(process.env.AI_ASSISTANT_PARITY_USER_ID) || await findSuperAdminUserId(db);
+	const now = new Date();
+
+	const context: ParityContext = {
+		db,
+		now,
+		startOfWeek: startOfWeekUtcMonday(now),
+		last6MonthsStart: addMonthsUtc(now, -6),
+		startOfCurrentMonth: startOfMonthUtc(now),
+		last6FullMonthsStart: addMonthsUtc(startOfMonthUtc(now), -6),
+		methodManager,
+		idUser,
+		appId
+	};
+
+	const results: ParityCaseResult[] = [];
+	for (const parityCase of selectedCases) {
+		const caseResult = await runCase(context, parityCase);
+		results.push(caseResult);
+		const status = caseResult.pass ? 'PASS' : 'FAIL';
+		const message = caseResult.errors.length ? `error=${caseResult.errors[0]}` : '';
+		console.log(`${status} ${parityCase.id} ${message}`.trim());
+	}
+
+	const passed = results.filter(result => result.pass).length;
+	const failed = results.length - passed;
+	const output = {
+		now: now.toISOString(),
+		serverDir,
+		settingsPath,
+		appId,
+		database: dbName,
+		total: results.length,
+		passed,
+		failed,
+		results
+	};
+	const outputPath = path.join(repoRoot, 'tmp', 'ai-assistant-data-parity-e2e-output.json');
+	fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+	fs.writeFileSync(outputPath, JSON.stringify(output, null, 2));
+	console.log(`ai assistant data parity e2e: ${passed}/${results.length} passed`);
+	console.log(`wrote ${outputPath}`);
+	if (failed > 0) {
+		process.exitCode = 1;
+	}
+}
+
+run()
+	.then(() => {
+		process.exit(process.exitCode ?? 0);
+	})
+	.catch((error) => {
+		console.error(error);
+		process.exit(1);
+	});