@resolveio/server-lib 22.3.197 → 22.3.199

package/tests/ai-assistant-utils.test.ts

@@ -1,3057 +0,0 @@
-import { ObjectId } from 'mongodb';
-import {
-	buildAssistantChangeHistorySummaryFromCommits,
-	buildAssistantSystemPromptForTesting,
-	applyAssistantDisplayTableToResponseForTesting,
-	buildAssistantToolFallbackResponseForTesting,
-	buildAssistantAnswerQualityFromExecution,
-	buildAssistantWorkspaceRootCandidates,
-	buildAssistantDatedPivotDisplay,
-	buildAssistantSchemaHints,
-	buildAssistantToolRequest,
-	deriveAssistantCommandExecutionStatus,
-	evaluateAssistantGuardrailsForTesting,
-	buildAssistantInvoiceCustomerLabelExpr,
-	buildDisplayTable,
-	executeAiAssistantMongoAggregate,
-	executeAiAssistantMongoRead,
-	extractAssistantMongoDirective,
-	flattenForTable,
-	formatDisplayTableMarkdown,
-	normalizeAssistantMonthlyCalendarWindowPipeline,
-	normalizeAssistantAggregatePipeline,
-	expandAggregateDateMatchFallbackForTesting,
-	normalizeAssistantNowExprPlaceholders,
-	repairAssistantPositionalPathSegmentsInPipeline,
-	repairAssistantFieldPathReferenceInPipeline,
-	normalizeIdsForTargetField,
-	rankAssistantNavigationRoutes,
-	resolveAssistantCollectionOverride,
-	resolveAssistantCollectionNameForTesting,
-	resolveCollectionOverrideWithContextForTesting,
-	resolveAssistantAvailableCrossCollectionFallbacksFromNames,
-	resolveAssistantAppCollectionHintCandidates,
-	resolveAssistantHeuristicDirectiveForTesting,
-	resolveAssistantCrossCollectionFallbackCandidates,
-	resolveAssistantReportBuilderBridgeCollection,
-	isAssistantDeterministicHeuristicEnabledForApp,
-	shouldAcceptAssistantFallbackDocuments,
-	shouldEnforceAssistantDatedDirective,
-	shouldLockAssistantRequestedCollectionForExecutionForTesting,
-	shouldPreserveAssistantProbeCollectionForTesting,
-	rewriteMatchExpressionsToExpr,
-	rewriteEmbeddedMatchObjects,
-	resolveCodexThoughtLevel,
-	resolveAssistantReadDisplayMaxRows,
-	resolveReadMultiTermJobRegexFallbackForTesting,
-	serializeMongoValue,
-	shouldRunAssistantPlanner,
-	shouldUseAssistantChangeHistoryFastPath,
-	shouldUseAssistantNavigationFastPath,
-	stripQueryFieldPathsDeep,
-	stripScopedFieldsFromPipeline
-} from '../src/methods/ai-terminal';
-import { ResolveIOServer } from '../src/resolveio-server-app';
-import * as UserCollection from '../src/collections/user.collection';
-
-function assert(condition: boolean, message: string) {
-	if (!condition) {
-		throw new Error(message);
-	}
-}
-
-function testDirectiveParsing() {
-	const content = [
-		'Summary line',
-		'MONGO_READ: {"collection":"users","query":{"active":true},"options":{"limit":5}}',
-		'More context',
-		'MONGO_AGG: {"collection":"invoices","pipeline":[{"$match":{"status":"Open"}}]}'
-	].join('\n');
-	const result = extractAssistantMongoDirective(content);
-	assert(!!result, 'Expected directive to be detected');
-	assert(result?.type === 'aggregate', 'Expected last directive to win');
-	assert(result?.payload?.collection === 'invoices', 'Expected payload collection to parse');
-	assert(!result?.cleaned.includes('MONGO_READ'), 'Expected cleaned content to remove directives');
-	assert(!result?.cleaned.includes('MONGO_AGG'), 'Expected cleaned content to remove directives');
-}
-
-function testReportBuilderDirectiveParsing() {
-	const content = [
-		'Summary line',
-		'REPORT_BUILDER_READ: {"collection":"users","query":{"active":true},"options":{"limit":5}}',
-		'REPORT_BUILDER_AGG: {"collection":"invoices","pipeline":[{"$match":{"status":"Open"}}]}'
-	].join('\n');
-	const result = extractAssistantMongoDirective(content);
-	assert(!!result, 'Expected report builder directive to be detected');
-	assert(result?.type === 'aggregate', 'Expected report builder aggregate directive to win');
-	assert(result?.payload?.collection === 'invoices', 'Expected report builder payload collection to parse');
-	assert(!result?.cleaned.includes('REPORT_BUILDER_READ'), 'Expected cleaned content to remove report builder read directive');
-	assert(!result?.cleaned.includes('REPORT_BUILDER_AGG'), 'Expected cleaned content to remove report builder agg directive');
-}
-
-function testFlattenForTable() {
-	const flattened = flattenForTable({
-		_id: { status: 'Open', type: 'A' },
-		count: 3
-	}, { includeGroupFromId: true });
-	assert(flattened.status === 'Open', 'Expected _id.status flattened to status');
-	assert(flattened.type === 'A', 'Expected _id.type flattened to type');
-	assert(flattened.count === 3, 'Expected count retained');
-}
-
-function testDisplayTableDefaults() {
-	const docs = [
-		{
-			_id: { toHexString: () => 'abcdef123456' },
-			name: 'Alpha',
-			createdAt: new Date('2024-01-01T00:00:00.000Z'),
-			updatedAt: new Date('2024-01-02T00:00:00.000Z'),
-			id_client: 'C1',
-			__v: 0
-		},
-		{
-			_id: { toHexString: () => '123456abcdef' },
-			name: 'Beta',
-			createdAt: new Date('2024-01-03T00:00:00.000Z'),
-			updatedAt: new Date('2024-01-04T00:00:00.000Z'),
-			id_client: 'C1',
-			__v: 0
-		}
-	];
-	const display = buildDisplayTable(docs);
-	assert(display.columns.includes('Created At'), 'Expected Created At column');
-	assert(display.columns.includes('Updated At'), 'Expected Updated At column');
-	assert(!display.columns.some(col => col.toLowerCase() === 'id_client'), 'Expected id_client hidden');
-	assert(!display.columns.some(col => col.toLowerCase() === '_id'), 'Expected _id hidden');
-	assert(!display.columns.some(col => col.toLowerCase() === '__v'), 'Expected __v hidden');
-}
-
-function testSerializeMongoValue() {
-	const value = serializeMongoValue(['A', 'B', 'C', 'D']);
-	assert(typeof value === 'string', 'Expected array to serialize to string');
-	assert(String(value).includes('...'), 'Expected array preview to be truncated');
-}
-
-function testDisplayMarkdownTable() {
-	const display = buildDisplayTable([
-		{ name: 'Alpha', status: 'Active' },
-		{ name: 'Beta', status: 'Paused' }
-	]);
-	const markdown = formatDisplayTableMarkdown(display);
-	assert(markdown.includes('| name |') || markdown.includes('| Name |'), 'Expected markdown header row');
-	assert(markdown.split('\n').length >= 3, 'Expected markdown table rows');
-}
-
-function testAssistantToolFallbackResponseIncludesUsefulLeadSummary() {
-	const response = buildAssistantToolFallbackResponseForTesting({
-		type: 'mongo_agg',
-		input: { collection: 'work-order-dynamics' },
-		output: {
-			collection: 'work-order-dynamics',
-			rowCount: 2,
-			columns: ['Customer', 'Active', 'Closed', 'Completed', 'Work Orders'],
-			display: {
-				columns: ['Customer', 'Active', 'Closed', 'Completed', 'Work Orders'],
-				rows: [
-					{ Customer: 'Avid', Active: 0, Closed: 4, Completed: 99, 'Work Orders': 217 },
-					{ Customer: 'Beta', Active: 0, Closed: 0, Completed: 10, 'Work Orders': 11 }
-				],
-				rowCount: 2,
-				truncated: false,
-				includeIds: false
-			}
-		}
-	});
-	assert(
-		response.includes('I found 2 matching rows from work-order-dynamics.'),
-		'Expected fallback response to state row count and source in plain language'
-	);
-	assert(
-		response.includes('Top row: Customer Avid, Work Orders 217.'),
-		'Expected fallback response to summarize the leading row before the table'
-	);
-	assert(response.includes('| Customer | Active | Closed | Completed | Work Orders |'), 'Expected fallback response to include table');
-}
-
-function testAssistantToolFallbackResponseExplainsZeroRows() {
-	const response = buildAssistantToolFallbackResponseForTesting({
-		type: 'mongo_agg',
-		input: { collection: 'work-order-dynamics' },
-		output: {
-			collection: 'work-order-dynamics',
-			rowCount: 0,
-			columns: ['Customer', 'Work Orders'],
-			display: {
-				columns: ['Customer', 'Work Orders'],
-				rows: [],
-				rowCount: 0,
-				truncated: false,
-				includeIds: false
-			}
-		}
-	});
-	assert(
-		response.includes('I checked the data') && response.includes('no matching rows were returned.'),
-		'Expected zero-row fallback response to explain successful zero-result execution'
-	);
-	assert(response.includes('- Rows returned: 0'), 'Expected zero-row fallback response to include row count');
-}
-
-function testBuildAssistantAnswerQualityFromExecution() {
-	const rowEvidence = buildAssistantAnswerQualityFromExecution({
-		requestMessage: 'Show revenue by month for the last 6 months.',
-		dataQuestion: true,
-		reportStyleIntent: 'dated',
-		requestedTimeGrain: 'month',
-		toolResult: {
-			type: 'mongo_agg',
-			input: { collection: 'invoices', pipeline: [{ $match: { status: 'Paid' } }] },
-			output: {
-				collection: 'invoices',
-				rowCount: 2,
-				columns: ['Month', 'Revenue'],
-				display: { columns: ['Month', 'Revenue'], rows: [{ Month: '2026-05', Revenue: 100 }], rowCount: 1 },
-				verification: {
-					metrics: {
-						window: {
-							startDate: '2025-12-01',
-							endDate: '2026-05-31',
-							months: 6,
-							type: 'full_month'
-						}
-					}
-				}
-			}
-		},
-		now: '2026-06-16T12:00:00.000Z'
-	});
-	assert(rowEvidence.queryStatus === 'ok', 'Expected successful tool execution to become ok queryStatus');
-	assert(rowEvidence.requiresDateWindow === true, 'Expected dated request to require date window evidence');
-	assert(rowEvidence.dateWindow?.startDate === '2025-12-01', 'Expected date-window start evidence');
-	assert(rowEvidence.dateWindow?.endDate === '2026-05-31', 'Expected date-window end evidence');
-	assert(rowEvidence.confidenceLevel === 'high', 'Expected successful data answer to be high confidence');
-	assert(Array.isArray(rowEvidence.citationRefs) && rowEvidence.citationRefs.length === 1, 'Expected tool evidence citation');
-	assert(rowEvidence.requiresQueryEvidence === true, 'Expected data answers to require structured query evidence');
-	assert(Array.isArray(rowEvidence.queryExecutions) && rowEvidence.queryExecutions.length === 1, 'Expected structured query execution proof');
-	assert(rowEvidence.queryExecutions[0].id === rowEvidence.citationRefs[0], 'Expected query execution id to match cited tool evidence');
-	assert(rowEvidence.queryExecutions[0].tool === 'aiAssistantMongoAggregate', 'Expected aggregate tool proof');
-	assert(rowEvidence.queryExecutions[0].resultCount === 2, 'Expected resultCount proof');
-
-	const noDataEvidence = buildAssistantAnswerQualityFromExecution({
-		requestMessage: 'Show invoices for this customer this month.',
-		dataQuestion: true,
-		toolResult: {
-			type: 'mongo_read',
-			input: { collection: 'invoices', query: { id_customer: 'cust-1' } },
-			output: {
-				collection: 'invoices',
-				rowCount: 0,
-				columns: ['Invoice'],
-				display: { columns: ['Invoice'], rows: [], rowCount: 0 }
-			}
-		},
-		now: '2026-06-16T12:00:00.000Z'
-	});
-	assert(noDataEvidence.queryStatus === 'no_data', 'Expected zero rows to become no_data');
-	assert(noDataEvidence.noDataConfirmed === true, 'Expected zero-row tool result to confirm no-data');
-	assert(noDataEvidence.confidenceLevel === 'medium', 'Expected no-data answer confidence to be medium');
-	assert(Array.isArray(noDataEvidence.queryExecutions) && noDataEvidence.queryExecutions.length === 1, 'Expected no-data answers to retain query execution proof');
-	assert(noDataEvidence.queryExecutions[0].queryStatus === 'no_data', 'Expected no-data query proof status');
-	assert(noDataEvidence.queryExecutions[0].resultCount === 0, 'Expected no-data resultCount proof');
-	assert(Array.isArray(noDataEvidence.queryEvidenceRefs) && noDataEvidence.queryEvidenceRefs.length === 1, 'Expected no-data query evidence refs');
-
-	const permissionEvidence = buildAssistantAnswerQualityFromExecution({
-		requestMessage: 'Show invoice totals.',
-		dataQuestion: true,
-		toolExecution: {
-			permissionDenied: true,
-			outcome: { error: 'AI assistant report builder bridge: Access denied.' }
-		},
-		now: '2026-06-16T12:00:00.000Z'
-	});
-	assert(permissionEvidence.queryStatus === 'permission_error', 'Expected permission failures to stay distinct from no-data');
-	assert(permissionEvidence.requiresHumanReview === true, 'Expected permission failures to require review');
-	assert(permissionEvidence.canAnswerCustomer === false, 'Expected permission failures to block customer answer');
-	assert(permissionEvidence.requiresQueryEvidence === true, 'Expected failed data answers to keep query-evidence requirement visible');
-
-	const nonDataEvidence = buildAssistantAnswerQualityFromExecution({
-		requestMessage: 'Say hello.',
-		dataQuestion: false,
-		now: '2026-06-16T12:00:00.000Z'
-	});
-	assert(nonDataEvidence.queryStatus === 'ok', 'Expected non-data assistant answer to stay ok without tools');
-	assert(nonDataEvidence.requiresQueryEvidence === false, 'Expected non-data answers to avoid query evidence requirement');
-	assert(!Array.isArray(nonDataEvidence.queryExecutions), 'Expected non-data answers to avoid synthetic query proof');
-}
-
-function testAssistantZeroRowDisplayDoesNotAppendSyntheticTable() {
-	const response = applyAssistantDisplayTableToResponseForTesting(
-		'The query ran successfully against jobs, but no matching rows were returned.\n- Source: jobs\n- Rows returned: 0',
-		{
-			columns: ['Job', 'Customer', 'Chemical', 'Quantity Sent'],
-			rows: [],
-			rowCount: 0,
-			truncated: false,
-			includeIds: false
-		}
-	);
-	assert(!response.includes('| Job |'), 'Expected zero-row responses to omit synthetic display tables');
-	assert(!response.includes('No rows matched | 0'), 'Expected zero-row responses to avoid fake table rows');
-	assert(response.includes('Rows returned: 0'), 'Expected zero-row response summary to remain intact');
-}
-
-function testDisplayMarkdownTableDefaultsToShortDateFormat() {
-	const priorInline = process.env.AI_ASSISTANT_APP_HEURISTICS;
-	const priorFile = process.env.AI_ASSISTANT_APP_HEURISTICS_FILE;
-	const priorAppId = process.env.AI_ASSISTANT_APP_ID;
-	try {
-		delete process.env.AI_ASSISTANT_APP_HEURISTICS_FILE;
-		delete process.env.AI_ASSISTANT_APP_HEURISTICS;
-		delete process.env.AI_ASSISTANT_APP_ID;
-		const display = buildDisplayTable([
-			{ day_utc: '2026-02-25T00:00:00.000Z', completed_count: 4 }
-		]);
-		const markdown = formatDisplayTableMarkdown(display);
-		assert(
-			markdown.includes('02/25/2026'),
-			'Expected default date format to render dates as MM/DD/YYYY'
-		);
-		assert(
-			!markdown.includes('2026-02-25'),
-			'Expected default date format to avoid YYYY-MM-DD display dates'
-		);
-	}
-	finally {
-		if (priorInline === undefined) {
-			delete process.env.AI_ASSISTANT_APP_HEURISTICS;
-		}
-		else {
-			process.env.AI_ASSISTANT_APP_HEURISTICS = priorInline;
-		}
-		if (priorFile === undefined) {
-			delete process.env.AI_ASSISTANT_APP_HEURISTICS_FILE;
-		}
-		else {
-			process.env.AI_ASSISTANT_APP_HEURISTICS_FILE = priorFile;
-		}
-		if (priorAppId === undefined) {
-			delete process.env.AI_ASSISTANT_APP_ID;
-		}
-		else {
-			process.env.AI_ASSISTANT_APP_ID = priorAppId;
-		}
-	}
-}
-
-function testDeriveAssistantCommandExecutionStatus() {
-	assert(
-		deriveAssistantCommandExecutionStatus('/bin/bash -lc "rg --files /var/app/current"') === 'Searching files',
-		'Expected rg command to map to Searching files'
-	);
-	assert(
-		deriveAssistantCommandExecutionStatus('/bin/bash -lc "find /var/app/current -type f"') === 'Finding files',
-		'Expected find command to map to Finding files'
-	);
-	assert(
-		deriveAssistantCommandExecutionStatus('/bin/bash -lc "sed -n \'1,120p\' /var/app/current/file.ts"') === 'Opening files',
-		'Expected sed command to map to Opening files'
-	);
-	assert(
-		deriveAssistantCommandExecutionStatus('/bin/bash -lc "ls -la /var/app/current"') === 'Scanning files',
-		'Expected ls command to map to Scanning files'
-	);
-	assert(
-		deriveAssistantCommandExecutionStatus('/bin/bash -lc "echo hello"') === 'Running command',
-		'Expected unknown command to map to Running command'
-	);
-}
-
-function testResolveCodexThoughtLevelPolicy() {
-	const keys = [
-		'AI_ASSISTANT_CODEX_THOUGHT_LEVEL',
-		'AI_TERMINAL_CODEX_THOUGHT_LEVEL',
-		'AI_DASHBOARD_CODEX_THOUGHT_LEVEL'
-	] as const;
-	const previous = keys.map((key) => [key, process.env[key]] as const);
-	try {
-		keys.forEach((key) => {
-			delete process.env[key];
-		});
-		const defaultNonBugLevel = resolveCodexThoughtLevel({
-			message: 'Explain what the deploy instance dashboard does',
-			requestType: 'feature_info'
-		});
-		assert(defaultNonBugLevel === 'low', 'Expected simple non-bug requests to default to low thought level');
-
-		keys.forEach((key) => {
-			process.env[key] = 'high';
-		});
-		const nonBugLevel = resolveCodexThoughtLevel({
-			message: 'Explain what the deploy instance dashboard does',
-			requestType: 'feature_info'
-		});
-		assert(nonBugLevel === 'medium', 'Expected non-bug requests to clamp to medium thought level');
-
-		const bugLevel = resolveCodexThoughtLevel({
-			message: "Why won't this save button work?",
-			requestType: 'bug_issue'
-		});
-		assert(bugLevel === 'high', 'Expected bug/issue requests to keep high thought level');
-	}
-	finally {
-		previous.forEach(([key, value]) => {
-			if (value === undefined) {
-				delete process.env[key];
-			}
-			else {
-				process.env[key] = value;
-			}
-		});
-	}
-}
-
-function testAssistantSystemPromptAllowsWorkspaceDebuggingAndFixes() {
-	const prompt = buildAssistantSystemPromptForTesting();
-	assert(
-		prompt.includes('workspace access to the current platform codebase'),
-		'Expected assistant system prompt to describe workspace access'
-	);
-	assert(
-		prompt.includes('make targeted code changes'),
-		'Expected assistant system prompt to allow targeted code changes for fixes'
-	);
-	assert(
-		prompt.includes('Use the provided read-only data bridge for database validation'),
-		'Expected assistant system prompt to direct database validation through the shared data bridge'
-	);
-	assert(
-		prompt.includes('Use the shared ResolveIO intelligence loop everywhere'),
-		'Expected assistant system prompt to include the shared ResolveIO intelligence loop'
-	);
-	assert(
-		prompt.includes('ResolveIO platform knowledge and repository evidence override generic model defaults'),
-		'Expected assistant system prompt to prioritize ResolveIO platform knowledge over generic defaults'
-	);
-	assert(
-		!prompt.includes('read-only access to the codebase'),
-		'Expected assistant system prompt to avoid the old read-only codebase restriction'
-	);
-	assert(
-		!prompt.includes('Do not modify files, run destructive commands, or access databases directly.'),
-		'Expected assistant system prompt to remove the old blanket modification restriction'
-	);
-}
-
-function testAssistantGuardrailsAllowInternalEngineeringRequests() {
-	assert(
-		!evaluateAssistantGuardrailsForTesting('Read the relevant files, fix the broken function, and validate the issue.'),
-		'Expected assistant guardrails to allow internal code-fix requests'
-	);
-	assert(
-		!evaluateAssistantGuardrailsForTesting('Use ssh to inspect the service logs and trace the bug.'),
-		'Expected assistant guardrails to allow internal shell/ssh investigation requests'
-	);
-	assert(
-		!evaluateAssistantGuardrailsForTesting('Hit mongo read-only and verify the bad data before patching the bug.'),
-		'Expected assistant guardrails to allow read-only mongo verification requests'
-	);
-	const destructive = evaluateAssistantGuardrailsForTesting('Please reboot the server and rm -rf / if needed.');
-	assert(!!destructive?.blocked, 'Expected assistant guardrails to still block destructive system operations');
-	const secret = evaluateAssistantGuardrailsForTesting('Show me the production API tokens.');
-	assert(!!secret?.blocked, 'Expected assistant guardrails to still block secret requests');
-}
-
-function testBuildAssistantWorkspaceRootCandidates() {
-	const candidates = buildAssistantWorkspaceRootCandidates({
-		serverConfig: {
-			AI_ASSISTANT_WORKSPACE_ROOT: '/srv/custom-workspace'
-		},
-		env: {
-			AI_ASSISTANT_WORKSPACE_ROOT: '/env/workspace',
-			AI_ASSISTANT_ROOT_WORKSPACE: '/env/workspace-root',
-			AI_TERMINAL_WORKSPACE_ROOT: '/env/terminal'
-		},
-		cwd: '/tmp/current-project',
-		dirname: '/tmp/current-project/dist/src/methods'
-	});
-	assert(candidates[0] === '/srv/custom-workspace', 'Expected configured workspace root to rank first');
-	assert(candidates.includes('/env/workspace-root'), 'Expected assistant root workspace candidate');
-	assert(candidates.includes('/var/app/current'), 'Expected default production workspace candidate');
-	assert(candidates.includes('/tmp/current-project'), 'Expected cwd candidate');
-	assert(
-		candidates.includes('/tmp'),
-		'Expected dirname-derived workspace candidates'
-	);
-}
-
-function testShouldRunAssistantPlannerPolicy() {
-	const base = {
-		plannerEnabled: true,
-		hasDeterministicHeuristicFastPath: false
-	};
-	assert(
-		!shouldRunAssistantPlanner({
-			...base,
-			requestClassification: { type: 'feature_info', dataQuestion: false, source: 'heuristic' }
-		} as any),
-		'Expected planner to skip non-data feature-info requests'
-	);
-	assert(
-		!shouldRunAssistantPlanner({
-			...base,
-			requestClassification: { type: 'bug_issue', dataQuestion: false, source: 'heuristic' }
-		} as any),
-		'Expected planner to skip non-data bug-issue requests'
-	);
-	assert(
-		shouldRunAssistantPlanner({
-			...base,
-			requestClassification: { type: 'data', dataQuestion: true, source: 'heuristic' }
-		} as any),
-		'Expected planner to run for data requests'
-	);
-	assert(
-		shouldRunAssistantPlanner({
-			...base,
-			requestClassification: { type: 'unknown', dataQuestion: false, source: 'heuristic' }
-		} as any),
-		'Expected planner to run for unknown intent requests'
-	);
-	assert(
-		!shouldRunAssistantPlanner({
-			...base,
-			requestClassification: { type: 'data', dataQuestion: true, source: 'heuristic' },
-			hasDeterministicHeuristicFastPath: true
-		} as any),
-		'Expected deterministic heuristic fast path to skip planner'
-	);
-}
-
-function testAssistantAppHeuristicRegistryTermHintsAndDeterministicEnablement() {
-	const priorInline = process.env.AI_ASSISTANT_APP_HEURISTICS;
-	const priorFile = process.env.AI_ASSISTANT_APP_HEURISTICS_FILE;
-	const priorAppId = process.env.AI_ASSISTANT_APP_ID;
-	try {
-		process.env.AI_ASSISTANT_APP_HEURISTICS_FILE = '';
-		process.env.AI_ASSISTANT_APP_HEURISTICS = JSON.stringify({
-			apps: {
-				snf: {
-					enabled_deterministic_heuristics: ['schema_hours_user_time'],
-					collection_term_hints: [
-						{
-							terms: ['well', 'wells'],
-							collections: ['jobs', 'work-order-dynamics']
-						}
-					]
-				}
-			}
-		});
-		process.env.AI_ASSISTANT_APP_ID = 'snf';
-		assert(
-			isAssistantDeterministicHeuristicEnabledForApp('schema_hours_user_time', 'snf'),
-			'Expected app heuristics to enable schema_hours_user_time for snf'
-		);
-		assert(
-			!isAssistantDeterministicHeuristicEnabledForApp('schema_hours_user_time', 'resolveio'),
-			'Expected schema_hours_user_time to remain disabled for non-snf apps'
-		);
-		const hints = resolveAssistantAppCollectionHintCandidates('How many active wells are there?', 'snf');
-		assert(
-			hints.includes('jobs'),
-			'Expected app collection term hints to return jobs for wells in snf'
-		);
-	}
-	finally {
-		if (priorInline === undefined) {
-			delete process.env.AI_ASSISTANT_APP_HEURISTICS;
-		}
-		else {
-			process.env.AI_ASSISTANT_APP_HEURISTICS = priorInline;
-		}
-		if (priorFile === undefined) {
-			delete process.env.AI_ASSISTANT_APP_HEURISTICS_FILE;
-		}
-		else {
-			process.env.AI_ASSISTANT_APP_HEURISTICS_FILE = priorFile;
-		}
-		if (priorAppId === undefined) {
-			delete process.env.AI_ASSISTANT_APP_ID;
-		}
-		else {
-			process.env.AI_ASSISTANT_APP_ID = priorAppId;
-		}
-	}
-}
-
-function testAssistantAppHeuristicRegistryLoadsRelativeFileFromParityServerDir() {
-	const fs = require('fs');
-	const os = require('os');
-	const path = require('path');
-	const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-assistant-heuristics-'));
-	const serverDir = path.join(tmpRoot, 'server');
-	const heuristicsDir = path.join(serverDir, 'src', 'ai');
-	const heuristicsPath = path.join(heuristicsDir, 'assistant-heuristics.json');
-	const priorInline = process.env.AI_ASSISTANT_APP_HEURISTICS;
-	const priorFile = process.env.AI_ASSISTANT_APP_HEURISTICS_FILE;
-	const priorAppId = process.env.AI_ASSISTANT_APP_ID;
-	const priorParityServerDir = process.env.AI_ASSISTANT_PARITY_SERVER_DIR;
-	const priorWorkspaceRoot = process.env.AI_ASSISTANT_WORKSPACE_ROOT;
-	try {
-		fs.mkdirSync(heuristicsDir, { recursive: true });
-		fs.writeFileSync(heuristicsPath, JSON.stringify({
-			apps: {
-				parityapp: {
-					collection_term_hints: [
-						{
-							terms: ['widgetfoo'],
-							collections: ['dashboard-widgets']
-						}
-					]
-				}
-			}
-		}));
-		delete process.env.AI_ASSISTANT_APP_HEURISTICS;
-		process.env.AI_ASSISTANT_APP_HEURISTICS_FILE = 'src/ai/assistant-heuristics.json';
-		process.env.AI_ASSISTANT_APP_ID = 'parityapp';
-		process.env.AI_ASSISTANT_PARITY_SERVER_DIR = serverDir;
-		process.env.AI_ASSISTANT_WORKSPACE_ROOT = tmpRoot;
-		const hints = resolveAssistantAppCollectionHintCandidates('Show me widgetfoo usage', 'parityapp');
-		assert(
-			hints.includes('dashboard-widgets'),
-			'Expected relative app heuristics file to resolve from AI_ASSISTANT_PARITY_SERVER_DIR'
-		);
-	}
-	finally {
-		fs.rmSync(tmpRoot, { recursive: true, force: true });
-		if (priorInline === undefined) {
-			delete process.env.AI_ASSISTANT_APP_HEURISTICS;
-		}
-		else {
-			process.env.AI_ASSISTANT_APP_HEURISTICS = priorInline;
-		}
-		if (priorFile === undefined) {
-			delete process.env.AI_ASSISTANT_APP_HEURISTICS_FILE;
-		}
-		else {
-			process.env.AI_ASSISTANT_APP_HEURISTICS_FILE = priorFile;
-		}
-		if (priorAppId === undefined) {
-			delete process.env.AI_ASSISTANT_APP_ID;
-		}
-		else {
-			process.env.AI_ASSISTANT_APP_ID = priorAppId;
-		}
-		if (priorParityServerDir === undefined) {
-			delete process.env.AI_ASSISTANT_PARITY_SERVER_DIR;
-		}
-		else {
-			process.env.AI_ASSISTANT_PARITY_SERVER_DIR = priorParityServerDir;
-		}
-		if (priorWorkspaceRoot === undefined) {
-			delete process.env.AI_ASSISTANT_WORKSPACE_ROOT;
-		}
-		else {
-			process.env.AI_ASSISTANT_WORKSPACE_ROOT = priorWorkspaceRoot;
-		}
-	}
-}
-
-function testAssistantCoreHeuristicsStayPlatformScoped() {
-	const hints = resolveAssistantAppCollectionHintCandidates(
-		'The report builder collapse-table data table in the navbar module is broken and users cannot login because sessions keep expiring.',
-		'resolveio'
-	);
-	assert(
-		hints.includes('reports') || hints.includes('report-templates') || hints.includes('report-layouts'),
-		'Expected core heuristics to map report-builder/widget language to report collections'
-	);
-	assert(
-		hints.includes('dashboard-configs') || hints.includes('homepage-configs') || hints.includes('roles'),
-		'Expected core heuristics to map navbar/module language to shared nav/system collections'
-	);
-	assert(
-		hints.includes('users') || hints.includes('client-users') || hints.includes('billing-logged-in-users'),
-		'Expected core heuristics to map login/session language to user/auth collections'
-	);
-	assert(
-		!hints.includes('support-tickets'),
-		'Expected core heuristics to avoid app-domain support ticket hints'
-	);
-	assert(
-		!hints.includes('invoices'),
-		'Expected core heuristics to avoid app-domain invoice hints'
-	);
-	assert(
-		!hints.includes('work-order-dynamics') && !hints.includes('chemical-blends'),
-		'Expected core heuristics to avoid app-domain work-order and blend hints'
-	);
-}
-
-function testAssistantAppHeuristicsCanOwnDomainCollectionHints() {
-	const priorInline = process.env.AI_ASSISTANT_APP_HEURISTICS;
-	const priorFile = process.env.AI_ASSISTANT_APP_HEURISTICS_FILE;
-	try {
-		process.env.AI_ASSISTANT_APP_HEURISTICS_FILE = '';
-		process.env.AI_ASSISTANT_APP_HEURISTICS = JSON.stringify({
-			apps: {
-				snf: {
-					collection_term_hints: [
-						{
-							terms: ['invoice', 'invoices'],
-							collections: ['invoices']
-						},
-						{
-							terms: ['work order', 'work orders'],
-							collections: ['work-order-dynamics']
-						},
-						{
-							terms: ['blend', 'blending'],
-							collections: ['chemical-blends']
-						}
-					]
-				}
-			}
-		});
-		const hints = resolveAssistantAppCollectionHintCandidates(
-			'Show invoices, work orders, and blend throughput.',
-			'snf'
-		);
-		assert(
-			hints.includes('invoices'),
-			'Expected app heuristics to own invoice collection hints'
-		);
-		assert(
-			hints.includes('work-order-dynamics'),
-			'Expected app heuristics to own work-order collection hints'
-		);
-		assert(
-			hints.includes('chemical-blends'),
-			'Expected app heuristics to own blend collection hints'
-		);
-	}
-	finally {
-		if (priorInline === undefined) {
-			delete process.env.AI_ASSISTANT_APP_HEURISTICS;
-		}
-		else {
-			process.env.AI_ASSISTANT_APP_HEURISTICS = priorInline;
-		}
-		if (priorFile === undefined) {
-			delete process.env.AI_ASSISTANT_APP_HEURISTICS_FILE;
-		}
-		else {
-			process.env.AI_ASSISTANT_APP_HEURISTICS_FILE = priorFile;
-		}
-	}
-}
-
-function testAssistantAppDataIntentsResolveSnfDomainRequests() {
-	const priorInline = process.env.AI_ASSISTANT_APP_HEURISTICS;
-	const priorFile = process.env.AI_ASSISTANT_APP_HEURISTICS_FILE;
-	try {
-		process.env.AI_ASSISTANT_APP_HEURISTICS_FILE = '';
-		process.env.AI_ASSISTANT_APP_HEURISTICS = JSON.stringify({
-			apps: {
-				snf: {
-					enabled_deterministic_heuristics: ['app_data_intent'],
-					data_intents: [
-						{
-							id: 'snf_job_chemical_shipments',
-							terms: ['amount of chemicals sent', 'chemicals sent', 'shipped chemicals', 'chemical shipments'],
-							collection: 'work-order-dynamics',
-							permission_view: '/work-order-dynamic/list',
-							date_field: 'date_completed',
-							quantity_field: 'chemicals.shipped.quantity',
-							fallback_collections: ['invoices', 'jobs'],
-							progress: ['Checking {{customer}} work orders for {{year}}', 'Summarizing shipped chemical quantities'],
-							assumptions: ['Sent means shipped chemical quantity']
-						},
-						{
-							id: 'snf_invoice_chemical_quantities',
-							terms: ['invoice', 'invoices', 'billed chemicals', 'amount charged'],
-							collection: 'invoices',
-							permission_view: '/invoice/list',
-							date_field: 'date_created',
-							quantity_field: 'items_chemicals.quantity'
-						},
-						{
-							id: 'snf_planned_job_chemicals',
-							terms: ['planned chemicals', 'planned chemical'],
-							collection: 'jobs',
-							permission_view: '/customer-info/jobs',
-							date_field: 'date_job_created',
-							quantity_field: 'planned_chemicals.quantity'
-						}
-					]
-				}
-			}
-		});
-		const collectionNames = ['jobs', 'work-order-dynamics', 'invoices'];
-		const shipmentDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'Summarize Devon Energy jobs and amount of chemicals sent to them for this year',
-			['chemicals', 'jobs', 'work-order-dynamics'],
-			collectionNames,
-			'snf'
-		);
-		assert(shipmentDirective?.payload?.collection === 'work-order-dynamics', 'Expected shipped-chemical job request to resolve to work-order-dynamics');
-		assert(String(shipmentDirective?.rawLine || '').includes('app-data-intent:snf_job_chemical_shipments'), 'Expected shipped-chemical request to use the SNF shipment recipe');
-		assert(
-			String(shipmentDirective?.metadata?.acknowledgementText || '').includes('I understand you want a summary of chemicals sent to Devon Energy jobs'),
-			'Expected shipment recipe to create a custom acknowledgement'
-		);
-		assert(
-			JSON.stringify(shipmentDirective?.payload?.pipeline || []).includes('chemicals.shipped.quantity'),
-			'Expected shipment recipe to aggregate shipped chemical quantity'
-		);
-		const invoiceDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'Devon Energy invoices this year',
-			['invoices'],
-			collectionNames,
-			'snf'
-		);
-		assert(invoiceDirective?.payload?.collection === 'invoices', 'Expected invoice request to resolve to invoices');
-		const plannedDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'planned chemicals for Devon jobs',
-			['jobs'],
-			collectionNames,
-			'snf'
-		);
-		assert(plannedDirective?.payload?.collection === 'jobs', 'Expected planned chemicals request to resolve to jobs');
-	}
-	finally {
-		if (priorInline === undefined) {
-			delete process.env.AI_ASSISTANT_APP_HEURISTICS;
-		}
-		else {
-			process.env.AI_ASSISTANT_APP_HEURISTICS = priorInline;
-		}
-		if (priorFile === undefined) {
-			delete process.env.AI_ASSISTANT_APP_HEURISTICS_FILE;
-		}
-		else {
-			process.env.AI_ASSISTANT_APP_HEURISTICS_FILE = priorFile;
-		}
-	}
-}
-
-function testAssistantRemovedDomainHeuristicIdsRemainAppSpecific() {
-	const priorInline = process.env.AI_ASSISTANT_APP_HEURISTICS;
-	const priorFile = process.env.AI_ASSISTANT_APP_HEURISTICS_FILE;
-	try {
-		process.env.AI_ASSISTANT_APP_HEURISTICS_FILE = '';
-		process.env.AI_ASSISTANT_APP_HEURISTICS = JSON.stringify({
-			apps: {
-				snf: {
-					enabled_deterministic_heuristics: [
-						'active_clients_count',
-						'current_bookings_count',
-						'active_holds_count',
-						'inventory_chemical_quantity',
-						'work_order_week_customer_breakdown',
-						'work_order_created_week_status',
-						'work_order_completed_per_day',
-						'work_order_completed_delivery_breakdown',
-						'work_order_top_customers_window',
-						'deliveries_per_driver_last_month',
-						'active_jobs_count',
-						'revenue_division_top_customers_window'
-					]
-				}
-			}
-		});
-		const cases = [
-			{
-				message: 'How many active clients are there?',
-				collectionHints: ['clients', 'customers'],
-				collectionNames: ['clients', 'customers'],
-				reason: 'Expected shared library to avoid emitting active client count directives'
-			},
-			{
-				message: 'How many current bookings does Acme have?',
-				collectionHints: ['bookings'],
-				collectionNames: ['bookings'],
-				reason: 'Expected shared library to avoid emitting booking count directives'
-			},
-			{
-				message: 'How many active holds are there?',
-				collectionHints: ['chemical-holds', 'holds'],
-				collectionNames: ['chemical-holds', 'holds'],
-				reason: 'Expected shared library to avoid emitting active hold directives'
-			},
-			{
-				message: 'How many Sack -1760 of FLOJET DRMAX P 9115 does midland plant have currently?',
-				collectionHints: ['chemical-inventory-snapshots', 'inventory-reports'],
-				collectionNames: ['chemical-inventory-snapshots', 'inventory-reports'],
-				reason: 'Expected shared library to avoid emitting inventory quantity directives'
-			},
-			{
-				message: 'Summarize the work orders this week by customer.',
-				collectionHints: ['work-order-dynamics', 'orders'],
-				collectionNames: ['work-order-dynamics', 'orders'],
-				reason: 'Expected shared library to avoid emitting work-order customer breakdown directives'
-			},
-			{
-				message: 'Show work orders created this week by status.',
-				collectionHints: ['work-order-dynamics', 'orders'],
-				collectionNames: ['work-order-dynamics', 'orders'],
-				reason: 'Expected shared library to avoid emitting work-order status directives'
-			},
-			{
-				message: 'Show completed work orders by day for the last 30 days.',
-				collectionHints: ['work-order-dynamics', 'orders'],
-				collectionNames: ['work-order-dynamics', 'orders'],
-				reason: 'Expected shared library to avoid emitting completed work-order per-day directives'
-			},
-			{
-				message: 'Break down the last 20 completed work orders and tell me what customer, what product and how much we delivered or returned.',
-				collectionHints: ['work-order-dynamics', 'orders'],
-				collectionNames: ['work-order-dynamics', 'orders'],
-				reason: 'Expected shared library to avoid emitting work-order delivery breakdown directives'
-			},
-			{
-				message: 'Show the top 10 customers by number of work orders in the last 6 months.',
-				collectionHints: ['work-order-dynamics', 'orders'],
-				collectionNames: ['work-order-dynamics', 'orders'],
-				reason: 'Expected shared library to avoid emitting work-order ranking directives'
-			},
-			{
-				message: 'Show deliveries per driver last month.',
-				collectionHints: ['work-order-dynamics', 'orders'],
-				collectionNames: ['work-order-dynamics', 'orders'],
-				reason: 'Expected shared library to avoid emitting delivery ranking directives'
-			},
-			{
-				message: 'How many active jobs are there?',
-				collectionHints: ['jobs'],
-				collectionNames: ['jobs'],
-				reason: 'Expected shared library to avoid emitting active jobs directives'
-			},
-			{
-				message: 'Show the top 10 customers by revenue by division in the last 6 months.',
-				collectionHints: ['invoices'],
-				collectionNames: ['invoices'],
-				reason: 'Expected shared library to avoid emitting revenue ranking directives'
-			}
-		];
-		cases.forEach((testCase) => {
-			assert(
-				!resolveAssistantHeuristicDirectiveForTesting(
-					testCase.message,
-					testCase.collectionHints,
-					testCase.collectionNames,
-					'snf'
-				),
-				testCase.reason
-			);
-		});
-	}
-	finally {
-		if (priorInline === undefined) {
-			delete process.env.AI_ASSISTANT_APP_HEURISTICS;
-		}
-		else {
-			process.env.AI_ASSISTANT_APP_HEURISTICS = priorInline;
-		}
-		if (priorFile === undefined) {
-			delete process.env.AI_ASSISTANT_APP_HEURISTICS_FILE;
-		}
-		else {
-			process.env.AI_ASSISTANT_APP_HEURISTICS_FILE = priorFile;
-		}
-	}
-}
-
-function testAssistantHeuristicBlendIdsRemainAppSpecific() {
-	const priorInline = process.env.AI_ASSISTANT_APP_HEURISTICS;
-	const priorFile = process.env.AI_ASSISTANT_APP_HEURISTICS_FILE;
-	try {
-		process.env.AI_ASSISTANT_APP_HEURISTICS_FILE = '';
-		process.env.AI_ASSISTANT_APP_HEURISTICS = JSON.stringify({
-			apps: {
-				snf: {
-					enabled_deterministic_heuristics: [
-						'blend_ticket_summary',
-						'blend_throughput_day_window',
-						'blend_user_window_count'
-					]
-				}
-			}
-		});
-		const summaryDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'For blending: summarize the last 10 blend tickets with product, total volume, and created date.',
-			['chemical-blends'],
-			['chemical-blends', 'report-chemical-blends'],
-			'snf'
-		);
-		assert(
-			!summaryDirective,
-			'Expected shared library to avoid emitting app-specific blend ticket summary directives'
-		);
-		const throughputDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'Show blend throughput by day for the last 2 weeks.',
-			['chemical-blends'],
-			['chemical-blends', 'report-chemical-blends'],
-			'snf'
-		);
-		assert(
-			!throughputDirective,
-			'Expected shared library to avoid emitting app-specific blend throughput directives'
-		);
-		assert(
-			!resolveAssistantHeuristicDirectiveForTesting(
-				'How many blends has John Doe completed in the last 30 days?',
-				['chemical-blends'],
-				['chemical-blends', 'report-chemical-blends'],
-				'snf'
-			),
-			'Expected shared library to avoid emitting app-specific blend user-window directives'
-		);
-	}
-	finally {
-		if (priorInline === undefined) {
-			delete process.env.AI_ASSISTANT_APP_HEURISTICS;
-		}
-		else {
-			process.env.AI_ASSISTANT_APP_HEURISTICS = priorInline;
-		}
-		if (priorFile === undefined) {
-			delete process.env.AI_ASSISTANT_APP_HEURISTICS_FILE;
-		}
-		else {
-			process.env.AI_ASSISTANT_APP_HEURISTICS_FILE = priorFile;
-		}
-	}
-}
-
-function testShouldEnforceAssistantDatedDirectiveSkipsWindowedRankingRequests() {
-	const classification = { type: 'data', dataQuestion: true, source: 'heuristic' } as any;
-	const shouldEnforce = shouldEnforceAssistantDatedDirective(
-		'List the top 10 customers by number of work orders in the last 6 months.',
-		{},
-		classification
-	);
-	assert(!shouldEnforce, 'Expected windowed ranking request to avoid forced dated grouping');
-}
-
-function testShouldEnforceAssistantDatedDirectiveForExplicitTemporalBreakdown() {
-	const classification = { type: 'data', dataQuestion: true, source: 'heuristic' } as any;
-	const shouldEnforce = shouldEnforceAssistantDatedDirective(
-		'Break down total revenue over the last 6 months by month.',
-		{},
-		classification
-	);
-	assert(shouldEnforce, 'Expected explicit by-month request to enforce dated grouping');
-}
-
-function testShouldEnforceAssistantDatedDirectiveForPlannerTemporalGroupBy() {
-	const classification = { type: 'data', dataQuestion: true, source: 'planner' } as any;
-	const shouldEnforce = shouldEnforceAssistantDatedDirective(
-		'Show revenue for the last 6 months.',
-		{ dataPlan: { queryPlan: { groupBy: 'month' } } },
-		classification
-	);
-	assert(shouldEnforce, 'Expected planner temporal groupBy to enforce dated grouping');
-}
-
-function testBuildAssistantDatedPivotDisplayWithYearMonthAndCustomer() {
-	const display = {
-		columns: ['Customer', 'Year', 'Month', 'Total Revenue'],
-		rows: [
-			{ Customer: 'Apache', Year: 2025, Month: 11, 'Total Revenue': 1000 },
-			{ Customer: 'Apache', Year: 2025, Month: 12, 'Total Revenue': 2000 },
-			{ Customer: 'Pioneer', Year: 2025, Month: 11, 'Total Revenue': 1500 },
-			{ Customer: 'Pioneer', Year: 2025, Month: 12, 'Total Revenue': 500 }
-		],
-		rowCount: 4,
-		truncated: false,
-		includeIds: false
-	};
-	const pivoted = buildAssistantDatedPivotDisplay(display as any);
-	assert(!!pivoted, 'Expected dated pivot display to be produced');
-	assert(
-		pivoted?.columns?.[0] === 'Customer',
-		'Expected customer to remain first pivot column'
-	);
-	assert(
-		pivoted?.columns?.includes('2025-11') && pivoted?.columns?.includes('2025-12'),
-		'Expected YYYY-MM month columns'
-	);
-	const apacheRow = (pivoted?.rows || []).find((row: any) => row?.Customer === 'Apache');
-	assert(!!apacheRow, 'Expected Apache row in pivot');
-	assert(
-		String(apacheRow?.['2025-11'] || '').includes('$'),
-		'Expected revenue cells to be currency formatted'
-	);
-}
-
-function testBuildAssistantDatedPivotDisplayWithoutDimensionCreatesMetricGrid() {
-	const display = {
-		columns: ['Year', 'Month', 'Total Revenue'],
-		rows: [
-			{ Year: 2025, Month: 11, 'Total Revenue': 3200 },
-			{ Year: 2025, Month: 12, 'Total Revenue': 4100 },
-			{ Year: 2026, Month: 1, 'Total Revenue': 5050 }
-		],
-		rowCount: 3,
-		truncated: false,
-		includeIds: false
-	};
-	const pivoted = buildAssistantDatedPivotDisplay(display as any);
-	assert(!!pivoted, 'Expected dated pivot grid even without explicit dimension');
-	assert(pivoted?.columns?.[0] === 'Metric', 'Expected synthetic Metric column');
-	assert(
-		pivoted?.columns?.includes('2025-11')
-		&& pivoted?.columns?.includes('2025-12')
-		&& pivoted?.columns?.includes('2026-01'),
-		'Expected month header columns for all buckets'
-	);
-	assert((pivoted?.rows || []).length === 1, 'Expected single metric row for monthly totals');
-	assert(
-		normalizeCellText((pivoted?.rows || [])[0]?.Metric) === 'Total Revenue',
-		'Expected metric row label to use value column'
-	);
-}
-
-function testBuildAssistantInvoiceCustomerLabelExprIncludesClientFallbacks() {
-	const expression = buildAssistantInvoiceCustomerLabelExpr();
-	const serialized = JSON.stringify(expression);
-	const requiredTokens = [
-		'$customer_name',
-		'$customer.fullname',
-		'$customer.name',
-		'$customer',
-		'$client_name',
-		'$client.fullname',
-		'$client.name',
-		'$client',
-		'$id_customer',
-		'$id_client',
-		'Unknown Customer',
-		'$strLenCP'
-	];
-	requiredTokens.forEach((token) => {
-		assert(
-			serialized.includes(token),
-			`Expected invoice customer expression to include ${token}`
-		);
-	});
-}
-
-function testResolveAssistantReadDisplayMaxRows() {
-	assert(
-		resolveAssistantReadDisplayMaxRows(0, 92) === 20,
-		'Expected limit=0 to fallback to preview rows instead of zero rows'
-	);
-	assert(
-		resolveAssistantReadDisplayMaxRows(undefined, 7) === 7,
-		'Expected small row counts to be preserved for preview'
-	);
-	assert(
-		resolveAssistantReadDisplayMaxRows(5, 92) === 5,
-		'Expected explicit positive limit to be respected'
-	);
-	assert(
-		resolveAssistantReadDisplayMaxRows(undefined, 0) === 20,
-		'Expected empty reads to keep default preview row ceiling'
-	);
-}
-
-function testResolveAssistantCollectionOverrideKeepsSpecificOrdersCollection() {
-	const override = resolveAssistantCollectionOverride(
-		{
-			ranked: [
-				{ name: 'orders', score: 40 },
-				{ name: 'maintenance-orders', score: 20 }
-			]
-		},
-		'maintenance-orders'
-	);
-	assert(!override, 'Expected maintenance-orders to not be overridden by generic orders');
-}
-
-function testResolveAssistantCollectionOverrideStillAppliesForUnrelatedCollection() {
-	const override = resolveAssistantCollectionOverride(
-		{
-			ranked: [
-				{ name: 'orders', score: 40 },
-				{ name: 'maintenance-orders', score: 20 }
-			]
-		},
-		'clients'
-	);
-	assert(!!override, 'Expected unrelated collection to be overridden by highest-ranked candidate');
-	assert(override?.to === 'orders', 'Expected override target to be orders');
-}
-
-function testResolveAssistantCollectionOverrideSkipsBorderlineGapForWorkOrderRanking() {
-	const override = resolveAssistantCollectionOverride(
-		{
-			tokens: ['top', '10', 'customers', 'customer', 'number', 'work', 'orders', 'order', '6', 'months'],
-			tokenWeights: {
-				top: 1,
-				'10': 1,
-				customers: 1,
-				customer: 1,
-				number: 1,
-				work: 1,
-				orders: 1,
-				order: 1,
-				'6': 1,
-				months: 1
-			},
-			ranked: [
-				{ name: 'customers', score: 40 },
-				{ name: 'orders', score: 40 }
-			]
-		},
-		'work-order-dynamics'
-	);
-	assert(!override, 'Expected work-order-dynamics to be preserved when score gap is only at threshold');
-}
-
-function testResolveAssistantCollectionOverrideKeepsWorkOrderCollectionWhenOrdersScoresHigher() {
-	const override = resolveAssistantCollectionOverride(
-		{
-			ranked: [
-				{ name: 'orders', score: 85 },
-				{ name: 'work-order-dynamics', score: 64 }
-			]
-		},
-		'work-order-dynamics'
-	);
-	assert(!override, 'Expected work-order-dynamics to stay selected over generic orders');
-}
-
-function testResolveCollectionOverrideWithContextRespectsPermissionRouteHints() {
-	const override = resolveCollectionOverrideWithContextForTesting({
-		message: 'How many pods do we have in inventory?',
-		collectionRanking: {
-			ranked: [
-				{ name: 'inventory-report-text-users', score: 39 },
-				{ name: 'assets', score: 0 }
-			]
-		},
-		requestedCollection: 'assets',
-		permissionView: '/asset/list',
-		collectionNames: ['assets', 'inventory-report-text-users']
-	});
-	assert(!override, 'Expected /asset/list route hints to keep assets collection');
-}
-
-function testResolveCollectionOverrideWithContextUsesSpecificPermissionRouteCollection() {
-	const override = resolveCollectionOverrideWithContextForTesting({
-		message: 'Summarize the work orders this week by customer.',
-		collectionRanking: {
-			ranked: [
-				{ name: 'production-sales-orders', score: 80 },
-				{ name: 'work-order-dynamics', score: 70 }
-			]
-		},
-		requestedCollection: 'production-sales-orders',
-		permissionView: '/work-order-dynamic/list',
-		collectionNames: ['production-sales-orders', 'work-order-dynamics']
-	});
-	assert(!!override, 'Expected work-order permission route to correct mismatched production-sales-orders collection');
-	assert(
-		override?.to === 'work-order-dynamics',
-		'Expected override target to be work-order-dynamics'
-	);
-}
-
-function testResolveCollectionOverrideWithContextUsesOrderedCollectionHints() {
-	const override = resolveCollectionOverrideWithContextForTesting({
-		message: 'Summarize the work orders this week by customer.',
-		collectionRanking: {
-			ranked: [
-				{ name: 'customers', score: 90 },
-				{ name: 'production-sales-orders', score: 80 }
-			]
-		},
-		requestedCollection: 'customers',
-		permissionView: '/work-order-dynamic/list',
-		collectionNames: ['customers', 'production-sales-orders'],
-		collectionHints: ['work-order-dynamics', 'jobs', 'maintenance-orders', 'customers', 'orders']
-	});
-	assert(!!override, 'Expected ordered collection hints to correct grouped-dimension collection selection');
-	assert(
-		override?.to === 'work-order-dynamics',
-		'Expected override target to be the first ordered collection hint'
-	);
-}
-
-function testResolveCollectionOverrideWithContextPreservesPrimaryCollectionHint() {
-	const override = resolveCollectionOverrideWithContextForTesting({
-		message: 'Summarize the work orders this week by customer.',
-		collectionRanking: {
-			ranked: [
-				{ name: 'customer-portal-passwords', score: 45 },
-				{ name: 'work-order-dynamics', score: 20 }
-			]
-		},
-		requestedCollection: 'work-order-dynamics',
-		permissionView: '/work-order-dynamic/list',
-		collectionNames: ['customer-portal-passwords', 'work-order-dynamics'],
-		collectionHints: ['work-order-dynamics', 'jobs', 'maintenance-orders', 'customers', 'orders']
-	});
-	assert(!override, 'Expected primary collection hint to preserve the model-selected collection');
-}
-
-function testResolveCollectionOverrideWithContextKeepsRouteMatchedJobsOverChemicalHint() {
-	const override = resolveCollectionOverrideWithContextForTesting({
-		message: 'Summarize Devon Energy jobs and amount of chemicals sent to them for this year',
-		collectionRanking: {
-			ranked: [
-				{ name: 'chemicals', score: 79 },
-				{ name: 'jobs', score: 76 },
-				{ name: 'work-order-dynamics', score: 38 }
-			]
-		},
-		requestedCollection: 'jobs',
-		permissionView: '/job/list',
-		collectionNames: ['chemicals', 'jobs', 'work-order-dynamics'],
-		collectionHints: ['chemicals', 'jobs', 'work-order-dynamics', 'chemical-blends']
-	});
-	assert(!override, 'Expected /job/list route to preserve model-selected jobs over a chemical keyword hint');
-}
-
-function testResolveCollectionOverrideWithContextPreservesJobDomainDetailCollections() {
-	const override = resolveCollectionOverrideWithContextForTesting({
-		message: 'Summarize Devon Energy jobs and amount of chemicals sent to them for this year',
-		collectionRanking: {
-			ranked: [
-				{ name: 'work-order-dynamics', score: 80 },
-				{ name: 'jobs', score: 76 }
-			]
-		},
-		requestedCollection: 'work-order-dynamics',
-		permissionView: '/customer-info/jobs',
-		collectionNames: ['jobs', 'work-order-dynamics', 'invoices'],
-		collectionHints: ['work-order-dynamics', 'jobs', 'invoices']
-	});
-	assert(!override, 'Expected job route to preserve work-order-dynamics for shipped chemical job summaries');
-}
-
-function testResolveCollectionOverrideWithContextKeepsCompetitiveRootCollectionHint() {
-	const override = resolveCollectionOverrideWithContextForTesting({
-		message: 'Summarize Devon Energy jobs and amount of chemicals sent to them for this year',
-		collectionRanking: {
-			ranked: [
-				{ name: 'chemicals', score: 79 },
-				{ name: 'jobs', score: 76 },
-				{ name: 'work-order-dynamics', score: 38 }
-			]
-		},
-		requestedCollection: 'jobs',
-		collectionNames: ['chemicals', 'jobs', 'work-order-dynamics'],
-		collectionHints: ['chemicals', 'jobs', 'work-order-dynamics', 'chemical-blends']
-	});
-	assert(!override, 'Expected close-ranked model-selected root collection to survive a related detail collection hint');
-}
-
-function testShouldPreserveAssistantProbeCollectionForPrimaryHintAndRoute() {
-	const directive = {
-		type: 'aggregate',
-		payload: {
-			collection: 'work-order-dynamics',
-			permissionView: '/work-order-dynamic/list'
-		}
-	};
-	const preserveFromHints = shouldPreserveAssistantProbeCollectionForTesting(
-		directive,
-		'production-sales-orders',
-		{
-			debug: {
-				requestHints: {
-					collectionHints: ['work-order-dynamics', 'production-sales-orders']
-				}
-			}
-		}
-	);
-	assert(preserveFromHints, 'Expected probe rewrite to preserve primary hinted work-order collection');
-
-	const preserveFromRoute = shouldPreserveAssistantProbeCollectionForTesting(
-		directive,
-		'production-sales-orders'
-	);
-	assert(preserveFromRoute, 'Expected probe rewrite to preserve collection matching the permission route');
-
-	const lockForExecution = shouldLockAssistantRequestedCollectionForExecutionForTesting(
-		'work-order-dynamics',
-		'/work-order-dynamic',
-		{
-			collectionHints: ['work-order-dynamics', 'production-sales-orders']
-		}
-	);
-	assert(lockForExecution, 'Expected execution to disable cross-collection retry for route/primary hinted collection');
-}
-
-function testResolveCollectionOverrideWithContextStillOverridesWithoutRouteHints() {
-	const override = resolveCollectionOverrideWithContextForTesting({
-		message: 'How many pods do we have in inventory?',
-		collectionRanking: {
-			ranked: [
-				{ name: 'inventory-report-text-users', score: 39 },
-				{ name: 'assets', score: 0 }
-			]
-		},
-		requestedCollection: 'assets',
-		permissionView: '/dashboard/home',
-		collectionNames: ['assets', 'inventory-report-text-users']
-	});
-	assert(!!override, 'Expected override to still apply when route has no collection hints');
-	assert(
-		override?.to === 'inventory-report-text-users',
-		'Expected override target to remain the top ranked collection when route hints are absent'
-	);
-}
-
-function testResolveAssistantCrossCollectionFallbackCandidatesForOrders() {
-	const candidates = resolveAssistantCrossCollectionFallbackCandidates('orders');
-	assert(candidates.length === 0, 'Expected non-aliased collections to have no hardcoded fallback list');
-}
-
-function testResolveAssistantCrossCollectionFallbackCandidatesForWorkOrderDynamics() {
-	const candidates = resolveAssistantCrossCollectionFallbackCandidates('work-order-dynamics');
-	assert(candidates.length === 0, 'Expected work-order-dynamics to have no hardcoded fallback list');
-}
-
-function testResolveAssistantCrossCollectionFallbackCandidatesForUnknownCollection() {
-	const candidates = resolveAssistantCrossCollectionFallbackCandidates('foobar-collection');
-	assert(candidates.length === 0, 'Expected unknown collection fallback candidates to be empty');
-}
-
-function testResolveAssistantCrossCollectionFallbackCandidatesForTimeEntries() {
-	const candidates = resolveAssistantCrossCollectionFallbackCandidates('time_entries');
-	assert(candidates.length === 0, 'Expected time entries to have no hardcoded fallback list');
-}
-
-function testResolveAssistantAvailableCrossCollectionFallbacksFromNamesUsesSimilarityRanking() {
-	const available = resolveAssistantAvailableCrossCollectionFallbacksFromNames(
-		'orders',
-		new Set<string>(['orders']),
-		['orders', 'maintenance-orders', 'repair-orders', 'customers']
-	);
-	assert(
-		available.includes('maintenance-orders') || available.includes('repair-orders'),
-		'Expected orders fallback to include related collections from token similarity'
-	);
-}
-
-function testResolveAssistantAvailableCrossCollectionFallbacksFromNamesSkipsCurrentFamilyOnlyMatch() {
-	const available = resolveAssistantAvailableCrossCollectionFallbacksFromNames(
-		'time_entries',
-		new Set<string>(['time_entries']),
-		['time_entries']
-	);
-	assert(
-		available.length === 0,
-		'Expected no fallback when only the current collection family is available'
-	);
-}
-
-function testResolveAssistantCrossCollectionFallbackCandidatesForSupportAlias() {
-	const candidates = resolveAssistantCrossCollectionFallbackCandidates('supporttickets');
-	assert(
-		candidates.length === 0,
-		'Expected shared library to avoid injecting support ticket fallback aliases'
-	);
-}
-
-function testShouldAcceptAssistantFallbackDocumentsRejectsBlankDimensionRows() {
-	const accepted = shouldAcceptAssistantFallbackDocuments([
-		{ 'Work Orders': 23, Customer: '' }
-	]);
-	assert(!accepted, 'Expected fallback documents with empty dimensions to be rejected');
-}
-
-function testShouldAcceptAssistantFallbackDocumentsAcceptsNamedDimensions() {
-	const accepted = shouldAcceptAssistantFallbackDocuments([
-		{ 'Work Orders': 23, Customer: 'Acme Services' }
-	]);
-	assert(accepted, 'Expected fallback documents with populated dimensions to be accepted');
-}
-
-function testShouldAcceptAssistantFallbackDocumentsAcceptsMetricOnlyRows() {
-	const accepted = shouldAcceptAssistantFallbackDocuments([
-		{ Count: 42, Total: 4200 }
-	]);
-	assert(accepted, 'Expected metric-only fallback documents to be accepted');
-}
-
-function normalizeCellText(value: any): string {
-	return String(value || '').trim();
-}
-
-function testDisplayMarkdownInvoiceNumbersAndCountsStayNumeric() {
-	const display = buildDisplayTable([
-		{ invoice_number: 0, total: 558, voidedCount: 558 },
-		{ invoice_number: 203746, total: 2, voidedCount: 2 }
-	]);
-	const markdown = formatDisplayTableMarkdown(display);
-	assert(!markdown.includes('$0.00'), 'Expected invoice number 0 to remain numeric');
-	assert(!markdown.includes('$203,746.00'), 'Expected invoice number to remain numeric');
-	assert(!markdown.includes('$558.00'), 'Expected duplicate count total to remain numeric');
-	assert(markdown.includes('203,746'), 'Expected large invoice number to be number-formatted');
-}
-
-function testDisplayMarkdownCurrencyColumnsStillUseCurrencyFormat() {
-	const display = buildDisplayTable([
-		{ invoice_number: 1001, grand_total: 1234.5, sales_tax: 88.1, paid_total: 500 }
-	]);
-	const markdown = formatDisplayTableMarkdown(display);
-	assert(markdown.includes('$1,234.50'), 'Expected grand_total to be currency formatted');
-	assert(markdown.includes('$88.10'), 'Expected sales_tax to be currency formatted');
-	assert(markdown.includes('$500.00'), 'Expected paid_total to be currency formatted');
-	assert(!markdown.includes('$1,001.00'), 'Expected invoice_number to not be currency formatted');
-}
-
-function testDisplayMarkdownKeepsAlphanumericBlendAndChemicalNames() {
-	const display = buildDisplayTable([
-		{
-			blend_name: 'ASFlow-100 Bulk Winter Blend (Surf Pkg)',
-			chemical: 'INT 50/50 - CO INDEPENDENCE',
-			chemical_recipe_quantity: 4500
-		}
-	]);
-	const markdown = formatDisplayTableMarkdown(display);
-	assert(markdown.includes('ASFlow-100 Bulk Winter Blend (Surf Pkg)'), 'Expected blend name to remain text');
-	assert(markdown.includes('INT 50/50 - CO INDEPENDENCE'), 'Expected chemical name to remain text');
-	assert(!markdown.includes('| -100 |'), 'Expected blend/chemical names to not be coerced into numeric -100');
-	assert(!markdown.includes('| 5,050 |'), 'Expected blend/chemical names to not be coerced into numeric 5,050');
-}
-
-function testDisplayTableCoalescesStringVariantFields() {
-	const display = buildDisplayTable([
-		{
-			batch_number: 202792,
-			batch_number_string: '202,792',
-			createdAt: '2026-02-06T21:47:00.000Z'
-		},
-		{
-			batch_number: null,
-			batch_number_string: '202,791',
-			createdAt: '2026-02-06T20:18:00.000Z'
-		}
-	]);
-	assert(display.columns.includes('Batch Number'), 'Expected base batch number column');
-	assert(!display.columns.includes('Batch Number String'), 'Expected string variant batch column to be removed');
-	const secondRow = display.rows?.[1] || {};
-	assert(String(secondRow['Batch Number'] || '').includes('202,791'), 'Expected fallback from batch_number_string into Batch Number');
-}
-
-function testDisplayTableCoalescesEquivalentCreatedDateFields() {
-	const display = buildDisplayTable([
-		{
-			createdAt: '2026-02-06T21:47:00.000Z',
-			date: '2026-02-06T21:47:00.000Z',
-			blend_name: 'Blend A'
-		},
-		{
-			createdAt: '2026-02-06T20:18:00.000Z',
-			date: '2026-02-06T20:18:00.000Z',
-			blend_name: 'Blend B'
-		}
-	]);
-	assert(display.columns.includes('Created At'), 'Expected Created At column to remain');
-	assert(!display.columns.includes('Date'), 'Expected duplicate Date column to be removed');
-}
-
-function testDisplayTableKeepsDistinctCreatedDateAndDateFields() {
-	const display = buildDisplayTable([
-		{
-			createdAt: '2026-02-06T21:47:00.000Z',
-			date: '2026-02-01T00:00:00.000Z',
-			blend_name: 'Blend A'
-		},
-		{
-			createdAt: '2026-02-06T20:18:00.000Z',
-			date: '2026-02-01T00:00:00.000Z',
-			blend_name: 'Blend B'
-		}
-	]);
-	assert(display.columns.includes('Created At'), 'Expected Created At column to remain');
-	assert(display.columns.includes('Date'), 'Expected Date column to remain when values differ');
-}
-
-function testStripQueryFieldPathsDeep() {
-	const query = { $and: [{ id_customer: 'Acme' }, { status: 'open' }] };
-	const stripped = stripQueryFieldPathsDeep(query, ['id_customer', 'other.id_customer']);
-	assert(JSON.stringify(stripped) === JSON.stringify({ status: 'open' }), 'Expected id_customer to be stripped');
-
-	const nested = { other: { id_customer: 'Acme', foo: 1 }, status: 'open' };
-	const strippedNested = stripQueryFieldPathsDeep(nested, ['id_customer', 'other.id_customer']);
-	assert(
-		JSON.stringify(strippedNested) === JSON.stringify({ other: { foo: 1 }, status: 'open' }),
-		'Expected nested other.id_customer to be stripped'
-	);
-
-	const pipeline = [{ $match: { id_customer: 'Acme', status: 'open' } }];
-	const strippedPipeline = stripScopedFieldsFromPipeline(pipeline, ['id_customer', 'other.id_customer']);
-	assert(
-		JSON.stringify(strippedPipeline[0]?.$match) === JSON.stringify({ status: 'open' }),
-		'Expected pipeline $match id_customer to be stripped'
-	);
-}
-
-function testResolveReadMultiTermJobRegexFallbackForTesting() {
-	const query = {
-		$and: [
-			{
-				$or: [
-					{ job_number_string: { $regex: 'hazelwood', $options: 'i' } },
-					{ job_number: { $regex: 'hazelwood', $options: 'i' } },
-					{ bid: { $regex: 'hazelwood', $options: 'i' } },
-					{ jca: { $regex: 'hazelwood', $options: 'i' } }
-				]
-			},
-			{
-				$or: [
-					{ job_number_string: { $regex: 'cross', $options: 'i' } },
-					{ job_number: { $regex: 'cross', $options: 'i' } },
-					{ bid: { $regex: 'cross', $options: 'i' } },
-					{ jca: { $regex: 'cross', $options: 'i' } }
-				]
-			},
-			{
-				$or: [
-					{ customer: { $regex: 'pioneer', $options: 'i' } },
-					{ operator: { $regex: 'pioneer', $options: 'i' } }
-				]
-			}
-		]
-	};
-	const probeDocs = [
-		{
-			job_number_string: 'J-1001',
-			pad: 'Hazelwood Cross',
-			wells: [{ well: 'Hazelwood Cross #1' }],
-			customer: 'Pioneer',
-			operator: 'Pioneer'
-		}
-	];
-	const schemaFields = ['job_number_string', 'job_number', 'bid', 'jca', 'pad', 'wells.$.well', 'customer', 'operator'];
-	const fallback = resolveReadMultiTermJobRegexFallbackForTesting(query as any, probeDocs, schemaFields);
-	assert(!!fallback, 'Expected multi-term job regex fallback to resolve');
-	assert(
-		fallback?.terms.includes('hazelwood') && fallback?.terms.includes('cross'),
-		'Expected fallback terms to include hazelwood and cross'
-	);
-	assert(
-		fallback?.fields.includes('pad') || fallback?.fields.includes('wells.well'),
-		'Expected fallback fields to include pad or wells.well'
-	);
-	const serialized = JSON.stringify(fallback?.query || {});
-	assert(serialized.includes('pioneer'), 'Expected non-job customer/operator filters to be preserved');
-	assert(serialized.includes('hazelwood') && serialized.includes('cross'), 'Expected fallback query to preserve both job terms');
-}
-
-function testNormalizeIdsForTargetField() {
-	const hex = '64b7f3f5c3a18e2f2b4a1f01';
-	const objectId = new ObjectId(hex);
-	const stringDocs = [{ id_customer: 'CUST-123' }];
-	const normalizedStrings = normalizeIdsForTargetField([objectId], stringDocs, 'id_customer');
-	assert(
-		Array.isArray(normalizedStrings) && normalizedStrings[0] === hex,
-		'Expected ObjectId to normalize to string hex for string fields'
-	);
-
-	const objectDocs = [{ id_customer: objectId }];
-	const normalizedObjects = normalizeIdsForTargetField([hex], objectDocs, 'id_customer');
-	const normalizedIsObjectId = normalizedObjects.some(value => value && typeof value.toHexString === 'function');
-	assert(normalizedIsObjectId, 'Expected string hex to normalize to ObjectId for objectId fields');
-}
-
-function testRewriteEmbeddedMatchObjects() {
-	const query = { customer: { name: 'Acme' }, status: 'open' };
-	const rewritten = rewriteEmbeddedMatchObjects(query);
-	assert(
-		JSON.stringify(rewritten) === JSON.stringify({ 'customer.name': 'Acme', status: 'open' }),
-		'Expected embedded match object to be rewritten to dot notation'
-	);
-
-	const nestedOperator = { customer: { name: { $regex: 'Acme', $options: 'i' } } };
-	const rewrittenOperator = rewriteEmbeddedMatchObjects(nestedOperator);
-	assert(
-		!!rewrittenOperator['customer.name']?.$regex,
-		'Expected operator object to be preserved under dot notation'
-	);
-
-	const fieldOperator = { customer: { $in: ['A', 'B'] } };
-	const rewrittenFieldOperator = rewriteEmbeddedMatchObjects(fieldOperator);
-	assert(
-		JSON.stringify(rewrittenFieldOperator) === JSON.stringify(fieldOperator),
-		'Expected field-level operator objects to remain unchanged'
-	);
-
-	const logicalOperator = {
-		$or: [
-			{ customer: { name: 'Acme' } },
-			{ customer: { name: 'Globex' } }
-		]
-	};
-	const rewrittenLogical = rewriteEmbeddedMatchObjects(logicalOperator);
-	assert(
-		JSON.stringify(rewrittenLogical) === JSON.stringify({
-			$or: [
-				{ 'customer.name': 'Acme' },
-				{ 'customer.name': 'Globex' }
-			]
-		}),
-		'Expected logical operator entries to be flattened'
-	);
-}
-
-function testRewriteMatchExpressionsToExpr() {
-	const query = {
-		status: 'Paid/Closed',
-		date_paid: {
-			$gte: { $dateSubtract: { startDate: '$$NOW', unit: 'month', amount: 6 } },
-			$lte: '$$NOW'
-		}
-	};
-	const rewritten = rewriteMatchExpressionsToExpr(query);
-	assert(
-		JSON.stringify(rewritten) === JSON.stringify({
-			status: 'Paid/Closed',
-			$expr: {
-				$and: [
-					{ $gte: ['$date_paid', { $dateSubtract: { startDate: '$$NOW', unit: 'month', amount: 6 } }] },
-					{ $lte: ['$date_paid', '$$NOW'] }
-				]
-			}
-		}),
-		'Expected expression-style match operators to be rewritten into $expr'
-	);
-}
-
-function testRewriteMatchExpressionsToExprCompactNowToken() {
-	const query = {
-		date_paid: {
-			$gte: '$$NOW-6M',
-			$lte: '$$NOW'
-		}
-	};
-	const rewritten = rewriteMatchExpressionsToExpr(query);
-	assert(
-		JSON.stringify(rewritten) === JSON.stringify({
-			$expr: {
-				$and: [
-					{ $gte: ['$date_paid', { $dateSubtract: { startDate: '$$NOW', unit: 'month', amount: 6 } }] },
-					{ $lte: ['$date_paid', '$$NOW'] }
-				]
-			}
-		}),
-		'Expected compact $$NOW-6M token to be normalized into $dateSubtract'
-	);
-}
-
-function testNormalizeAssistantNowExprPlaceholdersDateArithmeticArgs() {
-	const query = {
-		$expr: {
-			$gte: [
-				'$date_paid',
-				{ $dateSubtract: { date: '$$NOW', unit: 'month', amount: 6 } }
-			]
-		}
-	};
-	const normalized = normalizeAssistantNowExprPlaceholders(query);
-	const dateSubtractArgs = normalized?.$expr?.$gte?.[1]?.$dateSubtract;
-	assert(!!dateSubtractArgs, 'Expected $dateSubtract args to exist');
-	assert(dateSubtractArgs.startDate === '$$NOW', 'Expected $dateSubtract.date to normalize to startDate');
-	assert(!Object.prototype.hasOwnProperty.call(dateSubtractArgs, 'date'), 'Expected legacy $dateSubtract.date arg to be removed');
-}
-
-function testNormalizeAssistantNowExprPlaceholdersDateArithmeticUnknownKeyAsStartDate() {
-	const query = {
-		$expr: {
-			$gte: [
-				'$date_paid',
-				{ $dateSubtract: { 'misc_charges.amount': '$$NOW', unit: 'month', amount: 6 } }
-			]
-		}
-	};
-	const normalized = normalizeAssistantNowExprPlaceholders(query);
-	const dateSubtractArgs = normalized?.$expr?.$gte?.[1]?.$dateSubtract;
-	assert(!!dateSubtractArgs, 'Expected $dateSubtract args to exist');
-	assert(dateSubtractArgs.startDate === '$$NOW', 'Expected unknown key value to normalize to startDate');
-	assert(dateSubtractArgs.amount === 6, 'Expected amount to remain numeric');
-	assert(!Object.prototype.hasOwnProperty.call(dateSubtractArgs, 'misc_charges.amount'), 'Expected unknown key to be removed');
-}
-
-function testNormalizeAssistantNowExprPlaceholdersDateArithmeticUnknownKeyAsAmount() {
-	const query = {
-		$expr: {
-			$gte: [
-				'$date_paid',
-				{ $dateSubtract: { startDate: '$$NOW', unit: 'month', 'misc_charges.amount': 6 } }
-			]
-		}
-	};
-	const normalized = normalizeAssistantNowExprPlaceholders(query);
-	const dateSubtractArgs = normalized?.$expr?.$gte?.[1]?.$dateSubtract;
-	assert(!!dateSubtractArgs, 'Expected $dateSubtract args to exist');
-	assert(dateSubtractArgs.startDate === '$$NOW', 'Expected startDate to remain intact');
-	assert(dateSubtractArgs.amount === 6, 'Expected unknown numeric key to normalize to amount');
-	assert(!Object.prototype.hasOwnProperty.call(dateSubtractArgs, 'misc_charges.amount'), 'Expected unknown key to be removed');
-}
-
-function testNormalizeAssistantMonthlyCalendarWindowPipelineConvertsRollingMonthlyRange() {
-	const pipeline = [
-		{
-			$match: {
-				$expr: {
-					$and: [
-						{
-							$gte: [
-								'$date_invoice',
-								{ $dateSubtract: { startDate: '$$NOW', unit: 'month', amount: 6 } }
-							]
-						},
-						{ $lte: ['$date_invoice', '$$NOW'] }
-					]
-				}
-			}
-		},
-		{
-			$group: {
-				_id: {
-					$dateToString: {
-						format: '%Y-%m',
-						date: '$date_invoice'
-					}
-				},
-				total_revenue: { $sum: '$grand_total' }
-			}
-		}
-	];
-	const normalized = normalizeAssistantMonthlyCalendarWindowPipeline(pipeline as any);
-	const andClauses = normalized?.[0]?.$match?.$expr?.$and;
-	assert(Array.isArray(andClauses), 'Expected normalized $expr.$and clauses');
-	const lowerClause = andClauses.find((entry: any) => entry?.$gte?.[0] === '$date_invoice');
-	assert(!!lowerClause, 'Expected lower month bound clause');
-	const lowerSubtract = lowerClause?.$gte?.[1]?.$dateSubtract;
-	assert(!!lowerSubtract, 'Expected $dateSubtract lower bound');
-	assert(lowerSubtract?.startDate?.$dateTrunc?.date === '$$NOW', 'Expected lower bound anchored to month start');
-	assert(lowerSubtract?.startDate?.$dateTrunc?.unit === 'month', 'Expected lower bound month truncation');
-	assert(lowerSubtract?.amount === 6, 'Expected month count preserved');
-	const upperClause = andClauses.find((entry: any) => entry?.$lt?.[0] === '$date_invoice');
-	assert(!!upperClause, 'Expected strict upper month-start clause');
-	assert(upperClause?.$lt?.[1]?.$dateTrunc?.date === '$$NOW', 'Expected upper bound anchored to current month start');
-	assert(upperClause?.$lt?.[1]?.$dateTrunc?.unit === 'month', 'Expected upper bound month truncation');
-	assert(!andClauses.some((entry: any) => entry?.$lte?.[1] === '$$NOW'), 'Expected rolling $$NOW upper bound removed');
-}
-
-function testNormalizeAssistantMonthlyCalendarWindowPipelineSkipsDailyGrouping() {
-	const pipeline = [
-		{
-			$match: {
-				$expr: {
-					$and: [
-						{
-							$gte: [
-								'$date_invoice',
-								{ $dateSubtract: { startDate: '$$NOW', unit: 'month', amount: 6 } }
-							]
-						},
-						{ $lte: ['$date_invoice', '$$NOW'] }
-					]
-				}
-			}
-		},
-		{
-			$group: {
-				_id: {
-					$dateToString: {
-						format: '%Y-%m-%d',
-						date: '$date_invoice'
-					}
-				},
-				total_revenue: { $sum: '$grand_total' }
-			}
-		}
-	];
-	const normalized = normalizeAssistantMonthlyCalendarWindowPipeline(pipeline as any);
-	const andClauses = normalized?.[0]?.$match?.$expr?.$and;
-	assert(Array.isArray(andClauses), 'Expected daily grouping to preserve $and clauses');
-	assert(andClauses.some((entry: any) => entry?.$lte?.[1] === '$$NOW'), 'Expected rolling $$NOW upper bound to remain for non-monthly grouping');
-}
-
-function testExpandAggregateDateMatchFallbackExpandsNestedOrClauses() {
-	const pipeline = [
-		{
-			$match: {
-				$and: [
-					{
-						$or: [
-							{
-								date_created: { $gte: new Date('2026-02-16T00:00:00.000Z') },
-								$expr: { $lte: ['$date_created', '$$NOW'] }
-							},
-							{
-								createdAt: { $gte: new Date('2026-02-16T00:00:00.000Z') },
-								$expr: { $lte: ['$createdAt', '$$NOW'] }
-							}
-						]
-					}
-				]
-			}
-		},
-		{
-			$group: {
-				_id: '$customer',
-				work_orders: { $sum: 1 }
-			}
-		}
-	];
-	const expanded = expandAggregateDateMatchFallbackForTesting(
-		pipeline as any,
-		['date_completed', 'date_closed', 'date_created', 'createdAt']
-	);
-	assert(!!expanded, 'Expected aggregate date fallback to expand nested $or clauses');
-	assert(
-		Array.isArray(expanded?.fields) && expanded?.fields.includes('date_completed') && expanded?.fields.includes('date_closed'),
-		'Expected aggregate date fallback to add completed and closed date fields'
-	);
-	const expandedOr = expanded?.pipeline?.[0]?.$match?.$and?.[0]?.$or;
-	assert(Array.isArray(expandedOr), 'Expected expanded nested $or array');
-	assert(
-		expandedOr.some((entry: any) => Object.prototype.hasOwnProperty.call(entry, 'date_completed')),
-		'Expected nested $or to include date_completed fallback branch'
-	);
-	assert(
-		expandedOr.some((entry: any) => Object.prototype.hasOwnProperty.call(entry, 'date_closed')),
-		'Expected nested $or to include date_closed fallback branch'
-	);
-}
-
-function testNormalizeAssistantAggregatePipelineRankSortBySingleKey() {
-	const pipeline = [
-		{
-			$setWindowFields: {
-				partitionBy: null,
-				sortBy: {
-					total_by_driver: -1,
-					driver: 1
-				},
-				output: {
-					driver_rank: { $rank: {} }
-				}
-			}
-		}
-	];
-	const normalized = normalizeAssistantAggregatePipeline(pipeline as any, 'production-deliveries');
-	const rankStage = normalized?.[0]?.$setWindowFields;
-	const sortBy = rankStage?.sortBy || {};
-	const keys = Object.keys(sortBy);
-	assert(keys.length === 1, 'Expected rank sortBy to be normalized to exactly one key');
-	assert(keys[0] === 'total_by_driver', 'Expected first sortBy key to be preserved for rank');
-	assert(sortBy.total_by_driver === -1, 'Expected rank sort direction to be preserved');
-}
-
-function testNormalizeAssistantAggregatePipelineMovesLastNLimitBeforeGroup() {
-	const pipeline = [
-		{
-			$match: {
-				date_created: {
-					$gte: new Date('2026-02-09T00:00:00.000Z'),
-					$lt: new Date('2026-02-10T00:00:00.000Z')
-				}
-			}
-		},
-		{
-			$group: {
-				_id: '$status',
-				count: { $sum: 1 }
-			}
-		},
-		{ $sort: { count: -1 } },
-		{ $limit: 20 }
-	];
-	const normalized = normalizeAssistantAggregatePipeline(
-		pipeline as any,
-		'maintenance-orders',
-		'Show me the last 20 work orders created this week, grouped by status.'
-	);
-	const groupIndex = normalized.findIndex((stage: any) => !!stage?.$group);
-	const limitIndex = normalized.findIndex((stage: any) => typeof stage?.$limit === 'number');
-	const sortIndex = normalized.findIndex((stage: any) => !!stage?.$sort && stage.$sort.date_created === -1);
-	assert(groupIndex > -1, 'Expected group stage to remain in pipeline');
-	assert(limitIndex > -1, 'Expected limit stage to exist');
-	assert(sortIndex > -1, 'Expected created-date sort stage to be added before grouping');
-	assert(limitIndex < groupIndex, 'Expected record limit to be applied before grouping');
-	assert(sortIndex < limitIndex, 'Expected record sort to happen before record limit');
-	assert((normalized[limitIndex] as any).$limit === 20, 'Expected requested record limit to be preserved');
-}
-
-function testNormalizeAssistantAggregatePipelineKeepsTrendGroupingLimitAfterGroup() {
-	const pipeline = [
-		{
-			$match: {
-				date_invoice: {
-					$gte: new Date('2025-08-01T00:00:00.000Z'),
-					$lt: new Date('2026-02-01T00:00:00.000Z')
-				}
-			}
-		},
-		{
-			$group: {
-				_id: {
-					$dateToString: {
-						format: '%Y-%m',
-						date: '$date_invoice'
-					}
-				},
-				total: { $sum: '$grand_total' }
-			}
-		},
-		{ $sort: { _id: 1 } },
-		{ $limit: 20 }
-	];
-	const normalized = normalizeAssistantAggregatePipeline(
-		pipeline as any,
-		'invoices',
-		'Break down total revenue over the last 6 months by month.'
-	);
-	const groupIndex = normalized.findIndex((stage: any) => !!stage?.$group);
-	const limitIndex = normalized.findIndex((stage: any) => typeof stage?.$limit === 'number');
-	assert(groupIndex > -1, 'Expected group stage to remain in trend pipeline');
-	assert(limitIndex > groupIndex, 'Expected trend/month grouping limit to remain post-group');
-}
-
-function testBuildAssistantToolRequestRestoresMongoSafeDirectiveKeys() {
-	const request = buildAssistantToolRequest({
-		type: 'aggregate',
-		payload: {
-			collection: 'customers',
-			pipeline: [
-				{
-					_dollar_match: {
-						'customer__dot__name': 'Acme',
-						total: { _dollar_gt: 0 }
-					}
-				}
-			]
-		},
-		cleaned: '',
-		rawLine: 'REPORT_BUILDER_AGG: {}'
-	} as any, {
-		message: 'Show active clients'
-	} as any);
-	assert(request?.pipeline?.[0]?.$match, 'Expected Mongo-safe stage keys to restore to $ operators');
-	assert(
-		request?.pipeline?.[0]?.$match?.['customer.name'] === 'Acme',
-		'Expected Mongo-safe dotted field names to restore before tool execution'
-	);
-	assert(
-		request?.pipeline?.[0]?.$match?.total?.$gt === 0,
-		'Expected nested Mongo-safe operators to restore before tool execution'
-	);
-}
-
-function testRepairAssistantFieldPathReferenceInPipelineUsesGetFieldForDottedPath() {
-	const pipeline = [
-		{
-			$addFields: {
-				volume_unit: '$blend_chemicals.unit',
-				volume_value: '$blend_chemicals.containers.quantity'
-			}
-		}
-	];
-	const repaired = repairAssistantFieldPathReferenceInPipeline(pipeline as any, 'blend_chemicals.unit');
-	assert(repaired.changed, 'Expected dotted field-path references to be rewritten');
-	const unitExpr = repaired.pipeline?.[0]?.$addFields?.volume_unit;
-	assert(!!unitExpr?.$getField, 'Expected volume_unit to use $getField expression');
-	assert(unitExpr?.$getField?.field === 'unit', 'Expected final $getField segment to target unit');
-	assert(unitExpr?.$getField?.input === '$blend_chemicals', 'Expected $getField input to be blend_chemicals root');
-	const quantityExpr = repaired.pipeline?.[0]?.$addFields?.volume_value;
-	assert(
-		quantityExpr === '$blend_chemicals.containers.quantity',
-		'Expected non-targeted field path references to remain unchanged'
-	);
-}
-
-function testRepairAssistantPositionalPathSegmentsInPipeline() {
-	const pipeline = [
-		{
-			$match: {
-				'routes.$.date_needed.date': {
-					$gte: new Date('2026-02-16T00:00:00.000Z')
-				}
-			}
-		},
-		{
-			$group: {
-				_id: '$routes.$.id_location',
-				count: { $sum: 1 }
-			}
-		},
-		{
-			$sort: {
-				'_id.routes.$.id_location': 1
-			}
-		},
-		{
-			$project: {
-				route_date: '$routes.$.date_needed.date'
-			}
-		}
-	];
-	const repaired = repairAssistantPositionalPathSegmentsInPipeline(pipeline as any);
-	assert(repaired.changed, 'Expected positional path segments to be repaired');
-	const matchKeys = Object.keys(repaired.pipeline?.[0]?.$match || {});
-	assert(
-		matchKeys.includes('routes.date_needed.date'),
-		'Expected positional $ segment to be removed from match field'
-	);
-	assert(
-		!matchKeys.includes('routes.$.date_needed.date'),
-		'Expected legacy positional match field to be removed'
-	);
-	assert(
-		repaired.pipeline?.[1]?.$group?._id === '$routes.id_location',
-		'Expected positional $ segment to be removed from field reference'
-	);
-	assert(
-		Object.prototype.hasOwnProperty.call(repaired.pipeline?.[2]?.$sort || {}, '_id.routes.id_location'),
-		'Expected positional $ segment to be removed from sort key'
-	);
-	assert(
-		repaired.pipeline?.[3]?.$project?.route_date === '$routes.date_needed.date',
-		'Expected positional $ segment to be removed from projection field reference'
-	);
-}
-
-function testRepairAssistantFieldPathReferenceInPipelineSkipsUndottedPath() {
-	const pipeline = [
-		{
-			$addFields: {
-				volume_unit: '$volume_unit'
-			}
-		}
-	];
-	const repaired = repairAssistantFieldPathReferenceInPipeline(pipeline as any, 'volume_unit');
-	assert(!repaired.changed, 'Expected non-dotted field path to remain unchanged');
-	assert(
-		repaired.pipeline?.[0]?.$addFields?.volume_unit === '$volume_unit',
-		'Expected original reference to be preserved'
-	);
-}
-
-function testShouldUseAssistantNavigationFastPath() {
-	assert(
-		shouldUseAssistantNavigationFastPath('What is the route link for invoice list?', false),
-		'Expected route-link request to use navigation fast path'
-	);
-	assert(
-		!shouldUseAssistantNavigationFastPath('How many invoices were paid this month?', false),
-		'Expected data-count request to skip navigation fast path'
-	);
-	assert(
-		!shouldUseAssistantNavigationFastPath('What changed on this page?', false),
-		'Expected change-history prompt to skip navigation fast path'
-	);
-	assert(
-		!shouldUseAssistantNavigationFastPath('How long has the exception list been on this page?', false),
-		'Expected "how long on this page" prompt to skip navigation fast path'
-	);
-	assert(
-		!shouldUseAssistantNavigationFastPath('Why don\'t I see this asset in this dropdown?', false),
-		'Expected bug/issue prompt to skip navigation fast path'
-	);
-	assert(
-		!shouldUseAssistantNavigationFastPath('Route link for invoices', true),
-		'Expected attachments to disable navigation fast path'
-	);
-}
-
-function testRankAssistantNavigationRoutes() {
-	const ranked = rankAssistantNavigationRoutes(
-		'Need the invoice list route link',
-		['/dashboard', '/invoice/list', '/invoice/detail', '/chemical/list'],
-		2
-	);
-	assert(ranked.length === 2, 'Expected ranked route limit to apply');
-	assert(ranked[0] === '/invoice/list', 'Expected invoice list route to rank first');
-}
-
-function testShouldUseAssistantChangeHistoryFastPath() {
-	assert(
-		shouldUseAssistantChangeHistoryFastPath('What changed recently in GitHub?', false),
-		'Expected change-history prompt to use change-history fast path'
-	);
-	assert(
-		shouldUseAssistantChangeHistoryFastPath('When was the last time the invoice document was updated?', false),
-		'Expected "last updated" prompt to use change-history fast path'
-	);
-	assert(
-		shouldUseAssistantChangeHistoryFastPath('When does this dropdown for lease type get added to this page?', false),
-		'Expected "when does this dropdown get added" prompt to use change-history fast path'
-	);
-	assert(
-		shouldUseAssistantChangeHistoryFastPath('What changed on this page?', false),
-		'Expected "what changed on this page" prompt to use change-history fast path'
-	);
-	assert(
-		shouldUseAssistantChangeHistoryFastPath('What changed on the invoice page?', false),
-		'Expected "what changed on the invoice page" prompt to use change-history fast path'
-	);
-	assert(
-		shouldUseAssistantChangeHistoryFastPath('What did the last update just do?', false),
-		'Expected "what did the last update do" prompt to use change-history fast path'
-	);
-	assert(
-		shouldUseAssistantChangeHistoryFastPath('What did the last system update do?', false),
-		'Expected "what did the last system update do" prompt to use change-history fast path'
-	);
-	assert(
-		shouldUseAssistantChangeHistoryFastPath('How long has this been this way?', false),
-		'Expected duration prompt to use change-history fast path'
-	);
-	assert(
-		shouldUseAssistantChangeHistoryFastPath('What is this new exception list? How long has it been around?', false),
-		'Expected "been around" prompt to use change-history fast path'
-	);
-	assert(
-		shouldUseAssistantChangeHistoryFastPath('How long has the exception list been on this page?', false),
-		'Expected "been on this page" prompt to use change-history fast path'
-	);
-	assert(
-		!shouldUseAssistantChangeHistoryFastPath('How many invoices were paid this month?', false),
-		'Expected quantitative data request to skip change-history fast path'
-	);
-	assert(
-		!shouldUseAssistantChangeHistoryFastPath('What changed recently?', true),
-		'Expected attachments to disable change-history fast path'
-	);
-}
-
-function testBuildAssistantChangeHistorySummaryPermissionAware() {
-	const commits = [
-		{
-			date: '2026-02-05T12:00:00.000Z',
-			subject: 'Fix invoice total rounding for customer statements',
-			files: ['server/invoice/report-builder.ts'],
-			modules: ['invoice']
-		},
-		{
-			date: '2026-02-01T12:00:00.000Z',
-			subject: 'Improve work order assignment reliability',
-			files: ['server/work-order/assignment.ts'],
-			modules: ['work_order']
-		}
-	] as any[];
-
-	const invoiceUser = {
-		roles: {
-			super_admin: false,
-			groups: [{ name: 'Accounting', views: ['/invoice/list', '/dashboard'] }],
-			miscs: []
-		},
-		other: {}
-	};
-	const noInvoiceUser = {
-		roles: {
-			super_admin: false,
-			groups: [{ name: 'Field', views: ['/work-order/list'] }],
-			miscs: []
-		},
-		other: {}
-	};
-
-	const detailed = buildAssistantChangeHistorySummaryFromCommits({
-		message: 'What changed in invoices recently?',
-		user: invoiceUser,
-		isSuperAdmin: false,
-		commits,
-		branch: 'main',
-		now: new Date('2026-02-08T00:00:00.000Z')
-	});
-	assert(detailed.reason === 'detailed', 'Expected detailed summary for invoice-permitted user');
-	assert(!detailed.generic, 'Expected detailed summary to be non-generic');
-	assert(detailed.commitCount > 0, 'Expected at least one permitted commit in detailed summary');
-	assert(
-		String(detailed.response || '').includes('Fix invoice total rounding'),
-		'Expected detailed summary to include invoice change subject'
-	);
-
-	const generic = buildAssistantChangeHistorySummaryFromCommits({
-		message: 'What changed in invoices recently?',
-		user: noInvoiceUser,
-		isSuperAdmin: false,
-		commits,
-		branch: 'main',
-		now: new Date('2026-02-08T00:00:00.000Z')
-	});
-	assert(generic.reason === 'generic', 'Expected generic summary for invoice-restricted user');
-	assert(generic.generic, 'Expected generic summary to be marked generic');
-	assert(generic.commitCount === 0, 'Expected generic summary to hide commit details');
-	assert(
-		!String(generic.response || '').includes('Fix invoice total rounding'),
-		'Expected generic summary to redact invoice change subject'
-	);
-}
-
-function testBuildAssistantChangeHistorySummaryDuration() {
-	const workOrderUser = {
-		roles: {
-			super_admin: false,
-			groups: [{ name: 'Operations', views: ['/work-order/list'] }],
-			miscs: []
-		},
-		other: {}
-	};
-	const commits = [
-		{
-			date: '2025-11-15T10:00:00.000Z',
-			subject: 'Adjust work order scheduler defaults',
-			files: ['server/work-order/scheduler.ts'],
-			modules: ['work_order']
-		},
-		{
-			date: '2026-02-06T10:00:00.000Z',
-			subject: 'Fix work order dispatch edge case',
-			files: ['server/work-order/dispatch.ts'],
-			modules: ['work_order']
-		}
-	] as any[];
-	const summary = buildAssistantChangeHistorySummaryFromCommits({
-		message: 'How long has this been this way for work orders?',
-		user: workOrderUser,
-		isSuperAdmin: false,
-		commits,
-		branch: 'main',
-		now: new Date('2026-02-08T00:00:00.000Z')
-	});
-	assert(summary.reason === 'detailed', 'Expected detailed duration summary for permitted module');
-	assert(
-		String(summary.response || '').includes('since at least 2025-11-15'),
-		'Expected duration summary to include oldest known date'
-	);
-}
-
-function testBuildAssistantChangeHistorySummaryFeatureKeywordScoping() {
-	const commits = [
-		{
-			date: '2026-02-08T12:00:00.000Z',
-			subject: 'Improve deploy queue resiliency for worker restarts',
-			files: ['server/deploy/queue.ts'],
-			modules: ['general']
-		},
-		{
-			date: '2025-09-01T12:00:00.000Z',
-			subject: 'Add exception list filtering for deploy instances',
-			files: ['resolveio/angular/app/dashboard/deploy-instance/deploy-instances.component.ts'],
-			modules: ['general']
-		},
-		{
-			date: '2024-01-15T12:00:00.000Z',
-			subject: 'Migrate logging pipeline internals',
-			files: ['server/logging/pipeline.ts'],
-			modules: ['internal']
-		}
-	] as any[];
-
-	const summary = buildAssistantChangeHistorySummaryFromCommits({
-		message: 'What is this new exception list? How long has it been around?',
-		user: { roles: { super_admin: true }, other: {} },
-		isSuperAdmin: true,
-		commits,
-		branch: 'main',
-		now: new Date('2026-02-08T00:00:00.000Z')
-	});
-	assert(summary.reason === 'detailed', 'Expected detailed summary for super admin');
-	assert(
-		String(summary.response || '').includes('since at least 2025-09-01'),
-		'Expected duration summary to scope oldest date to exception-list related history'
-	);
-	assert(
-		!String(summary.response || '').includes('since at least 2024-01-15'),
-		'Expected duration summary to avoid unrelated older commit history'
-	);
-}
-
-function testBuildAssistantChangeHistorySummaryLibraryRepoKeepsDatesButRedactsDetails() {
-	const commits = [
-		{
-			date: '2026-01-15T12:00:00.000Z',
-			subject: 'Refactor invoice aggregation fallback logic',
-			files: ['src/methods/ai-terminal.ts'],
-			modules: ['invoice']
-		}
-	] as any[];
-	const summary = buildAssistantChangeHistorySummaryFromCommits({
-		message: 'What changed recently in invoices?',
-		user: { roles: { super_admin: true }, other: {} },
-		isSuperAdmin: true,
-		commits,
-		branch: 'main',
-		repositoryName: 'resolveio-server-lib',
-		now: new Date('2026-02-08T00:00:00.000Z')
-	});
-	assert(summary.reason === 'detailed', 'Expected detailed summary to remain available for library repos');
-	assert(
-		String(summary.response || '').includes('2026-01-15'),
-		'Expected library summary to retain date visibility'
-	);
-	assert(
-		!String(summary.response || '').includes('Refactor invoice aggregation fallback logic'),
-		'Expected library summary to redact low-level implementation details'
-	);
-	assert(
-		String(summary.response || '').includes('Platform/library update'),
-		'Expected library summary to use high-level library wording'
-	);
-}
-
-async function testResolveAssistantReportBuilderBridgeCollectionModeAndPath() {
-	const originalGetMongoManager = (ResolveIOServer as any).getMongoManager;
-	try {
-		(ResolveIOServer as any).getMongoManager = () => ({
-			collection: (name: string) => (name === 'report-orders' ? { useRB: true } : {})
-		});
-		const rbPreferred = await resolveAssistantReportBuilderBridgeCollection('orders');
-		assert(rbPreferred.collection === 'report-orders', 'Expected report collection selection when useRB is available');
-		assert(rbPreferred.mode === 'report-builder', 'Expected report-builder mode when useRB is available');
-		assert(
-			Array.isArray(rbPreferred.resolutionPath)
-			&& rbPreferred.resolutionPath.some(step => String(step).includes('manager.useRB:report-orders')),
-			'Expected bridge resolution path to include manager.useRB step'
-		);
-
-		(ResolveIOServer as any).getMongoManager = () => ({
-			collection: (_name: string) => ({})
-		});
-		const fakeDb = {
-			listCollections: (filter?: Record<string, any>) => ({
-				toArray: async () => {
-					const name = String(filter?.name || '');
-					if (!name) {
-						return [{ name: 'orders' }];
-					}
-					return name === 'orders' ? [{ name: 'orders' }] : [];
-				}
-			})
-		};
-		const directFallback = await resolveAssistantReportBuilderBridgeCollection('orders', fakeDb as any, 'resolveio');
-		assert(directFallback.collection === 'orders', 'Expected direct fallback to keep base collection');
-		assert(directFallback.mode === 'direct-mongo', 'Expected direct-mongo mode when RB is unavailable');
-		assert(
-			Array.isArray(directFallback.resolutionPath)
-			&& directFallback.resolutionPath.some(step => String(step).includes('db.exists:orders')),
-			'Expected bridge resolution path to include db existence fallback'
-		);
-	}
-	finally {
-		(ResolveIOServer as any).getMongoManager = originalGetMongoManager;
-	}
-}
-
-async function testResolveAssistantReportBuilderBridgeCollectionPreservesConfiguredCollection() {
-	const originalGetMongoManager = (ResolveIOServer as any).getMongoManager;
-	try {
-		(ResolveIOServer as any).getMongoManager = () => ({
-			collections: () => [
-				{ collectionName: 'work-order-dynamics' },
-				{ collectionName: 'production-sales-orders' }
-			],
-			collection: (_name: string) => ({})
-		});
-		const fakeDb = {
-			listCollections: (filter?: Record<string, any>) => ({
-				toArray: async () => {
-					const name = String(filter?.name || '');
-					if (!name) {
-						return [{ name: 'production-sales-orders' }];
-					}
-					return name === 'production-sales-orders' ? [{ name }] : [];
-				}
-			})
-		};
-		const resolved = await resolveAssistantReportBuilderBridgeCollection(
-			'work-order-dynamics',
-			fakeDb as any,
-			'resolveio',
-			{
-				requestHints: {
-					collectionHints: ['work-order-dynamics', 'production-sales-orders'],
-					rankedCollections: ['production-sales-orders', 'work-order-dynamics']
-				} as any
-			}
-		);
-		assert(
-			resolved.collection === 'work-order-dynamics',
-			'Expected configured work-order collection to win over neighboring DB-listed collections'
-		);
-		assert(resolved.mode === 'direct-mongo', 'Expected configured collection fallback to use direct-mongo mode');
-		assert(
-			Array.isArray(resolved.resolutionPath)
-			&& resolved.resolutionPath.some(step => String(step).includes('manager.configured:work-order-dynamics')),
-			'Expected bridge resolution path to include manager.configured step'
-		);
-	}
-	finally {
-		(ResolveIOServer as any).getMongoManager = originalGetMongoManager;
-	}
-}
-
-async function testResolveAssistantReportBuilderBridgeCollectionPreservesPrimaryHintCollection() {
-	const originalGetMongoManager = (ResolveIOServer as any).getMongoManager;
-	try {
-		(ResolveIOServer as any).getMongoManager = () => ({
-			collections: () => [],
-			collection: (_name: string) => ({})
-		});
-		const fakeDb = {
-			listCollections: (filter?: Record<string, any>) => ({
-				toArray: async () => {
-					const name = String(filter?.name || '');
-					if (!name) {
-						return [{ name: 'production-sales-orders' }];
-					}
-					return name === 'production-sales-orders' ? [{ name }] : [];
-				}
-			})
-		};
-		const resolved = await resolveAssistantReportBuilderBridgeCollection(
-			'work-order-dynamics',
-			fakeDb as any,
-			'resolveio',
-			{
-				requestHints: {
-					collectionHints: ['work-order-dynamics', 'jobs', 'production-sales-orders'],
-					rankedCollections: ['production-sales-orders', 'work-order-dynamics']
-				} as any
-			}
-		);
-		assert(
-			resolved.collection === 'work-order-dynamics',
-			'Expected primary collection hint to prevent bridge fallback to neighboring collections'
-		);
-		assert(
-			Array.isArray(resolved.resolutionPath)
-			&& resolved.resolutionPath.some(step => String(step).includes('hints.primary:work-order-dynamics')),
-			'Expected bridge resolution path to include primary hint preservation'
-		);
-	}
-	finally {
-		(ResolveIOServer as any).getMongoManager = originalGetMongoManager;
-	}
-}
-
-async function testResolveAssistantCollectionNameMergesConfiguredCollectionsIntoFreshCache() {
-	const originalGetMongoManager = (ResolveIOServer as any).getMongoManager;
-	const fakeDb = {
-		listCollections: (filter?: Record<string, any>) => ({
-			toArray: async () => {
-				const name = String(filter?.name || '');
-				if (!name) {
-					return [{ name: 'production-sales-orders' }];
-				}
-				return name === 'production-sales-orders' ? [{ name }] : [];
-			}
-		})
-	};
-	try {
-		(ResolveIOServer as any).getMongoManager = () => ({
-			collections: () => [],
-			collection: (_name: string) => ({})
-		});
-		const dbName = 'resolveio-cache-test-configured-collections';
-		const cachedBeforeManager = await resolveAssistantCollectionNameForTesting(
-			fakeDb as any,
-			dbName,
-			'work-order-dynamics',
-			'snf'
-		);
-		assert(
-			cachedBeforeManager.name === 'work-order-dynamics'
-			&& cachedBeforeManager.matched === false
-			&& cachedBeforeManager.candidates.includes('production-sales-orders'),
-			'Expected initial sparse DB cache to miss configured work-order collection while retaining neighboring candidates'
-		);
-
-		(ResolveIOServer as any).getMongoManager = () => ({
-			collections: () => [
-				{ collectionName: 'work-order-dynamics' },
-				{ collectionName: 'production-sales-orders' }
-			],
-			collection: (_name: string) => ({})
-		});
-		const resolvedAfterManager = await resolveAssistantCollectionNameForTesting(
-			fakeDb as any,
-			dbName,
-			'work-order-dynamics',
-			'snf'
-		);
-		assert(
-			resolvedAfterManager.name === 'work-order-dynamics',
-			'Expected configured manager collection to be merged into fresh collection cache'
-		);
-		assert(resolvedAfterManager.matched === true, 'Expected configured collection to be treated as matched');
-	}
-	finally {
-		(ResolveIOServer as any).getMongoManager = originalGetMongoManager;
-	}
-}
-
-async function testResolveAssistantReportBuilderBridgeCollectionUsesBlendHintsWithoutCrossDomainFallback() {
-	const originalGetMongoManager = (ResolveIOServer as any).getMongoManager;
-	const buildFakeDb = (collections: string[]) => ({
-		listCollections: (filter?: Record<string, any>) => ({
-			toArray: async () => {
-				const name = String(filter?.name || '');
-				if (!name) {
-					return collections.map(collectionName => ({ name: collectionName }));
-				}
-				return collections.includes(name) ? [{ name }] : [];
-			}
-		})
-	});
-	const blendHints = {
-		collectionHints: ['chemical-blends', 'support-tickets'],
-		rankedCollections: ['support-tickets', 'chemical-blends'],
-		fieldHints: ['Field hints (chemical-blends): blend_name, chemical_recipe_quantity'],
-		schemaHints: ['Schema hints (chemical-blends): fields: blend_name, quantity']
-	};
-	try {
-		(ResolveIOServer as any).getMongoManager = () => ({
-			collection: (_name: string) => ({})
-		});
-
-		const resolvedBlend = await resolveAssistantReportBuilderBridgeCollection(
-			'blend-tickets',
-			buildFakeDb(['support-tickets', 'chemical-blends']) as any,
-			'resolveio',
-			{ requestHints: blendHints as any }
-		);
-		assert(
-			resolvedBlend.collection === 'chemical-blends',
-			'Expected blend hints to resolve bridge collection to chemical-blends when available'
-		);
-		assert(
-			resolvedBlend.mode === 'direct-mongo',
-			'Expected blend hint fallback to use direct-mongo mode when RB is unavailable'
-		);
-
-		let threwMissingBlend = false;
-		try {
-			await resolveAssistantReportBuilderBridgeCollection(
-				'blend-tickets',
-				buildFakeDb(['support-tickets']) as any,
-				'resolveio',
-				{ requestHints: blendHints as any }
-			);
-		}
-		catch (error: any) {
-			threwMissingBlend = String(error?.message || '')
-				.includes('No queryable collection could be resolved');
-		}
-		assert(
-			threwMissingBlend,
-			'Expected blend ticket requests to fail when no blend collection exists'
-		);
-	}
-	finally {
-		(ResolveIOServer as any).getMongoManager = originalGetMongoManager;
-	}
-}
-
-function testBuildAssistantSchemaHintsIncludesFieldsAndLookups() {
-	const originalGetMongoManager = (ResolveIOServer as any).getMongoManager;
-	try {
-		(ResolveIOServer as any).getMongoManager = () => ({
-			collection: (name: string) => {
-				if (name !== 'work-orders') {
-					return {};
-				}
-				return {
-					simplschema: {
-						schema: () => ({
-							status: { type: String },
-							date_created: { type: Date },
-							id_customer: { type: String }
-						})
-					},
-					rbSchema: {
-						id_customer: {
-							lookup_collection: 'customers',
-							local_key: 'id_customer',
-							lookup_key: '_id'
-						}
-					}
-				};
-			}
-		});
-		const hints = buildAssistantSchemaHints(['work-orders'], {
-			maxCollections: 1,
-			maxFields: 8,
-			maxLookups: 4
-		});
-		assert(hints.length === 1, 'Expected a single schema hint line');
-		assert(hints[0].includes('Schema hints (work-orders):'), 'Expected schema hint collection label');
-		assert(hints[0].includes('fields:'), 'Expected schema fields section');
-		assert(hints[0].includes('report-builder lookups:'), 'Expected lookup section');
-		assert(
-			hints[0].includes('id_customer->customers._id'),
-			'Expected lookup mapping details in schema hints'
-		);
-	}
-	finally {
-		(ResolveIOServer as any).getMongoManager = originalGetMongoManager;
-	}
-}
-
-async function testBuildAssistantToolRequestHintsAndReadDebugBridgeResolution() {
-	const request = buildAssistantToolRequest(
-		{
-			type: 'read',
-			payload: {
-				collection: 'orders',
-				query: { status: 'Open' }
-			},
-			cleaned: '',
-			rawLine: 'REPORT_BUILDER_READ: {"collection":"orders"}'
-		} as any,
-		{
-			id_client: 'client-1',
-			mongo: {
-				database: 'resolveio',
-				databases: ['resolveio'],
-				access: 'read'
-			}
-		} as any,
-		{
-			collectionHints: ['orders', 'orders'],
-			rankedCollections: ['orders', 'report-orders'],
-			fieldHints: ['Field hints (orders): status', 'Field hints (orders): status'],
-			schemaHints: ['Schema hints (orders): fields: status', 'Schema hints (orders): fields: status']
-		}
-	);
-	assert(!!request.__assistantHints, 'Expected normalized assistant hints to be attached');
-	assert(
-		Array.isArray(request.__assistantHints.collectionHints)
-		&& request.__assistantHints.collectionHints.length === 1,
-		'Expected collection hints to be deduplicated'
-	);
-	assert(
-		Array.isArray(request.__assistantHints.schemaHints)
-		&& request.__assistantHints.schemaHints.length === 1,
-		'Expected schema hints to be deduplicated'
-	);
-
-	const originalGetMongoManager = (ResolveIOServer as any).getMongoManager;
-	const originalGetMongoConnection = (ResolveIOServer as any).getMongoConnection;
-	const originalGetServerConfig = (ResolveIOServer as any).getServerConfig;
-	const originalUsersCollection = (UserCollection as any).Users;
-	try {
-		(UserCollection as any).Users = {
-			findById: async (_id: string) => ({
-				_id: 'user-1',
-				username: 'admin',
-				roles: {
-					super_admin: true,
-					groups: [],
-					miscs: []
-				},
-				other: {}
-			})
-		};
-		(ResolveIOServer as any).getServerConfig = () => ({
-			DATABASE: 'resolveio'
-		});
-		(ResolveIOServer as any).getMongoManager = () => ({
-			getWatchedDatabases: () => ['resolveio'],
-			collection: (_name: string) => ({})
-		});
-		const fakeDb = {
-			listCollections: (filter?: Record<string, any>) => ({
-				toArray: async () => {
-					const name = String(filter?.name || '');
-					if (!name) {
-						return [{ name: 'orders' }];
-					}
-					return name === 'orders' ? [{ name: 'orders' }] : [];
-				}
-			}),
-			collection: (_name: string) => ({
-				find: (_query: Record<string, any>, _options: Record<string, any>) => ({
-					toArray: async () => [{ _id: 'order-1', name: 'Order Alpha', status: 'Open' }]
-				}),
-				countDocuments: async (_query: Record<string, any>) => 1
-			})
-		};
-		(ResolveIOServer as any).getMongoConnection = () => ({
-			db: (_dbName: string) => fakeDb
-		});
-
-		const readResult = await executeAiAssistantMongoRead({
-			collection: 'orders',
-			query: { status: 'Open' },
-			options: { limit: 1 },
-			permissionView: '/order/list',
-			mongo: {
-				database: 'resolveio',
-				databases: ['resolveio'],
-				access: 'read'
-			},
-			__assistantHints: {
-				collectionHints: ['orders'],
-				schemaHints: ['Schema hints (orders): fields: status']
-			}
-		} as any, { id_user: 'user-1' });
-		assert(readResult?.debug?.bridge === 'direct-mongo', 'Expected direct-mongo bridge mode in debug payload');
-		assert(
-			readResult?.debug?.bridgeResolution?.mode === 'direct-mongo',
-			'Expected bridgeResolution mode to be direct-mongo in debug payload'
-		);
-		assert(
-			readResult?.debug?.requestHints?.collectionHints?.[0] === 'orders',
-			'Expected debug payload to include request hint metadata'
-		);
-	}
-	finally {
-		(ResolveIOServer as any).getMongoManager = originalGetMongoManager;
-		(ResolveIOServer as any).getMongoConnection = originalGetMongoConnection;
-		(ResolveIOServer as any).getServerConfig = originalGetServerConfig;
-		(UserCollection as any).Users = originalUsersCollection;
-	}
-}
-
-async function testExecuteAiAssistantMongoAggregateFallsBackWithinCollectionForMissingActiveFields() {
-	const originalGetMongoManager = (ResolveIOServer as any).getMongoManager;
-	const originalGetMongoConnection = (ResolveIOServer as any).getMongoConnection;
-	const originalGetServerConfig = (ResolveIOServer as any).getServerConfig;
-	const originalUsersCollection = (UserCollection as any).Users;
-	const aggregateCalls: string[] = [];
-	try {
-		(UserCollection as any).Users = {
-			findById: async (_id: string) => ({
-				_id: 'user-1',
-				username: 'admin',
-				roles: {
-					super_admin: true,
-					groups: [],
-					miscs: []
-				},
-				other: {}
-			})
-		};
-		(ResolveIOServer as any).getServerConfig = () => ({
-			DATABASE: 'resolveio'
-		});
-		(ResolveIOServer as any).getMongoManager = () => ({
-			getWatchedDatabases: () => ['resolveio'],
-			collection: (_name: string) => ({})
-		});
-		const fakeDb = {
-			listCollections: (filter?: Record<string, any>) => ({
-				toArray: async () => {
-					const name = String(filter?.name || '');
-					const collections = ['customers', 'support-tickets'];
-					if (!name) {
-						return collections.map(collectionName => ({ name: collectionName }));
-					}
-					return collections.includes(name) ? [{ name }] : [];
-				}
-			}),
-			collection: (name: string) => ({
-				find: (_query: Record<string, any>) => ({
-					toArray: async () => {
-						if (name === 'customers') {
-							return [{ _id: 'customer-1', name: 'Acme', state: 'Texas' }];
-						}
-						return [];
-					}
-				}),
-				aggregate: (pipeline: Array<Record<string, any>>) => ({
-					toArray: async () => {
-						aggregateCalls.push(name);
-						if (name !== 'customers') {
-							return [{ active_clients: 334 }];
-						}
-						const matchStage = pipeline.find(stage => stage?.$match && typeof stage.$match === 'object');
-						const matchText = JSON.stringify(matchStage?.$match || {});
-						const hasActiveFilters = /\"(status|state|active|is_active|isactive|enabled|is_enabled|isenabled)\"/.test(matchText);
-						return hasActiveFilters ? [] : [{ active_clients: 476 }];
-					}
-				}),
-				countDocuments: async () => 0
-			})
-		};
-		(ResolveIOServer as any).getMongoConnection = () => ({
-			db: (_dbName: string) => fakeDb
-		});
-
-		const aggregateResult = await executeAiAssistantMongoAggregate({
-			collection: 'customers',
-			permissionView: '/client/list',
-			pipeline: [
-				{
-					$match: {
-						$and: [
-							{
-								$or: [
-									{ active: true },
-									{ is_active: true },
-									{ isactive: true },
-									{ enabled: true },
-									{ is_enabled: true },
-									{ isenabled: true },
-									{ status: { $regex: '^active$', $options: 'i' } },
-									{ state: { $regex: '^active$', $options: 'i' } }
-								]
-							}
-						]
-					}
-				},
-				{
-					$group: {
-						_id: null,
-						active_clients: { $sum: 1 }
-					}
-				},
-				{
-					$project: {
-						_id: 0,
-						active_clients: 1
-					}
-				}
-			],
-			options: {
-				allowDiskUse: true,
-				limit: 1
-			},
-			mongo: {
-				database: 'resolveio',
-				databases: ['resolveio'],
-				access: 'read'
-			}
-		} as any, { id_user: 'user-1' });
-
-		assert(
-			Array.isArray(aggregateResult?.documents) && aggregateResult.documents[0]?.active_clients === 476,
-			'Expected missing active-field aggregate fallback to stay on the requested collection and count all matching records'
-		);
-		assert(
-			aggregateResult?.debug?.fallbacks?.activeStatus?.used === true,
-			'Expected aggregate debug payload to record activeStatus fallback usage'
-		);
-		assert(
-			!aggregateCalls.includes('support-tickets'),
-			'Expected active-status aggregate fallback to avoid cross-collection retry'
-		);
-	}
-	finally {
-		(ResolveIOServer as any).getMongoManager = originalGetMongoManager;
-		(ResolveIOServer as any).getMongoConnection = originalGetMongoConnection;
-		(ResolveIOServer as any).getServerConfig = originalGetServerConfig;
-		(UserCollection as any).Users = originalUsersCollection;
-	}
-}
-
-async function run() {
-	testDirectiveParsing();
-	testReportBuilderDirectiveParsing();
-	testFlattenForTable();
-	testDisplayTableDefaults();
-	testSerializeMongoValue();
-	testDisplayMarkdownTable();
-	testAssistantToolFallbackResponseIncludesUsefulLeadSummary();
-	testAssistantToolFallbackResponseExplainsZeroRows();
-	testBuildAssistantAnswerQualityFromExecution();
-	testAssistantZeroRowDisplayDoesNotAppendSyntheticTable();
-	testDisplayMarkdownTableDefaultsToShortDateFormat();
-	testDeriveAssistantCommandExecutionStatus();
-	testResolveCodexThoughtLevelPolicy();
-	testAssistantSystemPromptAllowsWorkspaceDebuggingAndFixes();
-	testAssistantGuardrailsAllowInternalEngineeringRequests();
-	testBuildAssistantWorkspaceRootCandidates();
-	testShouldRunAssistantPlannerPolicy();
-	testAssistantAppHeuristicRegistryTermHintsAndDeterministicEnablement();
-	testAssistantAppHeuristicRegistryLoadsRelativeFileFromParityServerDir();
-	testAssistantCoreHeuristicsStayPlatformScoped();
-	testAssistantAppHeuristicsCanOwnDomainCollectionHints();
-	testAssistantAppDataIntentsResolveSnfDomainRequests();
-	testAssistantRemovedDomainHeuristicIdsRemainAppSpecific();
-	testAssistantHeuristicBlendIdsRemainAppSpecific();
-	testShouldEnforceAssistantDatedDirectiveSkipsWindowedRankingRequests();
-	testShouldEnforceAssistantDatedDirectiveForExplicitTemporalBreakdown();
-	testShouldEnforceAssistantDatedDirectiveForPlannerTemporalGroupBy();
-	testBuildAssistantDatedPivotDisplayWithYearMonthAndCustomer();
-	testBuildAssistantDatedPivotDisplayWithoutDimensionCreatesMetricGrid();
-	testBuildAssistantInvoiceCustomerLabelExprIncludesClientFallbacks();
-	testResolveAssistantReadDisplayMaxRows();
-	testResolveAssistantCollectionOverrideKeepsSpecificOrdersCollection();
-	testResolveAssistantCollectionOverrideStillAppliesForUnrelatedCollection();
-	testResolveAssistantCollectionOverrideSkipsBorderlineGapForWorkOrderRanking();
-	testResolveAssistantCollectionOverrideKeepsWorkOrderCollectionWhenOrdersScoresHigher();
-	testResolveCollectionOverrideWithContextRespectsPermissionRouteHints();
-	testResolveCollectionOverrideWithContextUsesSpecificPermissionRouteCollection();
-	testResolveCollectionOverrideWithContextUsesOrderedCollectionHints();
-	testResolveCollectionOverrideWithContextPreservesPrimaryCollectionHint();
-	testResolveCollectionOverrideWithContextKeepsRouteMatchedJobsOverChemicalHint();
-	testResolveCollectionOverrideWithContextPreservesJobDomainDetailCollections();
-	testResolveCollectionOverrideWithContextKeepsCompetitiveRootCollectionHint();
-	testShouldPreserveAssistantProbeCollectionForPrimaryHintAndRoute();
-	testResolveCollectionOverrideWithContextStillOverridesWithoutRouteHints();
-	testResolveAssistantCrossCollectionFallbackCandidatesForOrders();
-	testResolveAssistantCrossCollectionFallbackCandidatesForWorkOrderDynamics();
-	testResolveAssistantCrossCollectionFallbackCandidatesForUnknownCollection();
-	testResolveAssistantCrossCollectionFallbackCandidatesForTimeEntries();
-	testResolveAssistantAvailableCrossCollectionFallbacksFromNamesUsesSimilarityRanking();
-	testResolveAssistantAvailableCrossCollectionFallbacksFromNamesSkipsCurrentFamilyOnlyMatch();
-	testResolveAssistantCrossCollectionFallbackCandidatesForSupportAlias();
-	testShouldAcceptAssistantFallbackDocumentsRejectsBlankDimensionRows();
-	testShouldAcceptAssistantFallbackDocumentsAcceptsNamedDimensions();
-	testShouldAcceptAssistantFallbackDocumentsAcceptsMetricOnlyRows();
-	testDisplayMarkdownInvoiceNumbersAndCountsStayNumeric();
-	testDisplayMarkdownCurrencyColumnsStillUseCurrencyFormat();
-	testDisplayMarkdownKeepsAlphanumericBlendAndChemicalNames();
-	testDisplayTableCoalescesStringVariantFields();
-	testDisplayTableCoalescesEquivalentCreatedDateFields();
-	testDisplayTableKeepsDistinctCreatedDateAndDateFields();
-	testStripQueryFieldPathsDeep();
-	testResolveReadMultiTermJobRegexFallbackForTesting();
-	testNormalizeIdsForTargetField();
-	testRewriteEmbeddedMatchObjects();
-	testRewriteMatchExpressionsToExpr();
-	testRewriteMatchExpressionsToExprCompactNowToken();
-	testNormalizeAssistantNowExprPlaceholdersDateArithmeticArgs();
-	testNormalizeAssistantNowExprPlaceholdersDateArithmeticUnknownKeyAsStartDate();
-	testNormalizeAssistantNowExprPlaceholdersDateArithmeticUnknownKeyAsAmount();
-	testNormalizeAssistantMonthlyCalendarWindowPipelineConvertsRollingMonthlyRange();
-	testNormalizeAssistantMonthlyCalendarWindowPipelineSkipsDailyGrouping();
-	testExpandAggregateDateMatchFallbackExpandsNestedOrClauses();
-	testNormalizeAssistantAggregatePipelineRankSortBySingleKey();
-	testNormalizeAssistantAggregatePipelineMovesLastNLimitBeforeGroup();
-	testNormalizeAssistantAggregatePipelineKeepsTrendGroupingLimitAfterGroup();
-	testBuildAssistantToolRequestRestoresMongoSafeDirectiveKeys();
-	testRepairAssistantPositionalPathSegmentsInPipeline();
-	testRepairAssistantFieldPathReferenceInPipelineUsesGetFieldForDottedPath();
-	testRepairAssistantFieldPathReferenceInPipelineSkipsUndottedPath();
-	testShouldUseAssistantNavigationFastPath();
-	testRankAssistantNavigationRoutes();
-	testShouldUseAssistantChangeHistoryFastPath();
-	testBuildAssistantChangeHistorySummaryPermissionAware();
-	testBuildAssistantChangeHistorySummaryDuration();
-	testBuildAssistantChangeHistorySummaryFeatureKeywordScoping();
-	testBuildAssistantChangeHistorySummaryLibraryRepoKeepsDatesButRedactsDetails();
-	await testResolveAssistantReportBuilderBridgeCollectionModeAndPath();
-	await testResolveAssistantReportBuilderBridgeCollectionPreservesConfiguredCollection();
-	await testResolveAssistantReportBuilderBridgeCollectionPreservesPrimaryHintCollection();
-	await testResolveAssistantCollectionNameMergesConfiguredCollectionsIntoFreshCache();
-	await testResolveAssistantReportBuilderBridgeCollectionUsesBlendHintsWithoutCrossDomainFallback();
-	testBuildAssistantSchemaHintsIncludesFieldsAndLookups();
-	await testBuildAssistantToolRequestHintsAndReadDebugBridgeResolution();
-	await testExecuteAiAssistantMongoAggregateFallsBackWithinCollectionForMissingActiveFields();
-	console.log('ai assistant utils tests passed');
-}
-
-run()
-	.then(() => {
-		process.exit(process.exitCode ?? 0);
-	})
-	.catch((error) => {
-		console.error(error);
-		process.exit(1);
-	});