@resolveio/server-lib 22.3.221 → 22.3.222

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

@@ -1,4834 +0,0 @@
-import { ObjectId } from 'mongodb';
-import {
-	buildAssistantChangeHistorySummaryFromCommits,
-	buildAssistantSystemPromptForTesting,
-	applyAssistantDisplayTableToResponseForTesting,
-	adjustAssistantClassifiedAppDataIntentForTesting,
-	buildAssistantToolFallbackResponseForTesting,
-	buildAssistantAnswerQualityFromExecution,
-	buildAssistantWorkspaceRootCandidates,
-	buildAssistantDatedPivotDisplay,
-	buildAssistantSchemaHints,
-	buildAssistantToolRequest,
-	deriveAssistantCommandExecutionStatus,
-	evaluateAssistantGuardrailsForTesting,
-	buildAssistantInvoiceCustomerLabelExpr,
-	buildDisplayTable,
-	executeAiAssistantMongoAggregate,
-	executeAiAssistantMongoRead,
-	extractAssistantMongoDirective,
-	expandAssistantFieldTokensForTesting,
-	flattenForTable,
-	formatDisplayTableMarkdown,
-	normalizeAssistantMonthlyCalendarWindowPipeline,
-	normalizeAssistantAggregatePipeline,
-	expandAggregateDateMatchFallbackForTesting,
-	normalizeAssistantNowExprPlaceholders,
-	repairAssistantPositionalPathSegmentsInPipeline,
-	repairAssistantFieldPathReferenceInPipeline,
-	normalizeIdsForTargetField,
-	rankAssistantNavigationRoutes,
-	resolveAssistantCollectionOverride,
-	resolveAssistantCollectionNameForTesting,
-	resolveCollectionOverrideWithContextForTesting,
-	resolveAssistantAvailableCrossCollectionFallbacksFromNames,
-	resolveAssistantAppCollectionHintCandidates,
-	buildAssistantDataRequestClassifierMessagesForTesting,
-	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 testAssistantToolFallbackResponseIncludesRequestedBreakdowns() {
-	const response = buildAssistantToolFallbackResponseForTesting({
-		type: 'mongo_agg',
-		input: { collection: 'chemical-blends' },
-		output: {
-			collection: 'chemical-blends',
-			rowCount: 2,
-			columns: ['Chemical', '2026-06'],
-			display: {
-				columns: ['Chemical', '2026-06'],
-				rows: [
-					{ Chemical: 'NE-227', '2026-06': 7 },
-					{ Chemical: 'ME-350', '2026-06': 4 }
-				],
-				rowCount: 2,
-				truncated: false,
-				includeIds: false
-			},
-			debug: {
-				assumptions: [
-					'Sent means shipped quantity when users ask for delivered chemicals'
-				],
-				requestContract: {
-					requested_breakdowns: [
-						{ type: 'time', requested_text: 'month', granularity: 'month', field_hint: 'date' },
-						{ type: 'entity', requested_text: 'chemical', dimension: 'chemical', field_hints: ['chemical'] }
-					]
-				}
-			}
-		}
-	});
-	assert(
-		response.includes('- Summary breakdown: by month and chemical'),
-		'Expected fallback response to state all requested breakdown dimensions'
-	);
-	assert(
-		response.includes('- Assumptions: Sent means shipped quantity'),
-		'Expected fallback response to include configured assumptions even when rows are returned'
-	);
-}
-
-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'
-	);
-	assert(
-		!prompt.includes('jobs and chemicals sent'),
-		'Expected shared prompt to avoid app-specific root/detail examples'
-	);
-	assert(
-		!prompt.includes('customer, well, or chemical name'),
-		'Expected shared prompt to avoid app-specific entity-name examples'
-	);
-	assert(
-		!prompt.includes('drivers, deliveries, routes, chemicals'),
-		'Expected shared prompt to avoid app-specific array-field examples'
-	);
-	assert(
-		prompt.includes('app-provided domain instructions'),
-		'Expected shared prompt to delegate app-specific array-field rules to app configuration'
-	);
-}
-
-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 testAssistantAppFieldSynonymsStayAppOwned() {
-	const baseProductTokens = expandAssistantFieldTokensForTesting(['product'], 'resolveio');
-	assert(
-		!baseProductTokens.includes('chemical') && !baseProductTokens.includes('blend'),
-		'Expected shared field synonyms to avoid app-domain product mappings'
-	);
-	const baseRevenueTokens = expandAssistantFieldTokensForTesting(['revenue'], 'resolveio');
-	assert(
-		!baseRevenueTokens.includes('paid_total') && !baseRevenueTokens.includes('grand_total'),
-		'Expected shared field synonyms to avoid app-domain revenue total mappings'
-	);
-
-	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: {
-					field_synonyms: {
-						product: ['chemical', 'blend'],
-						revenue: ['paid_total', 'grand_total', 'billing']
-					}
-				}
-			}
-		});
-		const snfProductTokens = expandAssistantFieldTokensForTesting(['product'], 'snf');
-		assert(
-			snfProductTokens.includes('chemical') && snfProductTokens.includes('blend'),
-			'Expected SNF field synonyms to own product-to-chemical/blend mappings'
-		);
-		const snfRevenueTokens = expandAssistantFieldTokensForTesting(['revenue'], 'snf');
-		assert(
-			snfRevenueTokens.includes('paid_total') && snfRevenueTokens.includes('grand_total'),
-			'Expected SNF field synonyms to own revenue total mappings'
-		);
-	}
-	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 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 semanticPath = path.join(heuristicsDir, 'assistant-semantic-manifest.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']
-						}
-					],
-					enabled_deterministic_heuristics: ['app_data_intent'],
-					data_intents: [
-						{
-							id: 'parity_widget_inventory',
-							terms: ['legacy widget trigger phrase'],
-							collection: 'dashboard-widgets',
-							permission_view: '/dashboard/widget-list',
-							date_field: 'date',
-							quantity_field: 'quantity'
-						}
-					]
-				}
-			}
-		}));
-		fs.writeFileSync(semanticPath, JSON.stringify({
-			app_id: 'parityapp',
-			manifest_id: 'parity-semantic-test',
-			semantic_app_data: true,
-			semantic_data_intents: [
-				{
-					id: 'parity_widget_inventory',
-					collection: 'dashboard-widgets',
-					domain: 'widget_inventory',
-					name: 'Widget inventory',
-					description: 'Answers widget stock and on-hand quantities grouped by location or owner.',
-					source_family: 'widget inventory snapshots',
-					workflow_kind: 'inventory_summary',
-					permission_view: '/dashboard/widget-list',
-					date_field: 'date',
-					measures: ['quantity'],
-					entity_types: ['widget', 'location', 'owner'],
-					semantic_only: true
-				}
-			]
-		}));
-		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'
-		);
-		const classifierMessages = buildAssistantDataRequestClassifierMessagesForTesting({
-			message: 'How much widget stock is on hand by location?',
-			appId: 'parityapp',
-			collectionNames: ['dashboard-widgets']
-		});
-		const classifierText = JSON.stringify(classifierMessages);
-		assert(
-			classifierText.includes('Answers widget stock and on-hand quantities grouped by location or owner.'),
-			'Expected companion semantic manifest to overlay the classifier candidate description'
-		);
-		assert(
-			classifierText.includes('semantic_only') && !classifierText.includes('legacy widget trigger phrase'),
-			'Expected semantic-only data intent to avoid exposing legacy trigger terms to the classifier'
-		);
-	}
-	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 testAssistantClassifierWorkflowArbitrationPrefersExplicitWorkOrders() {
-	const workOrderIntent = {
-		id: 'snf_job_chemical_shipments',
-		collection: 'work-order-dynamics',
-		permissionView: '/work-order-dynamic/list',
-		terms: ['work orders', 'work order chemicals', 'shipped chemicals'],
-		quantityField: 'chemicals.shipped.quantity',
-		filterFields: [{ id: 'status', terms: ['status', 'open'], fields: ['status'] }]
-	} as any;
-	const plannedComparisonIntent = {
-		id: 'snf_planned_vs_sent_chemicals',
-		collection: 'jobs',
-		permissionView: '/customer-info/jobs',
-		terms: ['planned vs shipped', 'planned versus sent'],
-		quantityField: 'planned_chemicals.quantity',
-		metricField: 'shipped_quantity',
-		dimensions: [{ id: 'chemical', terms: ['chemical', 'chemicals'] }],
-		filterFields: [{ id: 'chemical', terms: ['chemical', 'chemicals'], fields: ['planned_chemicals.chemical'] }]
-	} as any;
-	const candidates = [
-		{ intent: workOrderIntent, score: 9 },
-		{ intent: plannedComparisonIntent, score: 0 }
-	] as any;
-	const explicitWorkOrders = adjustAssistantClassifiedAppDataIntentForTesting(
-		plannedComparisonIntent,
-		candidates,
-		{ intent_id: 'snf_planned_vs_sent_chemicals' },
-		'Show open work orders with planned or shipped chemicals'
-	);
-	assert(
-		explicitWorkOrders?.id === 'snf_job_chemical_shipments',
-		'Expected explicit work-order requests to keep the work-order workflow even when the text mentions planned chemicals'
-	);
-	const comparison = adjustAssistantClassifiedAppDataIntentForTesting(
-		workOrderIntent,
-		candidates,
-		{ intent_id: 'snf_job_chemical_shipments' },
-		'Compare planned vs shipped chemicals by work order'
-	);
-	assert(
-		comparison?.id === 'snf_planned_vs_sent_chemicals',
-		'Expected comparison wording to continue using the planned-vs-shipped workflow'
-	);
-}
-
-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_ats_driver_pay_summary',
-							terms: [
-								'ats pay',
-								'ats pays',
-								'ats settlement',
-								'ats settlements',
-								'driver pay',
-								'driver settlement',
-								'driver settlements',
-								'settlement payout',
-								'settlement pay'
-							],
-							collection: 'ats-settlements',
-							permission_view: '/ats-settlement/list',
-							date_field: 'date_end',
-							metric_field: 'total_payout',
-							fallback_collections: ['ats-pays', 'wo-type-ats-pays', 'users'],
-							acknowledgement: 'I understand you want an ATS driver pay breakdown for the requested date range. Let me summarize matching settlements.',
-							progress: ['Checking ATS settlements for the requested driver and date range', 'Summarizing payout totals'],
-							assumptions: ['ATS pay means driver settlement payouts from ats-settlements, not invoice billing'],
-							dimensions: {
-								month: {
-									type: 'time',
-									granularity: 'month',
-									terms: ['month', 'months', 'monthly'],
-									group_id: {
-										month: {
-											$dateToString: {
-												format: '%Y-%m',
-												date: '$date_end'
-											}
-										}
-									},
-									project: {
-										month: '$_id.month'
-									},
-									sort: {
-										month: -1
-									}
-								},
-								driver: {
-									terms: ['driver', 'drivers', 'user', 'employee', 'name'],
-									group_id: {
-										id_user: '$id_user',
-										user: '$user'
-									},
-									project: {
-										id_user: '$_id.id_user',
-										user: '$_id.user'
-									},
-									sort: {
-										total_payout: -1,
-										user: 1
-									}
-								},
-								status: {
-									terms: ['status', 'pending approval', 'approved', 'published'],
-									group_id: {
-										status: '$status'
-									},
-									project: {
-										status: '$_id.status'
-									},
-									sort: {
-										total_payout: -1,
-										status: 1
-									}
-								}
-							},
-							filter_fields: {
-								driver: {
-									terms: ['driver', 'drivers', 'user', 'employee', 'name'],
-									fields: ['user', 'id_user']
-								},
-								status: {
-									terms: ['status', 'pending approval', 'approved', 'published'],
-									field: 'status'
-								}
-							},
-							pipeline: [
-								{
-									$match: {
-										date_start: {
-											$gte: '{{date_start}}'
-										},
-										date_end: {
-											$lte: '{{date_end}}'
-										}
-									}
-								},
-								{
-									$group: {
-										_id: {
-											id_user: '$id_user',
-											user: '$user',
-											status: '$status'
-										},
-										settlement_count: { $sum: 1 },
-										load_count: { $sum: { $size: { $ifNull: ['$loads', []] } } },
-										load_payout: { $sum: '$load_payout' },
-										standby_pay: { $sum: '$standby_pay' },
-										total_payout: { $sum: '$total_payout' },
-										first_date_start: { $min: '$date_start' },
-										last_date_end: { $max: '$date_end' },
-										last_date_paid: { $max: '$date_paid' }
-									}
-								},
-								{
-									$project: {
-										_id: 0,
-										id_user: '$_id.id_user',
-										user: '$_id.user',
-										status: '$_id.status',
-										settlement_count: 1,
-										load_count: 1,
-										load_payout: 1,
-										standby_pay: 1,
-										total_payout: 1,
-										first_date_start: 1,
-										last_date_end: 1,
-										last_date_paid: 1
-									}
-								},
-								{ $sort: { last_date_end: -1, total_payout: -1, user: 1, status: 1 } }
-							]
-						},
-						{
-							id: 'snf_work_order_summary',
-							terms: [
-								'work order summary',
-								'work order breakdown',
-								'break down work orders',
-								'work orders',
-								'work order'
-							],
-							collection: 'work-order-dynamics',
-							permission_view: '/work-order-dynamic/list',
-							date_field: 'date_completed',
-							acknowledgement: 'I understand you want a work order breakdown for the requested date range. Let me check matching work orders.',
-							progress: ['Checking work orders for the requested date range', 'Grouping matching work orders'],
-							dimensions: {
-								work_order: {
-									terms: ['work order', 'work orders'],
-									group_id: {
-										id_work_order: '$_id',
-										wo_string: '$wo_string',
-										division: '$division',
-										status: '$status',
-										date_completed: '$date_completed'
-									},
-									project: {
-										id_work_order: '$_id.id_work_order',
-										wo_string: '$_id.wo_string',
-										division: '$_id.division',
-										status: '$_id.status',
-										date_completed: '$_id.date_completed'
-									},
-									sort: {
-										date_completed: -1,
-										wo_string: -1
-									}
-								},
-								division: {
-									terms: ['division', 'divisions'],
-									group_id: {
-										division: '$division'
-									},
-									project: {
-										division: '$_id.division'
-									},
-									sort: {
-										work_order_count: -1,
-										division: 1
-									}
-								}
-							},
-							filter_fields: {
-								division: {
-									terms: ['division', 'divisions'],
-									field: 'division'
-								},
-								status: {
-									terms: ['status', 'open', 'completed', 'reviewed', 'closed'],
-									field: 'status'
-								}
-							},
-							pipeline: [
-								{
-									$match: {
-										date_completed: {
-											$gte: '{{date_start}}',
-											$lte: '{{date_end}}'
-										}
-									}
-								},
-								{ $match: { status: { $in: ['Completed', 'Reviewed', 'Closed'] } } },
-								{
-									$group: {
-										_id: {
-											id_work_order: '$_id',
-											wo_string: '$wo_string',
-											division: '$division',
-											status: '$status',
-											date_completed: '$date_completed'
-										},
-										work_order_count: { $sum: 1 }
-									}
-								},
-								{
-									$project: {
-										_id: 0,
-										id_work_order: '$_id.id_work_order',
-										wo_string: '$_id.wo_string',
-										division: '$_id.division',
-										status: '$_id.status',
-										date_completed: '$_id.date_completed',
-										work_order_count: 1
-									}
-								},
-								{ $sort: { date_completed: -1, wo_string: -1 } }
-							]
-						},
-						{
-							id: 'snf_job_chemical_shipments',
-							terms: [
-								'amount of chemicals sent',
-								'chemicals sent',
-								'chemicals were sent',
-								'what chemicals were sent',
-								'shipped chemicals',
-								'chemical shipments',
-								'work order chemicals',
-								'work order shipments'
-							],
-							collection: 'work-order-dynamics',
-							permission_view: '/work-order-dynamic/list',
-							date_field: 'date_completed',
-							quantity_field: 'chemicals.shipped.quantity',
-							fallback_collections: ['invoices', 'jobs'],
-							acknowledgement: 'I understand you want a summary of chemicals sent to {{customer}} jobs for {{year}}. Let me check the matching work orders.',
-							progress: ['Checking {{customer}} work orders for {{year}}', 'Summarizing shipped chemical quantities'],
-							assumptions: ['Sent means shipped chemical quantity'],
-							filter_fields: {
-								customer: {
-									terms: ['customer', 'customers', 'client', 'clients'],
-									fields: ['customer', 'job.customer']
-								},
-								status: {
-									terms: ['status', 'open', 'completed', 'reviewed', 'closed'],
-									field: 'status'
-								}
-							},
-							pipeline: [
-								{
-									$match: {
-										$and: [
-											{
-												$or: [
-													{ customer: { $regex: '{{customer}}', $options: 'i' } },
-													{ 'job.customer': { $regex: '{{customer}}', $options: 'i' } }
-												]
-											},
-											{
-												date_completed: {
-													$gte: '{{date_start}}',
-													$lte: '{{date_end}}'
-												}
-											}
-										]
-									}
-								},
-								{ $match: { status: { $in: ['Completed', 'Reviewed', 'Closed'] } } },
-								{ $unwind: '$chemicals' },
-								{ $match: { 'chemicals.shipped.quantity': { $gt: 0 } } },
-								{
-									$group: {
-										_id: {
-											chemical: '$chemicals.chemical'
-										},
-										qty_sent: { $sum: '$chemicals.shipped.quantity' }
-									}
-								}
-							]
-						},
-						{
-							id: 'snf_invoice_chemical_quantities',
-							terms: ['invoice', 'invoices', 'billed chemicals', 'chemicals billed', 'how many chemicals', 'amount charged'],
-							collection: 'invoices',
-							permission_view: '/invoice/list',
-							date_field: 'date_created',
-							quantity_field: 'items_chemicals.quantity',
-							metric_field: 'items_chemicals.price_total',
-							dimensions: {
-								chemical: {
-									terms: ['chemical', 'chemicals', 'product', 'products'],
-									group_id: {
-										chemical: { $ifNull: ['$items_chemicals.chemical', 'Unknown'] }
-									},
-									project: {
-										chemical: '$_id.chemical'
-									}
-								},
-								customer: {
-									terms: ['customer', 'customers'],
-									group_id: {
-										customer: { $ifNull: ['$customer', 'Unknown'] }
-									},
-									project: {
-										customer: '$_id.customer'
-									}
-								}
-							},
-							filter_fields: {
-								chemical: {
-									terms: ['chemical', 'chemicals', 'product', 'products'],
-									field: 'items_chemicals.chemical'
-								},
-								customer: {
-									terms: ['customer', 'customers'],
-									fields: ['customer', 'job.customer']
-								}
-							}
-						},
-						{
-							id: 'snf_chemical_activity_summary',
-							terms: ['chemical activity', 'activity', 'summarize all the activity', 'nacl brine'],
-							collection: 'chemical-transactions',
-							permission_view: '/chemical/detail',
-							date_field: 'date',
-							quantity_field: 'quantity',
-							metric_field: 'quantity_diff',
-							filter_fields: {
-								chemical: {
-									terms: ['chemical', 'nacl brine'],
-									field: 'chemical'
-								}
-							},
-							pipeline: [
-								{
-									$match: {
-										date: {
-											$gte: '{{date_start}}',
-											$lte: '{{date_end}}'
-										}
-									}
-								},
-								{
-									$group: {
-										_id: {
-											chemical: { $ifNull: ['$chemical', 'Unknown'] },
-											activity_type: { $ifNull: ['$activity_type', 'Unknown'] },
-											type: { $ifNull: ['$type', 'Unknown'] }
-										},
-										activity_count: { $sum: 1 },
-										quantity: { $sum: '$quantity' },
-										quantity_diff: { $sum: '$quantity_diff' }
-									}
-								}
-							]
-						},
-						{
-							id: 'snf_chemical_blends_summary',
-							terms: ['chemical blends summary', 'chemical blends'],
-							collection: 'chemical-blends',
-							permission_view: '/chemical-blend/list',
-							date_field: 'date',
-							quantity_field: 'quantity',
-							dimensions: {
-								chemical: {
-									terms: ['chemical', 'product'],
-									group_id: {
-										chemical: {
-											$ifNull: ['$chemical', 'Unknown']
-										}
-									},
-									project: {
-										chemical: '$_id.chemical'
-									},
-										sort: {
-											quantity: -1,
-											chemical: 1
-										}
-									}
-								},
-								pipeline: [
-								{
-									$match: {
-										date: {
-											$gte: '{{date_start}}',
-											$lte: '{{date_end}}'
-										}
-									}
-								},
-								{
-									$group: {
-										_id: null,
-										blend_count: { $sum: 1 },
-										quantity: { $sum: '$quantity' }
-									}
-								}
-							]
-						},
-						{
-							id: 'snf_planned_job_chemicals',
-							terms: ['planned chemicals', 'planned chemical', 'chemicals were planned', 'what chemicals were planned', 'planned chemicals by customer'],
-							collection: 'jobs',
-							permission_view: '/customer-info/jobs',
-							date_field: 'date_job_created',
-							quantity_field: 'planned_chemicals.quantity',
-							dimensions: {
-								chemical: {
-									terms: ['chemical', 'chemicals', 'product', 'products'],
-									group_id: {
-										chemical: { $ifNull: ['$planned_chemicals.chemical', 'Unknown'] }
-									},
-									project: {
-										chemical: '$_id.chemical'
-									}
-								},
-								customer: {
-									terms: ['customer', 'customers'],
-									group_id: {
-										customer: { $ifNull: ['$customer', 'Unknown'] }
-									},
-									project: {
-										customer: '$_id.customer'
-									}
-								}
-							},
-							filter_fields: {
-								chemical: {
-									terms: ['chemical', 'chemicals', 'product', 'products'],
-									field: 'planned_chemicals.chemical'
-								},
-								customer: {
-									terms: ['customer', 'customers'],
-									fields: ['customer', 'jca.customer']
-								},
-								status: {
-									terms: ['status', 'open', 'closed', 'completed'],
-									field: 'status'
-								},
-								location: {
-									terms: ['location', 'yard'],
-									field: 'location'
-								}
-							},
-							pipeline: [
-								{
-									$match: {
-										date_job_created: {
-											$gte: '{{date_start}}',
-											$lte: '{{date_end}}'
-										}
-									}
-								},
-								{ $unwind: '$planned_chemicals' },
-								{ $match: {} },
-								{
-									$group: {
-										_id: {
-											chemical: '$planned_chemicals.chemical'
-										},
-										planned_quantity: { $sum: '$planned_chemicals.quantity' }
-									}
-								}
-							]
-						},
-						{
-							id: 'snf_chemical_inventory',
-							terms: ['inventory', 'chemical inventory', 'current inventory'],
-							collection: 'chemical-inventory-snapshots',
-							permission_view: '/chemical-inventory-snapshot/list',
-							date_field: 'date',
-							quantity_field: 'quantity',
-							assumptions: ['A named chemical or product in an inventory request is a chemical filter'],
-							dimensions: {
-								location: {
-									terms: ['location', 'locations', 'yard'],
-									group_id: {
-										location: { $ifNull: ['$location', 'Unknown'] }
-									},
-									project: {
-										location: '$_id.location'
-									}
-								},
-								chemical: {
-									terms: ['chemical', 'chemicals', 'product', 'products'],
-									group_id: {
-										chemical: { $ifNull: ['$chemical', 'Unknown'] }
-									},
-									project: {
-										chemical: '$_id.chemical'
-									}
-								}
-							},
-							filter_fields: {
-								chemical: {
-									terms: ['chemical', 'chemicals', 'product', 'products'],
-									field: 'chemical'
-								},
-								location: {
-									terms: ['location', 'locations', 'yard'],
-									field: 'location'
-								}
-							}
-						}
-					]
-				}
-			}
-		});
-		const collectionNames = ['jobs', 'work-order-dynamics', 'invoices', 'ats-settlements', 'ats-pays', 'wo-type-ats-pays', 'chemical-blends', 'chemical-transactions', 'chemical-inventory-snapshots'];
-		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'
-		);
-		assert(
-			shipmentDirective?.payload?.options?.disableNoDataFallbacks === true,
-			'Expected app-owned deterministic data intents to skip generic no-data aggregate fallbacks'
-		);
-		const atsPayDirective = resolveAssistantHeuristicDirectiveForTesting(
-			"Breakdown Fairbank, Michael's ats pay over the last year",
-			['ats-settlements', 'ats-pays'],
-			collectionNames,
-			'snf'
-		);
-		const atsPayPipelineText = JSON.stringify(atsPayDirective?.payload?.pipeline || []);
-		assert(
-			atsPayDirective?.payload?.collection === 'ats-settlements',
-			'Expected ATS pay request to resolve to ats-settlements instead of invoices'
-		);
-		assert(
-			String(atsPayDirective?.rawLine || '').includes('app-data-intent:snf_ats_driver_pay_summary'),
-			'Expected ATS pay request to use the SNF ATS driver pay recipe'
-		);
-		assert(
-			atsPayPipelineText.includes('date_start') && atsPayPipelineText.includes('date_end') && atsPayPipelineText.includes('$gte') && atsPayPipelineText.includes('$lte'),
-			'Expected over the last year to become an ATS settlement date window'
-		);
-		assert(
-			atsPayPipelineText.includes('"user":{"$regex":"Fairbank.*Michael"') && !atsPayPipelineText.includes('ats pay') && !atsPayPipelineText.includes(' over'),
-			'Expected Fairbank, Michael to become a punctuation-tolerant driver filter without ATS/date filler words'
-		);
-		assert(
-			atsPayPipelineText.includes('total_payout') && atsPayPipelineText.includes('settlement_count') && !atsPayPipelineText.includes('customer_group'),
-			'Expected ATS pay output to summarize settlement payout fields, not invoice customer groups'
-		);
-		const naturalShipmentDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'What chemicals were sent to Devon Energy last month?',
-			['chemicals', 'jobs', 'work-order-dynamics'],
-			collectionNames,
-			'snf'
-		);
-		assert(naturalShipmentDirective?.payload?.collection === 'work-order-dynamics', 'Expected natural shipped-chemical request to resolve to work-order-dynamics');
-		assert(
-			JSON.stringify(naturalShipmentDirective?.payload?.pipeline || []).includes('date_completed'),
-			'Expected natural shipped-chemical request to include the configured date field'
-		);
-		assert(
-			JSON.stringify(naturalShipmentDirective?.payload?.pipeline || []).includes('__assistant_sort_updatedAt'),
-			'Expected app data aggregates without explicit sort to default to newest updatedAt/createdAt records'
-		);
-		const divisionWorkOrderDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'Give me a breakdown of obsidian division work orders last few months',
-			['work-order-dynamics'],
-			collectionNames,
-			'snf'
-		);
-		const divisionWorkOrderPipelineText = JSON.stringify(divisionWorkOrderDirective?.payload?.pipeline || []);
-		assert(
-			divisionWorkOrderDirective?.payload?.collection === 'work-order-dynamics',
-			'Expected division work-order request to resolve to work-order-dynamics'
-		);
-		assert(
-			String(divisionWorkOrderDirective?.rawLine || '').includes('app-data-intent:snf_work_order_summary'),
-			'Expected plain work-order request to use the general work-order summary recipe'
-		);
-		assert(
-			String(divisionWorkOrderDirective?.metadata?.customerText || '') === '',
-			'Expected division filter text not to become customerText'
-		);
-		assert(
-			divisionWorkOrderPipelineText.includes('date_completed') && divisionWorkOrderPipelineText.includes('$gte') && divisionWorkOrderPipelineText.includes('$lte'),
-			'Expected last few months to become a configured date_completed window'
-		);
-		assert(
-			divisionWorkOrderPipelineText.includes('"division"') && divisionWorkOrderPipelineText.includes('"$regex":"obsidian"') && !divisionWorkOrderPipelineText.includes('obsidian division'),
-			'Expected Obsidian division wording to become a normalized division filter'
-		);
-		assert(
-			!divisionWorkOrderPipelineText.includes('chemicals.shipped.quantity') && !divisionWorkOrderPipelineText.includes('$unwind'),
-			'Expected plain work-order request not to use the shipped-chemical pipeline'
-		);
-		const openWorkOrderDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'Show open work orders with planned or shipped chemicals',
-			['work-order-dynamics'],
-			collectionNames,
-			'snf',
-			{
-				appDataRequestContract: {
-					intent_type: 'data_summary',
-					intent_id: 'snf_job_chemical_shipments',
-					domain: 'snf_job_chemical_shipments',
-					collection: 'work-order-dynamics',
-					operation: 'aggregate',
-					requested_breakdowns: [{ type: 'entity', requested_text: 'chemical', dimension: 'chemical' }],
-					date_range: null,
-					measures: ['qty_sent'],
-					filters: [{ field: 'status', operator: 'contains', value: 'open' }],
-					output_format: 'collapse_table',
-					user_progress: [],
-					ambiguities: [],
-					confidence: 0.9,
-					source: 'mini_model_classifier_test'
-				}
-			}
-		);
-		const openWorkOrderPipelineText = JSON.stringify(openWorkOrderDirective?.payload?.pipeline || []);
-		assert(openWorkOrderDirective?.payload?.collection === 'work-order-dynamics', 'Expected explicit open work-order chemical request to keep work-order-dynamics');
-		assert(openWorkOrderDirective?.metadata?.customerText === '', 'Expected connector words like "with or" not to become customer text');
-		assert(!openWorkOrderPipelineText.includes('"$regex":""'), 'Expected blank customer placeholders to be removed from configured pipelines');
-		assert(openWorkOrderPipelineText.includes('$nin'), 'Expected open status to become an open-like not-completed status filter');
-		assert(!openWorkOrderPipelineText.includes('"$in":["Completed","Reviewed","Closed"]'), 'Expected explicit open status to remove the recipe default closed-status match');
-		const invoiceDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'Devon Energy invoices this year',
-			['invoices'],
-			collectionNames,
-			'snf'
-		);
-		assert(invoiceDirective?.payload?.collection === 'invoices', 'Expected invoice request to resolve to invoices');
-		const chevronInvoiceChemicalDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'How many chemicals did Chevron get billed for this year?',
-			['invoices'],
-			collectionNames,
-			'snf'
-		);
-		const chevronInvoiceChemicalPipelineText = JSON.stringify(chevronInvoiceChemicalDirective?.payload?.pipeline || []);
-		assert(
-			String(chevronInvoiceChemicalDirective?.rawLine || '').includes('app-data-intent:snf_invoice_chemical_quantities'),
-			'Expected billed-chemical wording to use the invoice chemical line-item workflow'
-		);
-		assert(chevronInvoiceChemicalPipelineText.includes('Chevron'), 'Expected customer entity Chevron to be applied to the invoice pipeline');
-		assert(!chevronInvoiceChemicalPipelineText.includes('How many Chevron'), 'Expected customer extraction to remove question phrasing');
-		const noisyDateFilterDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'How many chemicals did Chevron get billed for this year?',
-			['invoices'],
-			collectionNames,
-			'snf',
-			{
-				appDataRequestContract: {
-					intent_type: 'data_summary',
-					intent_id: 'snf_invoice_chemical_quantities',
-					domain: 'snf_invoice_chemical_quantities',
-					collection: 'invoices',
-					operation: 'aggregate',
-					requested_breakdowns: [],
-					date_range: null,
-					measures: ['quantity'],
-					filters: [{ field: 'date_field', operator: 'contains', value: 'date_created' }],
-					output_format: 'collapse_table',
-					user_progress: [],
-					ambiguities: [],
-					confidence: 0.9,
-					source: 'mini_model_classifier_test'
-				}
-			}
-		);
-		assert(
-			!JSON.stringify(noisyDateFilterDirective?.metadata?.requestContract?.filters || []).includes('date_field'),
-			'Expected classifier date_field noise to be dropped from request filters'
-		);
-		const glutaraldehydeInvoiceDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'Summarize May invoices for glutaraldehyde by customer',
-			['invoices'],
-			collectionNames,
-			'snf',
-			{
-				appDataRequestContract: {
-					intent_type: 'data_summary',
-					intent_id: 'snf_invoice_customer_group_summary',
-					domain: 'snf_invoice_customer_group_summary',
-					collection: 'invoices',
-					operation: 'aggregate',
-					requested_breakdowns: [{ type: 'entity', requested_text: 'customer', dimension: 'customer' }],
-					date_range: null,
-					measures: ['quantity', 'invoice_total'],
-					filters: [{ field: 'chemical', operator: 'contains', value: 'May glutaraldehyde' }],
-					output_format: 'collapse_table',
-					user_progress: [
-						"I'll generate a summary of invoices for glutaraldehyde by customer for May 2023.",
-						"I'll focus on invoice header totals and group the results by customer."
-					],
-					ambiguities: [],
-					confidence: 0.9,
-					source: 'mini_model_classifier_test'
-				}
-			}
-		);
-		const glutaraldehydeInvoicePipelineText = JSON.stringify(glutaraldehydeInvoiceDirective?.payload?.pipeline || []);
-		const glutaraldehydeInvoiceContractText = JSON.stringify(glutaraldehydeInvoiceDirective?.metadata?.requestContract || {});
-		assert(
-			glutaraldehydeInvoiceDirective?.metadata?.requestContract?.intent_id === 'snf_invoice_chemical_quantities',
-			'Expected normalized request contract to report the selected invoice chemical workflow'
-		);
-		assert(glutaraldehydeInvoicePipelineText.includes('glutaraldehyde'), 'Expected chemical filter value to apply to invoice line items');
-		assert(!glutaraldehydeInvoicePipelineText.includes('May glutaraldehyde'), 'Expected month text to be removed from chemical filter value');
-		assert(glutaraldehydeInvoiceContractText.includes('"customer"'), 'Expected by-customer breakdown to remain in the contract');
-		assert(!glutaraldehydeInvoiceContractText.includes('May 2023'), 'Expected wrong-year model progress to be rejected');
-		assert(!glutaraldehydeInvoiceContractText.includes('header totals'), 'Expected header-total progress to be rejected for invoice chemical line items');
-		const inventoryDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'Break down glutaraldehyde inventory by location',
-			['chemical-inventory-snapshots'],
-			collectionNames,
-			'snf'
-		);
-		const inventoryPipelineText = JSON.stringify(inventoryDirective?.payload?.pipeline || []);
-		assert(inventoryDirective?.payload?.collection === 'chemical-inventory-snapshots', 'Expected bare chemical inventory request to use inventory snapshots');
-		assert(inventoryPipelineText.includes('glutaraldehyde'), 'Expected bare chemical name to be preserved as an inventory chemical filter');
-		assert(inventoryPipelineText.includes('location'), 'Expected inventory by-location breakdown to be applied');
-		const plannedClassifierCleanupDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'What chemicals were planned for Devon Energy jobs last month?',
-			['jobs'],
-			collectionNames,
-			'snf',
-			{
-				appDataRequestContract: {
-					intent_type: 'data_summary',
-					intent_id: 'snf_planned_job_chemicals',
-					domain: 'snf_planned_job_chemicals',
-					collection: 'jobs',
-					operation: 'aggregate',
-					requested_breakdowns: [],
-					date_range: null,
-					measures: ['planned_quantity'],
-					filters: [{ field: 'location', operator: 'contains', value: 'planned Devon Energy' }],
-					output_format: 'collapse_table',
-					user_progress: [],
-					ambiguities: [],
-					confidence: 0.7,
-					source: 'mini_model_classifier_test'
-				}
-			}
-		);
-		const plannedCleanupContractText = JSON.stringify(plannedClassifierCleanupDirective?.metadata?.requestContract || {});
-		const plannedCleanupPipelineText = JSON.stringify(plannedClassifierCleanupDirective?.payload?.pipeline || []);
-		assert(
-			plannedCleanupContractText.includes('"field":"customer"'),
-			`Expected planned job customer value to replace misclassified location filter: ${plannedCleanupContractText} ${plannedCleanupPipelineText}`
-		);
-		assert(!plannedCleanupContractText.includes('"field":"location"'), 'Expected stale misclassified location filter to be removed');
-		assert(plannedCleanupPipelineText.includes('Devon.*Energy'), 'Expected planned job customer filter value to apply to the pipeline');
-		assert(!plannedCleanupPipelineText.includes('planned Devon Energy'), 'Expected workflow word to be removed from planned customer filter value');
-		const blendSummaryDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'Give me a summary of all the chemical blends this month',
-			['chemical-blends'],
-			collectionNames,
-			'snf'
-		);
-		const blendDateMatch = blendSummaryDirective?.payload?.pipeline?.[0]?.$match?.date;
-		const now = new Date();
-		const expectedThisMonthStart = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1, 0, 0, 0, 0)).toISOString();
-		const expectedThisMonthEnd = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), 23, 59, 59, 999)).toISOString();
-		assert(blendSummaryDirective?.payload?.collection === 'chemical-blends', 'Expected chemical blend summary request to resolve to chemical-blends');
-		assert(blendDateMatch?.$gte instanceof Date, 'Expected configured date_start placeholder to remain a Date');
-		assert(blendDateMatch?.$lte instanceof Date, 'Expected configured date_end placeholder to remain a Date');
-		assert(blendDateMatch.$gte.toISOString() === expectedThisMonthStart, 'Expected this-month start date in configured pipeline');
-		assert(blendDateMatch.$lte.toISOString() === expectedThisMonthEnd, 'Expected this-month end date in configured pipeline');
-		const blendByChemicalDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'Give me a summary of all the chemical blends this month by chemical',
-			['chemical-blends'],
-			collectionNames,
-			'snf'
-		);
-		const blendByChemicalPipelineText = JSON.stringify(blendByChemicalDirective?.payload?.pipeline || []);
-		assert(blendByChemicalDirective?.payload?.collection === 'chemical-blends', 'Expected by-chemical blend request to keep the chemical-blends collection');
-		assert(blendByChemicalDirective?.metadata?.requestedDimension?.id === 'chemical', 'Expected by-chemical request to resolve the configured chemical dimension');
-		assert(blendByChemicalPipelineText.includes('"chemical"'), 'Expected by-chemical request to group/project chemical');
-		assert(!blendByChemicalPipelineText.includes('"status"'), 'Expected by-chemical request not to keep the default status grouping');
-		const blendByMonthChemicalDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'break down the chemical blends by month by chemical',
-			['chemical-blends'],
-			collectionNames,
-			'snf'
-		);
-		const blendByMonthChemicalPipeline = blendByMonthChemicalDirective?.payload?.pipeline || [];
-		const blendByMonthChemicalPipelineText = JSON.stringify(blendByMonthChemicalPipeline);
-		const blendByMonthChemicalGroup = blendByMonthChemicalPipeline.find((stage: any) => !!stage?.$group)?.$group;
-		assert(blendByMonthChemicalDirective?.payload?.collection === 'chemical-blends', 'Expected by-month by-chemical blend request to keep the chemical-blends collection');
-		assert(blendByMonthChemicalGroup?._id?.month?.$dateToString?.format === '%Y-%m', 'Expected by-month by-chemical request to group by month');
-		assert(blendByMonthChemicalGroup?._id?.month?.$dateToString?.date === '$date', 'Expected by-month grouping to use the configured date field');
-		assert(blendByMonthChemicalGroup?._id?.chemical, 'Expected by-month by-chemical request to keep the chemical dimension in the group key');
-		assert(blendByMonthChemicalPipelineText.includes('"month"'), 'Expected by-month by-chemical request to project month');
-		assert(blendByMonthChemicalPipelineText.includes('"chemical"'), 'Expected by-month by-chemical request to project chemical');
-		assert(!blendByMonthChemicalPipelineText.includes('"status"'), 'Expected by-month by-chemical request not to keep the default status grouping');
-		assert(
-			blendByMonthChemicalPipeline.find((stage: any) => !!stage?.$sort)?.$sort?.month === -1,
-			'Expected by-month by-chemical request to sort newest month first'
-		);
-		assert(
-			blendByMonthChemicalDirective?.metadata?.requestContract?.requested_breakdowns?.length === 2,
-			'Expected by-month by-chemical request contract to preserve both requested breakdowns'
-		);
-		const classifierDrivenBlendDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'chemical blends summary',
-			['chemical-blends'],
-			collectionNames,
-			'snf',
-			{
-				appDataRequestContract: {
-					intent_type: 'data_summary',
-					intent_id: 'snf_chemical_blends_summary',
-					domain: 'snf_chemical_blends_summary',
-					collection: 'chemical-blends',
-					operation: 'aggregate',
-					requested_breakdowns: [
-						{ type: 'time', requested_text: 'month', granularity: 'month', field_hint: 'date' },
-						{ type: 'entity', requested_text: 'chemical', dimension: 'chemical', field_hints: ['chemical'] }
-					],
-					date_range: null,
-					measures: ['quantity'],
-					filters: [],
-					output_format: 'collapse_table',
-					ambiguities: [],
-					confidence: 0.98,
-					source: 'mini_model_classifier_test'
-				}
-			}
-		);
-		const classifierDrivenPipeline = classifierDrivenBlendDirective?.payload?.pipeline || [];
-		const classifierDrivenGroup = classifierDrivenPipeline.find((stage: any) => !!stage?.$group)?.$group;
-		assert(classifierDrivenGroup?._id?.month?.$dateToString?.format === '%Y-%m', 'Expected classifier contract to drive month grouping');
-		assert(classifierDrivenGroup?._id?.chemical, 'Expected classifier contract to drive chemical grouping');
-		assert(
-			classifierDrivenBlendDirective?.metadata?.requestContract?.source === 'mini_model_classifier_test',
-			'Expected directive metadata to preserve classifier contract source'
-		);
-		assert(
-			classifierDrivenBlendDirective?.metadata?.requestContract?.requested_breakdowns?.length === 2,
-			'Expected classifier contract to preserve both requested breakdowns'
-		);
-		const classifierMessages = buildAssistantDataRequestClassifierMessagesForTesting({
-			message: 'break down the chemical blends by month by chemical',
-			appId: 'snf',
-			collectionNames
-		});
-		const classifierPromptText = JSON.stringify(classifierMessages);
-		assert(
-			classifierPromptText.includes('by month by chemical') && classifierPromptText.includes('two requested_breakdowns'),
-			'Expected classifier prompt to explicitly preserve multiple by clauses'
-		);
-		assert(
-			classifierPromptText.includes('user_progress') && classifierPromptText.includes('first-person'),
-			'Expected classifier prompt to request model-written user progress'
-		);
-		assert(
-			classifierPromptText.includes('Do not restate the user command') && classifierPromptText.includes('I want'),
-			'Expected classifier prompt to reject command-restatement progress'
-		);
-		const invoiceClassifierMessages = buildAssistantDataRequestClassifierMessagesForTesting({
-			message: 'Group invoices this year by month by customer',
-			appId: 'snf',
-			collectionNames
-		});
-		assert(
-			JSON.stringify(invoiceClassifierMessages).includes('snf_invoice_chemical_quantities'),
-			'Expected classifier candidates to include unscored invoice app data intents'
-		);
-		const chemicalActivityDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'summarize all the activity for 26% nacl brine this current year',
-			['chemical-transactions'],
-			collectionNames,
-			'snf',
-			{
-				appDataRequestContract: {
-					intent_type: 'data_summary',
-					intent_id: 'snf_chemical_activity_summary',
-					domain: 'snf_chemical_activity_summary',
-					collection: 'chemical-transactions',
-					operation: 'aggregate',
-					requested_breakdowns: [],
-					date_range: null,
-					measures: ['quantity_diff'],
-					filters: [{ field: 'chemical', operator: 'contains', value: '26% nacl brine' }],
-					output_format: 'collapse_table',
-					user_progress: [
-						"I'm identifying this as chemical transaction activity for 26% NaCl brine.",
-						"I'm applying the current-year date range and chemical filter before summarizing movement records."
-					],
-					ambiguities: [],
-					confidence: 0.98,
-					source: 'mini_model_classifier_test'
-				}
-			}
-		);
-		const chemicalActivityPipelineText = JSON.stringify(chemicalActivityDirective?.payload?.pipeline || []);
-		assert(chemicalActivityDirective?.payload?.collection === 'chemical-transactions', 'Expected chemical activity request to resolve to chemical-transactions');
-		assert(chemicalActivityDirective?.payload?.permissionView === '/chemical/detail', 'Expected chemical activity request to use the chemical detail permission view');
-		assert(chemicalActivityPipelineText.includes('quantity_diff'), 'Expected chemical activity request to include quantity_diff');
-		assert(chemicalActivityPipelineText.includes('26%.*nacl.*brine'), 'Expected classifier chemical filter to apply to the activity pipeline');
-		assert(
-			chemicalActivityDirective?.metadata?.progress?.[0] === "I'm identifying this as chemical transaction activity for 26% NaCl brine.",
-			'Expected classifier user_progress to drive visible directive progress'
-		);
-		assert(
-			chemicalActivityDirective?.metadata?.requestContract?.output_format === 'collapse_table',
-			'Expected chemical activity request to preserve collapse-table output format'
-		);
-		assert(
-			chemicalActivityDirective?.metadata?.planValidation?.ok === true,
-			'Expected app-data directive metadata to include successful query plan validation'
-		);
-		const leftoverFilterDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'Show brine activity by month for this year',
-			['chemical-transactions'],
-			collectionNames,
-			'snf',
-			{
-				appDataRequestContract: {
-					intent_type: 'data_summary',
-					intent_id: 'snf_chemical_activity_summary',
-					domain: 'snf_chemical_activity_summary',
-					collection: 'chemical-transactions',
-					operation: 'aggregate',
-					requested_breakdowns: [{ type: 'time', requested_text: 'month', dimension: 'month', granularity: 'month' }],
-					date_range: null,
-					measures: ['quantity_diff'],
-					filters: [{ field: 'date', operator: 'contains', value: 'year-to-date' }],
-					output_format: 'collapse_table',
-					user_progress: [],
-					ambiguities: [],
-					confidence: 0.98,
-					source: 'mini_model_classifier_test'
-				}
-			}
-		);
-		assert(
-			JSON.stringify(leftoverFilterDirective?.metadata?.requestContract?.filters || []).includes('brine'),
-			'Expected likely leftover chemical text to be appended when classifier only emitted a date filter'
-		);
-		assert(
-			JSON.stringify(leftoverFilterDirective?.payload?.pipeline || []).includes('brine'),
-			'Expected appended leftover chemical filter to apply to the activity pipeline'
-		);
-		const positiveMovementDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'Which chemical activity increased in last month?',
-			['chemical-transactions'],
-			collectionNames,
-			'snf',
-			{
-				appDataRequestContract: {
-					intent_type: 'data_summary',
-					intent_id: 'snf_chemical_activity_summary',
-					domain: 'snf_chemical_activity_summary',
-					collection: 'chemical-transactions',
-					operation: 'aggregate',
-					requested_breakdowns: [],
-					date_range: null,
-					measures: ['quantity_diff'],
-					filters: [{ field: 'quantity_diff', operator: 'contains', value: '>0' }],
-					output_format: 'collapse_table',
-					user_progress: [],
-					ambiguities: [],
-					confidence: 0.98,
-					source: 'mini_model_classifier_test'
-				}
-			}
-		);
-		const positiveMovementContractText = JSON.stringify(positiveMovementDirective?.metadata?.requestContract || {});
-		const positiveMovementPipelineText = JSON.stringify(positiveMovementDirective?.payload?.pipeline || []);
-		assert(!positiveMovementContractText.includes('increased in'), 'Expected movement wording not to become a chemical fallback filter');
-		assert(positiveMovementPipelineText.includes('"$gt":0'), 'Expected numeric comparator text >0 to apply as a greater-than filter');
-		assert(
-			!(positiveMovementDirective?.metadata?.requestContract?.ambiguities || []).some((entry: string) => /quantity/i.test(entry) && /not applied/i.test(entry)),
-			`Expected parsed numeric comparator filter not to be reported as unapplied: ${positiveMovementContractText} ${positiveMovementPipelineText}`
-		);
-		const badProgressDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'summarize all the activity for 26% nacl brine this current year',
-			['chemical-transactions'],
-			collectionNames,
-			'snf',
-			{
-				appDataRequestContract: {
-					intent_type: 'data_summary',
-					intent_id: 'snf_chemical_activity_summary',
-					domain: 'snf_chemical_activity_summary',
-					collection: 'chemical-transactions',
-					operation: 'aggregate',
-					requested_breakdowns: [{ type: 'entity', requested_text: 'by activity type', dimension: 'activity_type' }],
-					date_range: null,
-					measures: ['quantity_diff'],
-					filters: { chemical: '26% nacl brine' } as any,
-					output_format: 'collapse_table',
-					user_progress: [
-						'i want to see the activity summary',
-						'please include all relevant details for this year',
-						'Reading your request',
-						"I'll extract intent_id, date_range, and requested_breakdowns."
-					],
-					ambiguities: [],
-					confidence: 0.98,
-					source: 'mini_model_classifier_test'
-				}
-			}
-		);
-		assert(
-			!(badProgressDirective?.metadata?.requestContract?.user_progress || []).length,
-			'Expected command-restatement and placeholder model progress to be rejected'
-		);
-		assert(
-			JSON.stringify(badProgressDirective?.payload?.pipeline || []).includes('26%.*nacl.*brine'),
-			'Expected object-form classifier filters to normalize and apply'
-		);
-		assert(
-			!JSON.stringify(badProgressDirective?.metadata?.progress || []).includes('intent_id'),
-			'Expected internal JSON field names to be removed from visible model progress'
-		);
-		const byByResponse = buildAssistantToolFallbackResponseForTesting({
-			type: 'mongo_agg',
-			input: { collection: 'chemical-transactions' },
-			output: {
-				collection: 'chemical-transactions',
-				rowCount: 0,
-				columns: ['Activity Type', 'Quantity Diff'],
-				display: {
-					columns: ['Activity Type', 'Quantity Diff'],
-					rows: [],
-					rowCount: 0,
-					truncated: false,
-					includeIds: false
-				},
-				debug: {
-					requestContract: {
-						requested_breakdowns: [{ type: 'entity', requested_text: 'by activity type', dimension: 'activity_type' }]
-					}
-				}
-			}
-		});
-		assert(
-			byByResponse.includes('- Summary breakdown: by activity type') && !byByResponse.includes('by by activity type'),
-			'Expected presentation formatting to avoid duplicated by/by wording'
-		);
-		const shortenedFilterDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'summarize all the activity for 26% nacl brine this current year',
-			['chemical-transactions'],
-			collectionNames,
-			'snf',
-			{
-				appDataRequestContract: {
-					intent_type: 'data_summary',
-					intent_id: 'snf_chemical_activity_summary',
-					domain: 'snf_chemical_activity_summary',
-					collection: 'chemical-transactions',
-					operation: 'aggregate',
-					requested_breakdowns: [{ type: 'entity', requested_text: 'activity_type', dimension: 'activity_type' }],
-					date_range: { start: '2023-01-01', end: '2023-12-31', year: 2023 },
-					measures: ['quantity_diff'],
-					filters: [{ field: 'chemical', operator: 'contains', value: 'nacl brine' }],
-					output_format: 'collapse_table',
-					ambiguities: [],
-					confidence: 0.98,
-					source: 'mini_model_classifier_test'
-				}
-			}
-		);
-		assert(
-			JSON.stringify(shortenedFilterDirective?.metadata?.requestContract?.filters || []).includes('26% nacl brine'),
-			'Expected shortened classifier filter to preserve numeric/product qualifiers from the user request'
-		);
-		assert(
-			shortenedFilterDirective?.metadata?.dateWindow?.year === new Date().getUTCFullYear(),
-			'Expected deterministic relative-date parsing to override stale classifier date ranges'
-		);
-		const timeoutFallbackDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'summarize all the activity for 26% nacl brine this current year',
-			['chemical-transactions'],
-			collectionNames,
-			'snf',
-			{
-				appDataRequestClassifier: {
-					attempted: true,
-					succeeded: false,
-					error: 'AI request timed out.'
-				}
-			}
-		);
-		assert(timeoutFallbackDirective, 'Expected classifier timeout to fall back to the app data intent instead of bypassing it');
-		assert(
-			JSON.stringify(timeoutFallbackDirective?.metadata?.requestContract?.filters || []).includes('26% nacl brine'),
-			'Expected classifier timeout fallback to preserve likely filter text from the user request'
-		);
-		assert(
-			JSON.stringify(timeoutFallbackDirective?.payload?.pipeline || []).includes('26%.*nacl.*brine'),
-			'Expected classifier timeout fallback filter to apply to the activity pipeline'
-		);
-		const filterFieldBreakdownDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'summarize all the activity for 26% nacl brine this current year',
-			['chemical-transactions'],
-			collectionNames,
-			'snf',
-			{
-				appDataRequestContract: {
-					intent_type: 'data_summary',
-					intent_id: 'snf_chemical_activity_summary',
-					domain: 'snf_chemical_activity_summary',
-					collection: 'chemical-transactions',
-					operation: 'aggregate',
-					requested_breakdowns: [{ type: 'entity', requested_text: 'chemical', dimension: 'chemical' }],
-					date_range: null,
-					measures: ['quantity_diff'],
-					filters: [{ field: 'chemical', operator: 'contains', value: '26% nacl brine' }],
-					output_format: 'collapse_table',
-					ambiguities: [],
-					confidence: 0.98,
-					source: 'mini_model_classifier_test'
-				}
-			}
-		);
-		const filterFieldBreakdownGroup = filterFieldBreakdownDirective?.payload?.pipeline?.find((stage: any) => !!stage?.$group)?.$group;
-		assert(
-			!(filterFieldBreakdownDirective?.metadata?.requestContract?.requested_breakdowns || []).length,
-			'Expected non-explicit classifier breakdowns that duplicate filter fields to be ignored'
-		);
-		assert(
-			filterFieldBreakdownGroup?._id?.activity_type && filterFieldBreakdownGroup?._id?.type,
-			'Expected ignored filter-field breakdowns to preserve the app recipe default activity grouping'
-		);
-		const plannedDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'planned chemicals for Devon jobs',
-			['jobs'],
-			collectionNames,
-			'snf'
-		);
-		assert(plannedDirective?.payload?.collection === 'jobs', 'Expected planned chemicals request to resolve to jobs');
-		const plannedOpenDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'Show open jobs with planned chemicals by customer',
-			['jobs'],
-			collectionNames,
-			'snf',
-			{
-				appDataRequestClassifier: {
-					attempted: true,
-					succeeded: false,
-					error: 'AI request timed out.'
-				}
-			}
-		);
-		const plannedOpenPipelineText = JSON.stringify(plannedOpenDirective?.payload?.pipeline || []);
-		assert(plannedOpenDirective?.payload?.collection === 'jobs', 'Expected open planned jobs request to resolve to jobs');
-		assert(plannedOpenPipelineText.includes('"status"') && plannedOpenPipelineText.includes('open'), 'Expected open planned jobs fallback to preserve status filter evidence');
-	}
-	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 testAssistantAppDataIntentContractsPreserveGenericBreakdownsAndDateRanges() {
-	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: {
-				demo: {
-					enabled_deterministic_heuristics: ['app_data_intent'],
-					data_intents: [
-						{
-							id: 'demo_order_summary',
-							terms: ['orders', 'order summary'],
-							collection: 'orders',
-							permission_view: '/orders',
-							date_field: 'date',
-							quantity_field: 'total',
-							dimensions: {
-								customer_group: {
-									terms: ['customer group', 'customer groups'],
-									group_id: {
-										customer_group: {
-											$ifNull: ['$customer_group', 'Unknown']
-										}
-									},
-									project: {
-										customer_group: '$_id.customer_group'
-									},
-									sort: {
-										customer_group: 1
-									}
-								},
-								status: {
-									terms: ['status', 'state'],
-									group_id: {
-										status: {
-											$ifNull: ['$status', 'Unknown']
-										}
-									},
-									project: {
-										status: '$_id.status'
-									},
-										sort: {
-											status: 1
-										}
-									}
-								},
-								filter_fields: {
-									priority: {
-										terms: ['priority'],
-										field: 'priority'
-									}
-								},
-								pipeline: [
-								{
-									$match: {
-										date: {
-											$gte: '{{date_start}}',
-											$lte: '{{date_end}}'
-										}
-									}
-								},
-								{
-									$group: {
-										_id: null,
-										order_count: { $sum: 1 },
-										total: { $sum: '$total' }
-									}
-								},
-								{
-									$project: {
-										_id: 0,
-										order_count: 1,
-										total: 1
-									}
-								},
-								{
-									$sort: {
-										total: -1
-									}
-								}
-							]
-						},
-						{
-							id: 'demo_order_list',
-							terms: ['order list', 'orders list'],
-							collection: 'orders',
-							permission_view: '/orders',
-							date_field: 'date',
-							dimensions: {
-								status: {
-									terms: ['status', 'state'],
-									group_id: {
-										status: {
-											$ifNull: ['$status', 'Unknown']
-										}
-									},
-									project: {
-										status: '$_id.status'
-									},
-									sort: {
-										status: 1
-									}
-								}
-							}
-						}
-					]
-				}
-			}
-		});
-		const collectionNames = ['orders'];
-		const byCustomerMonth = resolveAssistantHeuristicDirectiveForTesting(
-			'Summarize orders by customer group by month',
-				['orders'],
-				collectionNames,
-				'demo'
-			);
-		const byCustomerMonthPipeline = byCustomerMonth?.payload?.pipeline || [];
-		const byCustomerMonthGroup = byCustomerMonthPipeline.find((stage: any) => !!stage?.$group)?.$group;
-		assert(byCustomerMonth?.payload?.collection === 'orders', 'Expected generic app data request to keep the app-owned collection');
-		assert(byCustomerMonth?.metadata?.customerText === '', 'Expected customer group breakdown text not to become a customer filter');
-		assert(byCustomerMonthGroup?._id?.customer_group, 'Expected generic customer group breakdown to be included');
-		assert(byCustomerMonthGroup?._id?.month?.$dateToString?.format === '%Y-%m', 'Expected generic month breakdown to be included');
-		assert(
-			byCustomerMonth?.metadata?.requestContract?.requested_breakdowns?.length === 2,
-			'Expected generic contract to preserve customer group and month breakdowns'
-		);
-		assert(
-			!(byCustomerMonth?.metadata?.requestContract?.ambiguities || []).length,
-			'Expected applied customer group and month breakdowns not to record ambiguities'
-		);
-
-		const classifierAndTextDuplicateDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'Summarize orders by customer group by month',
-			['orders'],
-			collectionNames,
-			'demo',
-			{
-				appDataRequestContract: {
-					intent_type: 'data_summary',
-					intent_id: 'demo_order_summary',
-					domain: 'demo_order_summary',
-					collection: 'orders',
-					operation: 'aggregate',
-					requested_breakdowns: [
-						{ type: 'entity', requested_text: 'customer group', dimension: 'customer_group', field_hints: ['customer_group'] },
-						{ type: 'time', requested_text: 'month', granularity: 'month', field_hint: 'date' }
-					],
-					date_range: null,
-					measures: ['total'],
-					filters: [],
-					output_format: 'collapse_table',
-					ambiguities: [],
-					confidence: 0.98,
-					source: 'mini_model_classifier_test'
-				}
-			}
-		);
-		assert(
-			classifierAndTextDuplicateDirective?.metadata?.requestContract?.requested_breakdowns?.length === 2,
-			'Expected classifier and text-extracted breakdowns to dedupe to the two unique requested dimensions'
-		);
-
-		const byStatusDay = resolveAssistantHeuristicDirectiveForTesting(
-			'Show orders by status by day for past 30 days',
-			['orders'],
-			collectionNames,
-			'demo'
-		);
-		const byStatusDayPipeline = byStatusDay?.payload?.pipeline || [];
-		const byStatusDayGroup = byStatusDayPipeline.find((stage: any) => !!stage?.$group)?.$group;
-		const byStatusDayMatch = byStatusDayPipeline.find((stage: any) => !!stage?.$match)?.$match?.date;
-		assert(byStatusDayGroup?._id?.status, 'Expected generic status breakdown to be included');
-		assert(byStatusDayGroup?._id?.day?.$dateToString?.format === '%Y-%m-%d', 'Expected generic day breakdown to be included');
-		assert(byStatusDayMatch?.$gte instanceof Date, 'Expected past-30-days date start placeholder to become a Date');
-		assert(byStatusDayMatch?.$lte instanceof Date, 'Expected past-30-days date end placeholder to become a Date');
-		assert(
-			byStatusDay?.metadata?.requestContract?.requested_breakdowns?.length === 2,
-			'Expected generic contract to preserve status and day breakdowns'
-		);
-
-		const unappliedBreakdownDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'Show order list by status',
-			['orders'],
-			collectionNames,
-			'demo'
-		);
-		const unappliedAmbiguities = unappliedBreakdownDirective?.metadata?.requestContract?.ambiguities || [];
-		assert(unappliedBreakdownDirective?.payload?.collection === 'orders', 'Expected order list request to keep the app-owned collection');
-		assert(unappliedBreakdownDirective?.metadata?.requestContract?.requested_breakdowns?.length === 1, 'Expected order list request to preserve the explicit status breakdown');
-		assert(
-			unappliedAmbiguities.some((entry: string) => /status/i.test(entry) && /not applied/i.test(entry)),
-			'Expected an explicit ambiguity when a requested breakdown is not applied to the final group'
-		);
-
-		const throughMay = resolveAssistantHeuristicDirectiveForTesting(
-			'Summarize orders through May',
-			['orders'],
-			collectionNames,
-			'demo'
-		);
-		const throughMayMatch = throughMay?.payload?.pipeline?.find((stage: any) => !!stage?.$match)?.$match?.date;
-		const now = new Date();
-		const expectedMayEnd = new Date(Date.UTC(now.getUTCFullYear(), 5, 0, 23, 59, 59, 999)).toISOString();
-		const expectedCurrentMonthStart = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1, 0, 0, 0, 0)).toISOString();
-		const expectedCurrentDayEnd = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), 23, 59, 59, 999)).toISOString();
-		assert(throughMayMatch?.$lte instanceof Date, 'Expected through-May date end placeholder to become a Date');
-		assert(throughMayMatch.$lte.toISOString() === expectedMayEnd, 'Expected through-May date range to end on the last day of May');
-		assert(!Object.prototype.hasOwnProperty.call(throughMayMatch, '$gte'), 'Expected through-May date range not to invent a start date');
-
-		const untilJune15 = resolveAssistantHeuristicDirectiveForTesting(
-			'Summarize orders until June 15',
-			['orders'],
-			collectionNames,
-			'demo'
-		);
-		const untilJune15Match = untilJune15?.payload?.pipeline?.find((stage: any) => !!stage?.$match)?.$match?.date;
-		const expectedJune15End = new Date(Date.UTC(now.getUTCFullYear(), 5, 15, 23, 59, 59, 999)).toISOString();
-		assert(untilJune15Match?.$lte instanceof Date, 'Expected until-June-15 date end placeholder to become a Date');
-		assert(untilJune15Match.$lte.toISOString() === expectedJune15End, 'Expected until-June-15 date range to end on June 15');
-		assert(!Object.prototype.hasOwnProperty.call(untilJune15Match, '$gte'), 'Expected until-June-15 date range not to invent a start date');
-
-		const thisMonth = resolveAssistantHeuristicDirectiveForTesting(
-			'Summarize orders this month',
-			['orders'],
-			collectionNames,
-			'demo'
-		);
-		const thisMonthMatch = thisMonth?.payload?.pipeline?.find((stage: any) => !!stage?.$match)?.$match?.date;
-		assert(thisMonthMatch?.$gte instanceof Date, 'Expected this-month date start placeholder to become a Date');
-		assert(thisMonthMatch?.$lte instanceof Date, 'Expected this-month date end placeholder to become a Date');
-		assert(thisMonthMatch.$gte.toISOString() === expectedCurrentMonthStart, 'Expected this-month range to start on the first day of the current month');
-		assert(thisMonthMatch.$lte.toISOString() === expectedCurrentDayEnd, 'Expected this-month range to end today');
-
-		const lastMonth = resolveAssistantHeuristicDirectiveForTesting(
-			'Summarize orders last month',
-			['orders'],
-			collectionNames,
-			'demo'
-		);
-		const lastMonthMatch = lastMonth?.payload?.pipeline?.find((stage: any) => !!stage?.$match)?.$match?.date;
-		const expectedLastMonthStartDate = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() - 1, 1, 0, 0, 0, 0));
-		const expectedLastMonthEndDate = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 0, 23, 59, 59, 999));
-		assert(lastMonthMatch?.$gte instanceof Date, 'Expected last-month date start placeholder to become a Date');
-		assert(lastMonthMatch?.$lte instanceof Date, 'Expected last-month date end placeholder to become a Date');
-		assert(lastMonthMatch.$gte.toISOString() === expectedLastMonthStartDate.toISOString(), 'Expected last-month range to start on the first day of last month');
-		assert(lastMonthMatch.$lte.toISOString() === expectedLastMonthEndDate.toISOString(), 'Expected last-month range to end on the last day of last month');
-
-		const thisYearThroughMay = resolveAssistantHeuristicDirectiveForTesting(
-			'Summarize orders this year through May',
-			['orders'],
-			collectionNames,
-			'demo'
-		);
-		const thisYearThroughMayMatch = thisYearThroughMay?.payload?.pipeline?.find((stage: any) => !!stage?.$match)?.$match?.date;
-		const expectedYearStart = new Date(Date.UTC(now.getUTCFullYear(), 0, 1, 0, 0, 0, 0)).toISOString();
-		assert(thisYearThroughMayMatch?.$gte instanceof Date, 'Expected this-year-through-May date start placeholder to become a Date');
-		assert(thisYearThroughMayMatch?.$lte instanceof Date, 'Expected this-year-through-May date end placeholder to become a Date');
-		assert(thisYearThroughMayMatch.$gte.toISOString() === expectedYearStart, 'Expected this-year-through-May range to start at year start');
-		assert(thisYearThroughMayMatch.$lte.toISOString() === expectedMayEnd, 'Expected this-year-through-May range to end on the last day of May');
-
-		const classifierDateRangeDirective = resolveAssistantHeuristicDirectiveForTesting(
-			'Summarize orders',
-			['orders'],
-			collectionNames,
-			'demo',
-			{
-				appDataRequestContract: {
-					intent_type: 'data_summary',
-					intent_id: 'demo_order_summary',
-					domain: 'demo_order_summary',
-					collection: 'orders',
-					operation: 'aggregate',
-					requested_breakdowns: [
-						{ type: 'entity', requested_text: 'customer group', dimension: 'customer_group', field_hints: ['customer_group'] },
-						{ type: 'time', requested_text: 'month', granularity: 'month', field_hint: 'date' }
-					],
-					date_range: {
-						start: '2026-04-01T00:00:00.000Z',
-						end: '2026-04-30T23:59:59.999Z'
-					},
-					measures: ['total'],
-					filters: [],
-					output_format: 'collapse_table',
-					ambiguities: [],
-					confidence: 0.98,
-					source: 'mini_model_classifier_test'
-				}
-			}
-		);
-		const classifierDateRangePipeline = classifierDateRangeDirective?.payload?.pipeline || [];
-		const classifierDateRangeMatch = classifierDateRangePipeline.find((stage: any) => !!stage?.$match)?.$match?.date;
-		const classifierDateRangeGroup = classifierDateRangePipeline.find((stage: any) => !!stage?.$group)?.$group;
-		assert(classifierDateRangeMatch?.$gte instanceof Date, 'Expected classifier date_range start to replace date_start placeholder as a Date');
-		assert(classifierDateRangeMatch?.$lte instanceof Date, 'Expected classifier date_range end to replace date_end placeholder as a Date');
-		assert(classifierDateRangeMatch.$gte.toISOString() === '2026-04-01T00:00:00.000Z', 'Expected classifier date_range start to drive the pipeline');
-		assert(classifierDateRangeMatch.$lte.toISOString() === '2026-04-30T23:59:59.999Z', 'Expected classifier date_range end to drive the pipeline');
-			assert(classifierDateRangeGroup?._id?.customer_group, 'Expected classifier customer-group breakdown to drive grouping');
-			assert(classifierDateRangeGroup?._id?.month?.$dateToString?.format === '%Y-%m', 'Expected classifier month breakdown to drive grouping');
-			assert(
-				classifierDateRangeDirective?.metadata?.dateWindow?.year === 2026,
-				'Expected classifier date_range to populate effective dateWindow year'
-			);
-
-			const appliedDimensionFilterDirective = resolveAssistantHeuristicDirectiveForTesting(
-				'Summarize orders',
-				['orders'],
-				collectionNames,
-				'demo',
-				{
-					appDataRequestContract: {
-						intent_type: 'data_summary',
-						intent_id: 'demo_order_summary',
-						domain: 'demo_order_summary',
-						collection: 'orders',
-						operation: 'aggregate',
-						requested_breakdowns: [],
-						date_range: null,
-						measures: ['total'],
-						filters: [{ status: 'Open' }],
-						output_format: 'collapse_table',
-						ambiguities: [],
-						confidence: 0.98,
-						source: 'mini_model_classifier_test'
-					}
-				}
-			);
-			const appliedDimensionFilterPipelineText = JSON.stringify(appliedDimensionFilterDirective?.payload?.pipeline || []);
-			assert(appliedDimensionFilterPipelineText.includes('"status"'), 'Expected dimension-backed classifier filter to apply status to the pipeline');
-			assert(appliedDimensionFilterPipelineText.includes('Open'), 'Expected dimension-backed classifier filter value to apply to the pipeline');
-			assert(
-				!(appliedDimensionFilterDirective?.metadata?.requestContract?.ambiguities || []).some((entry: string) => /status/i.test(entry) && /not applied/i.test(entry)),
-				'Expected applied dimension-backed classifier filter not to record a not-applied ambiguity'
-			);
-
-			const appliedExplicitFilterDirective = resolveAssistantHeuristicDirectiveForTesting(
-				'Summarize orders',
-				['orders'],
-				collectionNames,
-				'demo',
-				{
-					appDataRequestContract: {
-						intent_type: 'data_summary',
-						intent_id: 'demo_order_summary',
-						domain: 'demo_order_summary',
-						collection: 'orders',
-						operation: 'aggregate',
-						requested_breakdowns: [],
-						date_range: null,
-						measures: ['total'],
-						filters: [{ field: 'priority', operator: 'eq', value: 'High' }],
-						output_format: 'collapse_table',
-						ambiguities: [],
-						confidence: 0.98,
-						source: 'mini_model_classifier_test'
-					}
-				}
-			);
-			const appliedExplicitFilterPipelineText = JSON.stringify(appliedExplicitFilterDirective?.payload?.pipeline || []);
-			assert(appliedExplicitFilterPipelineText.includes('"priority"'), 'Expected explicit app filter field to apply priority to the pipeline');
-			assert(appliedExplicitFilterPipelineText.includes('High'), 'Expected explicit app filter value to apply to the pipeline');
-
-			const unappliedFilterDirective = resolveAssistantHeuristicDirectiveForTesting(
-				'Summarize orders',
-				['orders'],
-				collectionNames,
-				'demo',
-				{
-					appDataRequestContract: {
-						intent_type: 'data_summary',
-						intent_id: 'demo_order_summary',
-						domain: 'demo_order_summary',
-						collection: 'orders',
-						operation: 'aggregate',
-						requested_breakdowns: [],
-						date_range: null,
-						measures: ['total'],
-						filters: [{ region: 'North' }],
-						output_format: 'collapse_table',
-						ambiguities: [],
-						confidence: 0.98,
-						source: 'mini_model_classifier_test'
-					}
-				}
-			);
-			const unappliedFilterAmbiguities = unappliedFilterDirective?.metadata?.requestContract?.ambiguities || [];
-			assert(
-				unappliedFilterDirective?.metadata?.requestContract?.filters?.[0]?.region === 'North',
-				'Expected unmatched classifier filters to be preserved in the request contract'
-			);
-			assert(
-				unappliedFilterAmbiguities.some((entry: string) => /filter/i.test(entry) && /region/i.test(entry) && /not applied/i.test(entry)),
-				'Expected an explicit ambiguity when a classifier filter is not applied to the final pipeline'
-			);
-			assert(
-				unappliedFilterDirective?.metadata?.requestContract?.confidence <= 0.65,
-				'Expected unapplied classifier filters to lower request contract confidence'
-			);
-		}
-		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'
-	);
-	assert(
-		(pivoted?.columns || []).indexOf('2025-12') < (pivoted?.columns || []).indexOf('2025-11'),
-		'Expected dated pivot month columns to show newest month first'
-	);
-	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?.columns || []).indexOf('2026-01') < (pivoted?.columns || []).indexOf('2025-12'),
-		'Expected metric pivot month columns to show newest month first'
-	);
-	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 testResolveCollectionOverrideWithContextDoesNotRewriteAggregateDataPlanToRouteCollection() {
-	const aggregateOverride = resolveCollectionOverrideWithContextForTesting({
-		message: 'summarize all the activity for 26% nacl brine this current year',
-		collectionRanking: {
-			ranked: [
-				{ name: 'chemicals', score: 88 },
-				{ name: 'chemical-transactions', score: 84 }
-			]
-		},
-		requestedCollection: 'chemical-transactions',
-		permissionView: '/chemical/detail',
-		collectionNames: ['chemicals', 'chemical-transactions'],
-		collectionHints: ['chemicals', 'chemical-transactions'],
-		directiveType: 'aggregate'
-	});
-	assert(!aggregateOverride, 'Expected aggregate chemical activity plan to keep chemical-transactions instead of the route chemicals collection');
-
-	const readOverride = resolveCollectionOverrideWithContextForTesting({
-		message: 'open this chemical record',
-		collectionRanking: {
-			ranked: [
-				{ name: 'chemicals', score: 88 },
-				{ name: 'chemical-transactions', score: 84 }
-			]
-		},
-		requestedCollection: 'chemical-transactions',
-		permissionView: '/chemical/detail',
-		collectionNames: ['chemicals', 'chemical-transactions'],
-		collectionHints: ['chemicals', 'chemical-transactions'],
-		directiveType: 'read'
-	});
-	assert(!!readOverride, 'Expected non-aggregate route-context collection correction to remain available');
-	assert(readOverride?.to === 'chemicals', 'Expected non-aggregate route correction to target chemicals');
-}
-
-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'],
-		collectionPreserveRules: [
-			{
-				routePreferredCollections: ['jobs'],
-				routePatterns: ['/customer-info/jobs', '/job/list', '/jobs'],
-				requestedCollections: ['work-order-dynamics'],
-				contextTerms: ['job', 'jobs', 'work order', 'work orders'],
-				terms: ['chemical', 'chemicals', 'sent', 'shipped']
-			}
-		]
-	});
-	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();
-	testAssistantToolFallbackResponseIncludesRequestedBreakdowns();
-	testAssistantToolFallbackResponseExplainsZeroRows();
-	testBuildAssistantAnswerQualityFromExecution();
-	testAssistantZeroRowDisplayDoesNotAppendSyntheticTable();
-	testDisplayMarkdownTableDefaultsToShortDateFormat();
-	testDeriveAssistantCommandExecutionStatus();
-	testResolveCodexThoughtLevelPolicy();
-	testAssistantSystemPromptAllowsWorkspaceDebuggingAndFixes();
-	testAssistantGuardrailsAllowInternalEngineeringRequests();
-	testBuildAssistantWorkspaceRootCandidates();
-	testShouldRunAssistantPlannerPolicy();
-	testAssistantAppHeuristicRegistryTermHintsAndDeterministicEnablement();
-	testAssistantAppFieldSynonymsStayAppOwned();
-	testAssistantAppHeuristicRegistryLoadsRelativeFileFromParityServerDir();
-	testAssistantCoreHeuristicsStayPlatformScoped();
-	testAssistantAppHeuristicsCanOwnDomainCollectionHints();
-	testAssistantClassifierWorkflowArbitrationPrefersExplicitWorkOrders();
-	testAssistantAppDataIntentsResolveSnfDomainRequests();
-	testAssistantAppDataIntentContractsPreserveGenericBreakdownsAndDateRanges();
-	testAssistantRemovedDomainHeuristicIdsRemainAppSpecific();
-	testAssistantHeuristicBlendIdsRemainAppSpecific();
-	testShouldEnforceAssistantDatedDirectiveSkipsWindowedRankingRequests();
-	testShouldEnforceAssistantDatedDirectiveForExplicitTemporalBreakdown();
-	testShouldEnforceAssistantDatedDirectiveForPlannerTemporalGroupBy();
-	testBuildAssistantDatedPivotDisplayWithYearMonthAndCustomer();
-	testBuildAssistantDatedPivotDisplayWithoutDimensionCreatesMetricGrid();
-	testBuildAssistantInvoiceCustomerLabelExprIncludesClientFallbacks();
-	testResolveAssistantReadDisplayMaxRows();
-	testResolveAssistantCollectionOverrideKeepsSpecificOrdersCollection();
-	testResolveAssistantCollectionOverrideStillAppliesForUnrelatedCollection();
-	testResolveAssistantCollectionOverrideSkipsBorderlineGapForWorkOrderRanking();
-	testResolveAssistantCollectionOverrideKeepsWorkOrderCollectionWhenOrdersScoresHigher();
-	testResolveCollectionOverrideWithContextRespectsPermissionRouteHints();
-	testResolveCollectionOverrideWithContextUsesSpecificPermissionRouteCollection();
-	testResolveCollectionOverrideWithContextDoesNotRewriteAggregateDataPlanToRouteCollection();
-	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);
-	});