@resolveio/server-lib 22.3.126 → 22.3.127

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

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