@resolveio/server-lib 22.3.221 → 22.3.222

package/src/managers/slow-query-verifier.manager.ts

@@ -1,3590 +0,0 @@
-import { createHash } from 'crypto';
-import { ResolveIOServer } from '../resolveio-server-app';
-import { pad, round } from '../util/common';
-import { MongoClient } from 'mongodb';
-import { Users } from '../collections/user.collection';
-import { AppSettings } from '../collections/app-setting.collection';
-import { buildGeneratedSlowQuerySummary, buildResolveIOProjectSlowQueryDetails } from './customer-notification-content.manager';
-
-type AIDashboardJob = Record<string, any>;
-type AICoderAppModel = Record<string, any>;
-type ClientDBModel = Record<string, any>;
-type SlowQueryExecutionOverride = Record<string, any>;
-type SlowQueryVerificationStatus = 'pending' | 'passed' | 'failed';
-type SlowQueryVerificationRun = Record<string, any>;
-type SlowQueryLogModel = Record<string, any>;
-
-export interface TokenEligibilityResult {
-	eligible: boolean;
-	reason?: string;
-}
-
-export type CheckAICoderTokenEligibilityFn = Function;
-
-export interface SlowQueryVerifierDependencies {
-	ClientDBs?: any;
-	Clients?: any;
-	SlowQueryLogs: any;
-	AICoderApps?: any;
-	AIDashboardJobs?: any;
-	checkAICoderTokenEligibility?: CheckAICoderTokenEligibilityFn;
-}
-
-const OPTIONAL_COLLECTION = {
-	findOne: () => Promise.resolve(null),
-	find: () => Promise.resolve([])
-};
-
-let AICoderApps: any = OPTIONAL_COLLECTION;
-let AIDashboardJobs: any = OPTIONAL_COLLECTION;
-let ClientDBs: any = OPTIONAL_COLLECTION;
-let Clients: any = OPTIONAL_COLLECTION;
-let SlowQueryLogs: any = null;
-const DEFAULT_CHECK_AICODER_TOKEN_ELIGIBILITY: CheckAICoderTokenEligibilityFn = () => {
-	return Promise.resolve({
-		eligible: true
-	});
-};
-let checkAICoderTokenEligibility: CheckAICoderTokenEligibilityFn = DEFAULT_CHECK_AICODER_TOKEN_ELIGIBILITY;
-let configuredSlowQueryVerifierDependencies: SlowQueryVerifierDependencies | null = null;
-
-function resolveSlowQueryVerifierDependencies(
-	overrides?: Partial<SlowQueryVerifierDependencies>
-): SlowQueryVerifierDependencies {
-	const resolved: SlowQueryVerifierDependencies = {
-		...(configuredSlowQueryVerifierDependencies || {} as SlowQueryVerifierDependencies),
-		...(overrides || {})
-	};
-
-	if (!resolved.SlowQueryLogs) {
-		throw new Error('SlowQueryVerifier dependencies are not configured.');
-	}
-
-	return resolved;
-}
-
-function applySlowQueryVerifierDependencies(dependencies: SlowQueryVerifierDependencies): void {
-	configuredSlowQueryVerifierDependencies = dependencies;
-	ClientDBs = dependencies.ClientDBs || OPTIONAL_COLLECTION;
-	Clients = dependencies.Clients || OPTIONAL_COLLECTION;
-	SlowQueryLogs = dependencies.SlowQueryLogs;
-	AICoderApps = dependencies.AICoderApps || OPTIONAL_COLLECTION;
-	AIDashboardJobs = dependencies.AIDashboardJobs || OPTIONAL_COLLECTION;
-	checkAICoderTokenEligibility = dependencies.checkAICoderTokenEligibility || DEFAULT_CHECK_AICODER_TOKEN_ELIGIBILITY;
-}
-
-export function registerSlowQueryVerifierDependencies(dependencies: SlowQueryVerifierDependencies): void {
-	applySlowQueryVerifierDependencies(dependencies);
-	ensureSlowQueryVerifier();
-}
-
-const VERIFICATION_CHECK_INTERVAL_MS = 60 * 1000;
-const VERIFICATION_INTERVAL_MS = 5 * 60 * 1000;
-const VERIFICATION_ATTEMPTS = 3;
-const VERIFICATION_THRESHOLD_MS = 2000;
-const AUTO_OPTIMIZE_DEFAULT_IMPROVEMENT_RATIO = 0.7;
-const AUTO_OPTIMIZE_DEFAULT_RETURNED_DOC_TOLERANCE = 0.15;
-const AUTO_OPTIMIZE_DEFAULT_MAX_ATTEMPTS_PER_QUERY = 3;
-const AUTO_OPTIMIZE_DEFAULT_COOLDOWN_MINUTES = 120;
-const AUTO_OPTIMIZE_DEFAULT_MAX_ATTEMPTS_PER_FINGERPRINT = 4;
-const AUTO_OPTIMIZE_DEFAULT_FINGERPRINT_WINDOW_HOURS = 24;
-const AUTO_OPTIMIZE_DEFAULT_OUTPUT_COMPARE_MAX_DOCS = 10000;
-const DEFAULT_ERROR_ALERT_EMAIL = 'dev@resolveio.com';
-const MAX_LOCAL_NOTIFICATION_USERS = 5000;
-
-interface ExplainStageSummary {
-	stage: string;
-	path: string;
-	executionTimeMs?: number;
-	docsExamined?: number;
-	keysExamined?: number;
-	nReturned?: number;
-}
-
-export function ensureSlowQueryVerifier(serverConfig?: any): SlowQueryVerifier | null {
-	const existing = ResolveIOServer['SlowQueryVerifier'] as SlowQueryVerifier | null;
-	if (existing) {
-		return existing;
-	}
-
-	if (!configuredSlowQueryVerifierDependencies) {
-		return null;
-	}
-
-	const resolvedServerConfig = serverConfig || ResolveIOServer.getServerConfig();
-	if (!resolvedServerConfig) {
-		return null;
-	}
-
-	const verifier = new SlowQueryVerifier(resolvedServerConfig);
-	ResolveIOServer['SlowQueryVerifier'] = verifier;
-	return verifier;
-}
-
-interface ExecutionMetrics {
-	durationMs?: number;
-	docsExamined?: number;
-	nReturned?: number;
-	topStages: ExplainStageSummary[];
-}
-
-interface OutputFingerprint {
-	explicitSort: boolean;
-	docsCompared: number;
-	truncated: boolean;
-	orderedDigest: string;
-	unorderedDigest: string;
-	firstDocDigest: string;
-	lastDocDigest: string;
-	durationMs: number;
-	maxDocs: number;
-}
-
-interface OutputEquivalenceResult {
-	passed: boolean;
-	reason: string;
-	mode: 'ordered' | 'unordered' | 'unknown';
-	baseline?: OutputFingerprint;
-	after?: OutputFingerprint;
-}
-
-interface ExplainResult {
-	durationMs: number;
-	explainPlan: Record<string, any>;
-	explainStats: Record<string, any>;
-	stageSummaries: ExplainStageSummary[];
-}
-
-type SlowQueryVerifierErrorCode =
-	'client_db_not_found' |
-	'client_db_missing_uri' |
-	'client_db_missing_database' |
-	'main_db_unavailable' |
-	'aggregate_write_stage' |
-	'bson_too_large' |
-	'collection_missing';
-
-class SlowQueryVerifierError extends Error {
-	public readonly code: SlowQueryVerifierErrorCode;
-
-	constructor(code: SlowQueryVerifierErrorCode, message: string) {
-		super(message);
-		this.code = code;
-	}
-}
-
-interface SlowQueryVerifierConfig {
-	enabled: boolean;
-	fallbackToMainDB: boolean;
-	debugLogging: boolean;
-	configSource: string;
-	autofixRepoRoot: string;
-	autofixGithubOwner: string;
-	autofixGithubRepo: string;
-	autoOptimizeEnabled: boolean;
-	autoOptimizeWaitTimeoutMs: number;
-	autoOptimizeDurationRatioTarget: number;
-	autoOptimizeDocsRatioTarget: number;
-	autoOptimizeReturnedDocsTolerance: number;
-	autoOptimizeMaxAttemptsPerQuery: number;
-	autoOptimizeCooldownMinutes: number;
-	autoOptimizeMaxAttemptsPerFingerprint: number;
-	autoOptimizeFingerprintWindowHours: number;
-	autoOptimizeRequiredTokens: number;
-	autoOptimizeOutputCompareEnabled: boolean;
-	autoOptimizeRequireExactOutput: boolean;
-	autoOptimizeOutputMismatchRetryCount: number;
-	autoOptimizeOutputCompareMaxDocs: number;
-	escalationEmails: string[];
-}
-
-interface ExplainTarget {
-	type: 'client' | 'main';
-	dbName: string;
-	uri?: string;
-}
-
-type ExplainVerbosity = 'queryPlanner' | 'executionStats';
-
-export class SlowQueryVerifier {
-	private readonly _timer?: NodeJS.Timeout;
-	private readonly config: SlowQueryVerifierConfig;
-	private readonly autoOptimizeInFlight = new Set<string>();
-	private readonly autoOptimizeDependenciesAvailable: boolean;
-	private static readonly APP_SETTINGS_CACHE_TTL_MS = 10000;
-	private appSettingsAutoOptimizeCacheExpiresAt = 0;
-	private appSettingsAutoOptimizeCacheValue: boolean | null = null;
-
-	constructor(serverConfig?: any, dependencies?: Partial<SlowQueryVerifierDependencies>) {
-		const resolvedDependencies = resolveSlowQueryVerifierDependencies(dependencies);
-		applySlowQueryVerifierDependencies(resolvedDependencies);
-
-		this.config = SlowQueryVerifier.resolveConfig(serverConfig);
-		this.autoOptimizeDependenciesAvailable = !!(resolvedDependencies.AICoderApps && resolvedDependencies.AIDashboardJobs);
-
-		if (this.config.enabled) {
-			this._timer = setInterval(() => {
-				// eslint-disable-next-line no-restricted-syntax
-				this.poll().catch(err => {
-					console.error('Slow query verifier poll failed', err);
-				});
-			}, VERIFICATION_CHECK_INTERVAL_MS);
-
-			// eslint-disable-next-line no-restricted-syntax
-			this.poll().catch(err => {
-				console.error('Slow query verifier failed to start', err);
-			});
-		}
-	}
-
-	private static resolveConfig(serverConfig?: any): SlowQueryVerifierConfig {
-		const slowQueryConfig = (serverConfig && (serverConfig.slowQuery || serverConfig.SLOW_QUERY)) || {};
-		const verifierConfig = (slowQueryConfig && (slowQueryConfig.verifier || slowQueryConfig.slowQueryVerifier)) || {};
-		const autofixConfig = (serverConfig && (serverConfig.autofix || serverConfig.AUTOFIX)) || {};
-
-		const getBoolean = (envKey: string, configKey: string, fallback = true) => {
-			if (typeof process.env[envKey] !== 'undefined') {
-				return process.env[envKey] === 'true';
-			}
-			if (typeof verifierConfig[configKey] !== 'undefined') {
-				return !!verifierConfig[configKey];
-			}
-			return fallback;
-		};
-
-		const getNumber = (envKey: string, configKey: string, fallback: number): number => {
-			if (typeof process.env[envKey] !== 'undefined') {
-				const parsedEnv = Number(process.env[envKey]);
-				if (Number.isFinite(parsedEnv)) {
-					return parsedEnv;
-				}
-			}
-			if (typeof verifierConfig[configKey] !== 'undefined') {
-				const parsedConfig = Number(verifierConfig[configKey]);
-				if (Number.isFinite(parsedConfig)) {
-					return parsedConfig;
-				}
-			}
-			return fallback;
-		};
-
-		const getString = (envKey: string, configKey: string, fallback = ''): string => {
-			if (typeof process.env[envKey] !== 'undefined') {
-				return String(process.env[envKey] || '').trim();
-			}
-			if (typeof verifierConfig[configKey] !== 'undefined') {
-				return String(verifierConfig[configKey] || '').trim();
-			}
-			if (typeof slowQueryConfig[configKey] !== 'undefined') {
-				return String(slowQueryConfig[configKey] || '').trim();
-			}
-			if (typeof autofixConfig[configKey] !== 'undefined') {
-				return String(autofixConfig[configKey] || '').trim();
-			}
-			return fallback;
-		};
-
-		const parseEmails = (value: any): string[] => {
-			if (Array.isArray(value)) {
-				return value.map(item => `${item || ''}`.trim().toLowerCase()).filter(Boolean);
-			}
-			if (typeof value === 'string') {
-				return value.split(',').map(item => item.trim().toLowerCase()).filter(Boolean);
-			}
-			return [];
-		};
-
-		const clampRatio = (value: number, fallback: number): number => {
-			if (!Number.isFinite(value)) {
-				return fallback;
-			}
-			if (value <= 0 || value >= 1) {
-				return fallback;
-			}
-			return value;
-		};
-
-		const normalizePositiveInt = (value: number, fallback: number): number => {
-			if (!Number.isFinite(value) || value <= 0) {
-				return fallback;
-			}
-			return Math.floor(value);
-		};
-
-		const normalizeNonNegativeInt = (value: number, fallback = 0): number => {
-			if (!Number.isFinite(value) || value < 0) {
-				return fallback;
-			}
-			return Math.floor(value);
-		};
-
-		const escalationEmails = parseEmails(
-			process.env.SLOW_QUERY_ESCALATION_EMAILS
-				|| verifierConfig.escalationEmails
-				|| slowQueryConfig.escalationEmails
-				|| slowQueryConfig.notifyEmails
-		);
-
-		return {
-			enabled: true,
-			fallbackToMainDB: getBoolean('SLOW_QUERY_VERIFIER_FALLBACK_MAIN_DB', 'fallbackToMainDB', true),
-			debugLogging: getBoolean('SLOW_QUERY_VERIFIER_DEBUG_LOGS', 'debugLogging', false),
-			configSource: Object.keys(verifierConfig).length ? 'serverConfig' : 'defaults',
-			autofixRepoRoot: getString('AUTOFIX_REPO_ROOT', 'repoRoot', '/var/app/current'),
-			autofixGithubOwner: getString('AUTOFIX_GITHUB_OWNER', 'githubOwner', 'resolveio'),
-			autofixGithubRepo: getString('AUTOFIX_GITHUB_REPO', 'githubRepo', ''),
-			autoOptimizeEnabled: getBoolean('SLOW_QUERY_AUTO_OPTIMIZE_ENABLED', 'autoOptimizeEnabled', false),
-			autoOptimizeWaitTimeoutMs: getNumber('SLOW_QUERY_AUTO_OPTIMIZE_WAIT_TIMEOUT_MS', 'autoOptimizeWaitTimeoutMs', 45 * 60 * 1000),
-			autoOptimizeDurationRatioTarget: clampRatio(
-				getNumber('SLOW_QUERY_AUTO_OPTIMIZE_DURATION_RATIO', 'autoOptimizeDurationRatioTarget', AUTO_OPTIMIZE_DEFAULT_IMPROVEMENT_RATIO),
-				AUTO_OPTIMIZE_DEFAULT_IMPROVEMENT_RATIO
-			),
-			autoOptimizeDocsRatioTarget: clampRatio(
-				getNumber('SLOW_QUERY_AUTO_OPTIMIZE_DOCS_RATIO', 'autoOptimizeDocsRatioTarget', AUTO_OPTIMIZE_DEFAULT_IMPROVEMENT_RATIO),
-				AUTO_OPTIMIZE_DEFAULT_IMPROVEMENT_RATIO
-			),
-			autoOptimizeReturnedDocsTolerance: clampRatio(
-				getNumber('SLOW_QUERY_AUTO_OPTIMIZE_RETURNED_DOCS_TOLERANCE', 'autoOptimizeReturnedDocsTolerance', AUTO_OPTIMIZE_DEFAULT_RETURNED_DOC_TOLERANCE),
-				AUTO_OPTIMIZE_DEFAULT_RETURNED_DOC_TOLERANCE
-			),
-			autoOptimizeMaxAttemptsPerQuery: normalizePositiveInt(
-				getNumber('SLOW_QUERY_AUTO_OPTIMIZE_MAX_ATTEMPTS_PER_QUERY', 'autoOptimizeMaxAttemptsPerQuery', AUTO_OPTIMIZE_DEFAULT_MAX_ATTEMPTS_PER_QUERY),
-				AUTO_OPTIMIZE_DEFAULT_MAX_ATTEMPTS_PER_QUERY
-			),
-			autoOptimizeCooldownMinutes: normalizeNonNegativeInt(
-				getNumber('SLOW_QUERY_AUTO_OPTIMIZE_COOLDOWN_MINUTES', 'autoOptimizeCooldownMinutes', AUTO_OPTIMIZE_DEFAULT_COOLDOWN_MINUTES),
-				AUTO_OPTIMIZE_DEFAULT_COOLDOWN_MINUTES
-			),
-			autoOptimizeMaxAttemptsPerFingerprint: normalizePositiveInt(
-				getNumber(
-					'SLOW_QUERY_AUTO_OPTIMIZE_MAX_ATTEMPTS_PER_FINGERPRINT',
-					'autoOptimizeMaxAttemptsPerFingerprint',
-					AUTO_OPTIMIZE_DEFAULT_MAX_ATTEMPTS_PER_FINGERPRINT
-				),
-				AUTO_OPTIMIZE_DEFAULT_MAX_ATTEMPTS_PER_FINGERPRINT
-			),
-			autoOptimizeFingerprintWindowHours: normalizePositiveInt(
-				getNumber(
-					'SLOW_QUERY_AUTO_OPTIMIZE_FINGERPRINT_WINDOW_HOURS',
-					'autoOptimizeFingerprintWindowHours',
-					AUTO_OPTIMIZE_DEFAULT_FINGERPRINT_WINDOW_HOURS
-				),
-				AUTO_OPTIMIZE_DEFAULT_FINGERPRINT_WINDOW_HOURS
-			),
-			autoOptimizeRequiredTokens: normalizeNonNegativeInt(
-				getNumber('SLOW_QUERY_AUTO_OPTIMIZE_REQUIRED_TOKENS', 'autoOptimizeRequiredTokens', 0),
-				0
-			),
-			autoOptimizeOutputCompareEnabled: getBoolean('SLOW_QUERY_AUTO_OPTIMIZE_OUTPUT_COMPARE_ENABLED', 'autoOptimizeOutputCompareEnabled', true),
-			autoOptimizeRequireExactOutput: getBoolean('SLOW_QUERY_AUTO_OPTIMIZE_REQUIRE_EXACT_OUTPUT', 'autoOptimizeRequireExactOutput', true),
-			autoOptimizeOutputMismatchRetryCount: normalizeNonNegativeInt(
-				getNumber('SLOW_QUERY_AUTO_OPTIMIZE_OUTPUT_MISMATCH_RETRY_COUNT', 'autoOptimizeOutputMismatchRetryCount', 2),
-				2
-			),
-			autoOptimizeOutputCompareMaxDocs: normalizePositiveInt(
-				getNumber(
-					'SLOW_QUERY_AUTO_OPTIMIZE_OUTPUT_COMPARE_MAX_DOCS',
-					'autoOptimizeOutputCompareMaxDocs',
-					AUTO_OPTIMIZE_DEFAULT_OUTPUT_COMPARE_MAX_DOCS
-				),
-				AUTO_OPTIMIZE_DEFAULT_OUTPUT_COMPARE_MAX_DOCS
-			),
-			escalationEmails
-		};
-	}
-
-	private parseBooleanEnv(envKey: string): boolean | null {
-		if (typeof process.env[envKey] === 'undefined') {
-			return null;
-		}
-		return process.env[envKey] === 'true';
-	}
-
-	private async resolveAutoOptimizeEnabled(): Promise<boolean> {
-		if (!this.autoOptimizeDependenciesAvailable) {
-			return false;
-		}
-
-		const now = Date.now();
-		if (this.appSettingsAutoOptimizeCacheValue !== null && now < this.appSettingsAutoOptimizeCacheExpiresAt) {
-			return this.appSettingsAutoOptimizeCacheValue;
-		}
-
-		const envValue = this.parseBooleanEnv('SLOW_QUERY_AUTO_OPTIMIZE_ENABLED');
-		let enabled = envValue !== null ? envValue : !!this.config.autoOptimizeEnabled;
-		try {
-			if (AppSettings && typeof AppSettings.findOne === 'function') {
-				const activeSetting = await AppSettings.findOne({
-					is_active: {
-						$ne: false
-					}
-				}, {
-					sort: {
-						updatedAt: -1,
-						createdAt: -1
-					}
-				}) || await AppSettings.findOne({}, {
-					sort: {
-						updatedAt: -1,
-						createdAt: -1
-					}
-				});
-
-				if (activeSetting && typeof activeSetting.enable_slow_query_optimizer === 'boolean') {
-					enabled = !!activeSetting.enable_slow_query_optimizer;
-				}
-			}
-		}
-		catch (error) {
-			if (this.config?.debugLogging) {
-				console.warn('SlowQueryVerifier failed to read app settings slow-query optimizer toggle', error);
-			}
-		}
-
-		this.appSettingsAutoOptimizeCacheValue = enabled;
-		this.appSettingsAutoOptimizeCacheExpiresAt = now + SlowQueryVerifier.APP_SETTINGS_CACHE_TTL_MS;
-		return enabled;
-	}
-
-	private async poll() {
-		const autoOptimizeEnabled = await this.resolveAutoOptimizeEnabled();
-		if (!autoOptimizeEnabled) {
-			return;
-		}
-
-		const now = new Date();
-		const candidates = await SlowQueryLogs.find({
-			ignored: {
-				$ne: true
-			},
-			verification_status: {
-				$in: [null, 'pending']
-			},
-			$or: [
-				{
-					verification_next_run_at: {
-						$exists: false
-					}
-				},
-				{
-					verification_next_run_at: {
-						$lte: now
-					}
-				}
-			]
-		}, {
-			sort: {
-				verification_next_run_at: 1,
-				last_seen_at: -1
-			},
-			limit: 5
-		});
-
-		for (const candidate of candidates) {
-			await this.processCandidate(candidate);
-		}
-	}
-
-	private async processCandidate(candidate: SlowQueryLogModel) {
-		if (!candidate || !candidate._id) {
-			return;
-		}
-
-		const claimAt = new Date(Date.now() + VERIFICATION_INTERVAL_MS);
-		await SlowQueryLogs.updateOne({_id: candidate._id}, {
-			$set: {
-				verification_next_run_at: claimAt
-			}
-		});
-
-		try {
-			const result = await this.runExplain(candidate);
-			await this.handleExplainResult(candidate, result);
-		}
-		catch (err) {
-			await this.handleExplainError(candidate, err);
-		}
-	}
-
-	public async generateExplainForLog(logId: string): Promise<void> {
-		if (!logId) {
-			throw new Error('Slow query log ID is required.');
-		}
-
-		const log = await SlowQueryLogs.findOne({_id: logId});
-
-		if (!log) {
-			throw new Error('Slow query log not found.');
-		}
-
-		try {
-			const result = await this.runExplain(log);
-			await this.handleExplainResult(log, result);
-		}
-		catch (err) {
-			await this.handleExplainError(log, err);
-			throw err;
-		}
-	}
-
-	public async runLog(logId: string, options?: { force?: boolean }): Promise<{
-		status: 'in_progress' | 'success' | 'failed' | 'updated' | 'not_found';
-		reason?: string;
-		log?: SlowQueryLogModel;
-	}> {
-		if (!logId) {
-			throw new Error('Slow query log ID is required.');
-		}
-
-		const existing = await SlowQueryLogs.findOne({_id: logId});
-		if (!existing) {
-			return {
-				status: 'not_found',
-				reason: 'Slow query log not found.'
-			};
-		}
-
-		if (existing.ignored) {
-			throw new Error('Slow query log is ignored.');
-		}
-
-		if (this.autoOptimizeInFlight.has(logId) || existing.auto_fix_status === 'running' || existing.status === 'queued') {
-			return {
-				status: 'in_progress',
-				reason: 'Slow query optimization is already running.',
-				log: existing
-			};
-		}
-
-		this.autoOptimizeInFlight.add(logId);
-		try {
-			await this.runLogWithRetries(logId, {
-				force: !!options?.force,
-				retryOutputMismatch: true
-			});
-		}
-		finally {
-			this.autoOptimizeInFlight.delete(logId);
-		}
-
-		const updated = await SlowQueryLogs.findOne({_id: logId});
-		if (!updated) {
-			return {
-				status: 'not_found',
-				reason: 'Slow query log no longer exists.'
-			};
-		}
-
-		if (updated.auto_fix_status === 'running' || updated.status === 'queued') {
-			return {
-				status: 'in_progress',
-				reason: 'Slow query optimization queued.',
-				log: updated
-			};
-		}
-
-		if (updated.auto_fix_status === 'completed' || updated.status === 'optimized') {
-			return {
-				status: 'success',
-				reason: 'Slow query optimization completed.',
-				log: updated
-			};
-		}
-
-		if (updated.auto_fix_status === 'failed') {
-			return {
-				status: 'failed',
-				reason: updated.verification_notes || updated.auto_fix_disabled_reason || 'Slow query optimization failed.',
-				log: updated
-			};
-		}
-
-		return {
-			status: 'updated',
-			reason: updated.verification_notes || '',
-			log: updated
-		};
-	}
-
-	public async queueLogRun(logId: string, options?: { force?: boolean }): Promise<{
-		status: 'in_progress' | 'not_found' | 'failed';
-		reason?: string;
-		log?: SlowQueryLogModel;
-	}> {
-		if (!logId) {
-			throw new Error('Slow query log ID is required.');
-		}
-
-		const existing = await SlowQueryLogs.findOne({_id: logId});
-		if (!existing) {
-			return {
-				status: 'not_found',
-				reason: 'Slow query log not found.'
-			};
-		}
-
-		if (existing.ignored) {
-			throw new Error('Slow query log is ignored.');
-		}
-
-		if (this.autoOptimizeInFlight.has(logId) || existing.auto_fix_status === 'running' || existing.status === 'queued') {
-			return {
-				status: 'in_progress',
-				reason: 'Slow query optimization is already running.',
-				log: existing
-			};
-		}
-
-		const queuedAt = new Date();
-		await SlowQueryLogs.updateOne({_id: logId}, {
-			$set: {
-				status: 'queued',
-				auto_fix_status: 'queued',
-				verification_notes: 'Slow query optimization queued from super-admin.',
-				last_triaged_by: 'super-admin',
-				last_triaged_at: queuedAt
-			}
-		});
-		const queuedLog = (await SlowQueryLogs.findOne({_id: logId})) || existing;
-
-		this.autoOptimizeInFlight.add(logId);
-		setImmediate(async () => {
-			try {
-				await this.runLogWithRetries(logId, {
-					force: !!options?.force,
-					retryOutputMismatch: true
-				});
-			}
-			catch (error) {
-				console.error('Slow query queued run failed', {logId, error: (error as Error)?.message || error});
-			}
-			finally {
-				this.autoOptimizeInFlight.delete(logId);
-			}
-		});
-
-		return {
-			status: 'in_progress',
-			reason: 'Slow query optimization queued.',
-			log: queuedLog
-		};
-	}
-
-	public async deployLog(logId: string): Promise<{
-		status: 'success' | 'failed' | 'not_found';
-		reason?: string;
-		log?: SlowQueryLogModel;
-	}> {
-		if (!logId) {
-			throw new Error('Slow query log ID is required.');
-		}
-
-		const log = await SlowQueryLogs.findOne({_id: logId});
-		if (!log) {
-			return {
-				status: 'not_found',
-				reason: 'Slow query log not found.'
-			};
-		}
-
-		const jobId = String(log.openai_task_id || '').trim();
-		if (!jobId) {
-			throw new Error('Slow query log does not have a dashboard job id to deploy.');
-		}
-
-		try {
-			const job = await this.publishDashboardJob(jobId);
-			const publishOutcome = this.evaluateDashboardPublishOutcome(job);
-			const now = new Date();
-			const existingResult = (log.auto_fix_result && typeof log.auto_fix_result === 'object')
-				? {...log.auto_fix_result}
-				: {};
-			existingResult.manual_deploy = {
-				job_id: jobId,
-				requested_at: now,
-				success: publishOutcome.success,
-				message: publishOutcome.message,
-				branch_name: publishOutcome.branchName || existingResult.publish_branch || ''
-			};
-			if (publishOutcome.branchName) {
-				existingResult.publish_branch = publishOutcome.branchName;
-			}
-
-			await SlowQueryLogs.updateOne({_id: logId}, {
-				$set: {
-					auto_fix_result: existingResult,
-					verification_notes: publishOutcome.success
-						? `Manual deploy completed: ${publishOutcome.message}`
-						: `Manual deploy failed: ${publishOutcome.message}`,
-					last_triaged_by: 'super-admin',
-					last_triaged_at: now
-				}
-			});
-
-			const refreshed = (await SlowQueryLogs.findOne({_id: logId})) || log;
-			return {
-				status: publishOutcome.success ? 'success' : 'failed',
-				reason: publishOutcome.message,
-				log: refreshed
-			};
-		}
-		catch (error) {
-			const message = (error as Error)?.message || 'Manual deploy failed.';
-			await SlowQueryLogs.updateOne({_id: logId}, {
-				$set: {
-					verification_notes: `Manual deploy failed: ${message}`,
-					last_triaged_by: 'super-admin',
-					last_triaged_at: new Date()
-				}
-			});
-			const refreshed = await SlowQueryLogs.findOne({_id: logId});
-			return {
-				status: 'failed',
-				reason: message,
-				log: refreshed || log
-			};
-		}
-	}
-
-	private async runLogWithRetries(
-		logId: string,
-		options: { force: boolean; retryOutputMismatch: boolean }
-	): Promise<SlowQueryLogModel | null> {
-		const retryBudget = options.retryOutputMismatch
-			? (Number.isFinite(Number(this.config.autoOptimizeOutputMismatchRetryCount))
-				? Number(this.config.autoOptimizeOutputMismatchRetryCount)
-				: 0)
-			: 0;
-		let retriesUsed = 0;
-
-		while (true) {
-			await this.runAutoOptimization(logId, options.force);
-			const latest = await SlowQueryLogs.findOne({_id: logId});
-			if (!latest) {
-				return null;
-			}
-
-			if (
-				!options.retryOutputMismatch
-				|| !this.shouldRetryForOutputMismatch(latest)
-				|| retriesUsed >= retryBudget
-			) {
-				return latest;
-			}
-
-			const maxAttempts = Number.isFinite(Number(this.config.autoOptimizeMaxAttemptsPerQuery))
-				? Number(this.config.autoOptimizeMaxAttemptsPerQuery)
-				: 0;
-			const attemptsUsed = Number.isFinite(Number(latest.auto_fix_attempt_count))
-				? Number(latest.auto_fix_attempt_count)
-				: 0;
-			if (maxAttempts > 0 && attemptsUsed >= maxAttempts) {
-				return latest;
-			}
-
-			retriesUsed += 1;
-			await SlowQueryLogs.updateOne({_id: logId}, {
-				$set: {
-					verification_notes: `Output equivalence mismatch detected. Retrying (${retriesUsed}/${retryBudget}).`,
-					last_triaged_by: 'auto-slow-query',
-					last_triaged_at: new Date()
-				}
-			});
-		}
-	}
-
-	private shouldRetryForOutputMismatch(log: SlowQueryLogModel): boolean {
-		if (!log || log.ignored || log.auto_fix_status !== 'failed') {
-			return false;
-		}
-
-		const result = (log.auto_fix_result && typeof log.auto_fix_result === 'object')
-			? log.auto_fix_result
-			: {};
-		const validation = (result.validation && typeof result.validation === 'object')
-			? result.validation
-			: {};
-		const outputEquivalence = result.output_equivalence;
-		const validationReason = String(validation.reason || '').toLowerCase();
-		const notes = String(log.verification_notes || '').toLowerCase();
-
-		if (outputEquivalence && outputEquivalence.passed === false) {
-			return true;
-		}
-
-		return validationReason.includes('output equivalence')
-			|| notes.includes('output equivalence');
-	}
-
-	private async runExplain(log: SlowQueryLogModel, overrides?: SlowQueryExecutionOverride): Promise<ExplainResult> {
-		const collectionName = log.collection;
-
-		if (!collectionName) {
-			throw new Error('Slow query missing collection name.');
-		}
-
-		const target = await this.resolveExplainTarget(log);
-		let client: MongoClient | undefined;
-		let db: any;
-
-		try {
-			if (target.type === 'client') {
-				if (!target.uri) {
-					throw new SlowQueryVerifierError('client_db_missing_uri', 'Client DB missing uri.');
-				}
-
-				client = await MongoClient.connect(target.uri, {
-					connectTimeoutMS: 10000,
-					serverSelectionTimeoutMS: 10000,
-					readPreference: 'secondaryPreferred'
-				});
-				db = client.db(target.dbName);
-			}
-			else {
-				db = ResolveIOServer.getMainDB();
-			}
-
-			if (!db) {
-				throw new SlowQueryVerifierError('main_db_unavailable', 'Main server DB is not available.');
-			}
-
-			const effectiveLog = SlowQueryVerifier.applyQueryOverrides(log, overrides);
-			const pipeline = SlowQueryVerifier.extractPipelineFromLog(effectiveLog);
-			const filter = effectiveLog.filter ?? {};
-			const findOptions = SlowQueryVerifier.extractFindOptions(effectiveLog.options);
-			const aggregateOptions = SlowQueryVerifier.extractAggregateOptions(effectiveLog.options);
-			let explainResponse: Record<string, any>;
-			let usedVerbosity: ExplainVerbosity = 'executionStats';
-
-			const explainAggregate = async (verbosity: ExplainVerbosity): Promise<Record<string, any>> => {
-				if (SlowQueryVerifier.pipelineHasWriteStage(pipeline as any[])) {
-					throw new SlowQueryVerifierError('aggregate_write_stage', 'Aggregate pipeline includes a write stage; verification skipped.');
-				}
-
-				try {
-					return await db.collection(collectionName)
-						.aggregate(pipeline, {
-							...(aggregateOptions || {}),
-							readPreference: 'secondaryPreferred'
-						})
-						.explain(verbosity);
-				}
-				catch (err: any) {
-					if (SlowQueryVerifier.isAggregateExplainWriteConcernError(err)) {
-						return await db.command(
-							SlowQueryVerifier.buildAggregateExplainCommand(collectionName, pipeline as any[], aggregateOptions, verbosity),
-							{readPreference: 'secondaryPreferred'}
-						);
-					}
-
-					throw err;
-				}
-			};
-
-			try {
-				if (pipeline) {
-					explainResponse = await explainAggregate('executionStats');
-				}
-				else {
-					const cursor = SlowQueryVerifier.buildFindCursor(db.collection(collectionName), filter, findOptions);
-					explainResponse = await cursor.explain('executionStats');
-				}
-			}
-			catch (err: any) {
-				const code = err?.code;
-				const codeName = `${err?.codeName || ''}`.trim();
-				const message = `${err?.message || ''}`.toLowerCase();
-
-				if (code === 26 || codeName === 'NamespaceNotFound' || message.includes('ns does not exist')) {
-					throw new SlowQueryVerifierError('collection_missing', `Collection '${collectionName}' not found in ${target.type} DB.`);
-				}
-
-				if (pipeline) {
-					if (SlowQueryVerifier.isBsonObjectTooLargeError(err)) {
-						try {
-							explainResponse = await explainAggregate('queryPlanner');
-							usedVerbosity = 'queryPlanner';
-						}
-						catch (fallbackErr: any) {
-								if (SlowQueryVerifier.isBsonObjectTooLargeError(fallbackErr)) {
-									const durationMs = await SlowQueryVerifier.measureExecution(db, collectionName, pipeline, filter, findOptions, aggregateOptions);
-									if (!SlowQueryVerifier.isValidDuration(durationMs)) {
-										throw new SlowQueryVerifierError('bson_too_large', 'Explain/query payload too large to verify.');
-									}
-									return {
-										durationMs,
-										explainPlan: {},
-										explainStats: {},
-										stageSummaries: []
-									};
-								}
-
-							throw fallbackErr;
-						}
-					}
-					else {
-						throw err;
-					}
-				}
-				else {
-					if (SlowQueryVerifier.isBsonObjectTooLargeError(err)) {
-						try {
-							const cursor = SlowQueryVerifier.buildFindCursor(db.collection(collectionName), filter, findOptions);
-							explainResponse = await cursor.explain('queryPlanner');
-							usedVerbosity = 'queryPlanner';
-						}
-						catch {
-							const durationMs = await SlowQueryVerifier.measureExecution(db, collectionName, pipeline, filter, findOptions, aggregateOptions);
-								if (!SlowQueryVerifier.isValidDuration(durationMs)) {
-									throw new SlowQueryVerifierError('bson_too_large', 'Explain/query payload too large to verify.');
-								}
-								return {
-									durationMs,
-									explainPlan: {},
-									explainStats: {},
-									stageSummaries: []
-								};
-							}
-					}
-					else {
-						throw err;
-					}
-				}
-			}
-
-			let durationMs = SlowQueryVerifier.resolveDurationMs(explainResponse);
-
-			if (!SlowQueryVerifier.isValidDuration(durationMs)) {
-				durationMs = await SlowQueryVerifier.measureExecution(db, collectionName, pipeline, filter, findOptions, aggregateOptions);
-			}
-
-			const explainPlanRaw = explainResponse?.queryPlanner ?? explainResponse ?? {};
-			const explainStatsRaw = usedVerbosity === 'queryPlanner' ? {} : (explainResponse?.executionStats ?? {});
-			const stageSummaries = SlowQueryVerifier.extractStageSummaries(explainResponse, explainStatsRaw);
-
-			const explainPlan = SlowQueryVerifier.sanitizeExplainPayload(SlowQueryVerifier.normalizeExplainPayload(explainPlanRaw));
-			const explainStats = SlowQueryVerifier.sanitizeExplainPayload(SlowQueryVerifier.normalizeExplainPayload(explainStatsRaw));
-
-			return {
-				durationMs,
-				explainPlan,
-				explainStats,
-				stageSummaries
-			};
-		}
-		finally {
-			if (client) {
-				await client.close();
-			}
-		}
-	}
-
-	public async measureQuery(log: SlowQueryLogModel, overrides?: SlowQueryExecutionOverride): Promise<ExplainResult> {
-		return this.runExplain(log, overrides);
-	}
-
-	private async handleExplainResult(log: SlowQueryLogModel, result: ExplainResult) {
-		if (!log._id) {
-			return;
-		}
-
-		const existingRuns = (Array.isArray(log.verification_runs) ? log.verification_runs : [])
-			.filter(run => SlowQueryVerifier.isValidDuration(run.duration_ms));
-		const durationValid = SlowQueryVerifier.isValidDuration(result.durationMs);
-
-		if (!durationValid) {
-			if (this.config.debugLogging) {
-				console.warn('Slow query verification reported invalid duration; keeping log pending.', log.collection, result.durationMs);
-			}
-
-			const previousInvalidAttempts = typeof log.verification_invalid_attempts === 'number'
-				? log.verification_invalid_attempts
-				: 0;
-			const invalidAttempts = previousInvalidAttempts + 1;
-			const shouldFail = invalidAttempts >= VERIFICATION_ATTEMPTS;
-
-			const nextRunAt = new Date(Date.now() + VERIFICATION_INTERVAL_MS);
-			const updateOps: Record<string, any> = {
-				$set: {
-					verification_runs: existingRuns,
-					verification_status: shouldFail ? 'failed' : 'pending',
-					verification_invalid_attempts: invalidAttempts,
-					explain_plan: result.explainPlan,
-					explain_execution_stats: result.explainStats,
-					explain_generated_at: new Date(),
-					verification_notes: shouldFail ? 'Verification failed: invalid duration' : 'Explain returned invalid duration'
-				}
-			};
-
-			if (shouldFail) {
-				updateOps.$unset = {
-					verification_next_run_at: ''
-				};
-			}
-			else {
-				updateOps.$set.verification_next_run_at = nextRunAt;
-			}
-
-			await SlowQueryLogs.updateOne({_id: log._id}, updateOps);
-			return;
-		}
-
-		const runs: SlowQueryVerificationRun[] = existingRuns
-			.concat([
-				{
-					timestamp: new Date(),
-					duration_ms: result.durationMs
-				}
-			])
-			.slice(-VERIFICATION_ATTEMPTS);
-
-		const hasFastRun = runs.some(run => run.duration_ms < VERIFICATION_THRESHOLD_MS);
-
-		if (hasFastRun) {
-			// const durations = runs.map(run => `${run.duration_ms}ms`).join(', ');
-			// console.info('Removing slow query log; not consistently slow.', log.collection, durations);
-			await SlowQueryLogs.deleteOne({_id: log._id});
-			return;
-		}
-
-		const hasEnoughRuns = runs.length >= VERIFICATION_ATTEMPTS;
-		let status: SlowQueryVerificationStatus = hasEnoughRuns ? 'passed' : 'pending';
-		let nextRunAt: Date | undefined;
-
-		if (!hasEnoughRuns) {
-			nextRunAt = new Date(Date.now() + VERIFICATION_INTERVAL_MS);
-		}
-		const updateOps: Record<string, any> = {
-			$set: {
-				verification_runs: runs,
-				verification_status: status,
-				verification_invalid_attempts: 0,
-				explain_plan: result.explainPlan,
-				explain_execution_stats: result.explainStats,
-				explain_generated_at: new Date()
-			}
-		};
-
-		if (nextRunAt) {
-			updateOps.$set.verification_next_run_at = nextRunAt;
-		}
-		else {
-			updateOps.$unset = updateOps.$unset || {};
-			updateOps.$unset.verification_next_run_at = '';
-		}
-
-		await SlowQueryLogs.updateOne({_id: log._id}, updateOps);
-
-		if (status === 'passed') {
-			await this.assignSlowQueryCounter(log._id);
-			this.scheduleAutoOptimization(log._id);
-		}
-	}
-
-	private async handleExplainError(log: SlowQueryLogModel, err: any) {
-		if (!log._id) {
-			return;
-		}
-
-		const message = typeof err === 'string' ? err : err?.message || 'Unknown error';
-		const code = err instanceof SlowQueryVerifierError ? err.code : null;
-		const permanentFailure = !!code && ['client_db_not_found', 'client_db_missing_uri', 'client_db_missing_database', 'main_db_unavailable', 'aggregate_write_stage', 'bson_too_large', 'collection_missing'].includes(code);
-
-		if (this.config.debugLogging) {
-			console.error('Slow query verification error for', log.collection, message);
-		}
-		else if (!permanentFailure) {
-			console.warn('Slow query verification error for', log.collection, message);
-		}
-
-		if (permanentFailure) {
-			await SlowQueryLogs.updateOne({_id: log._id}, {
-				$set: {
-					verification_status: 'failed',
-					verification_notes: `Verification failed: ${message}`
-				},
-				$unset: {
-					verification_next_run_at: ''
-				}
-			});
-			return;
-		}
-
-		const nextRunAt = new Date(Date.now() + VERIFICATION_INTERVAL_MS);
-		await SlowQueryLogs.updateOne({_id: log._id}, {
-			$set: {
-				verification_next_run_at: nextRunAt,
-				verification_notes: `Verification error: ${message}`
-			}
-		});
-	}
-
-	private async assignSlowQueryCounter(logId: string) {
-		if (!logId) {
-			return;
-		}
-
-		const latest = await SlowQueryLogs.findOne({_id: logId});
-
-		if (!latest) {
-			return;
-		}
-
-		const hasNumber = typeof latest.slow_query_count === 'number' && latest.slow_query_count > 0;
-
-		if (hasNumber) {
-			return;
-		}
-
-		const counterValue = await ResolveIOServer.getMainServer().getMethodManager().callMethod('incCounter', 'slow_query');
-		const counterString = pad(counterValue, 6);
-
-		await SlowQueryLogs.updateOne({_id: logId}, {
-			$set: {
-				slow_query_count: counterValue,
-				slow_query_count_string: counterString
-			}
-		});
-	}
-
-	private scheduleAutoOptimization(logId: string): void {
-		if (!logId) {
-			return;
-		}
-		if (this.autoOptimizeInFlight.has(logId)) {
-			return;
-		}
-
-		this.autoOptimizeInFlight.add(logId);
-		this.runAutoOptimizationInBackground(logId);
-	}
-
-	private runAutoOptimizationInBackground(logId: string): void {
-		setImmediate(async () => {
-			try {
-				await this.runAutoOptimization(logId);
-			}
-			catch (error) {
-				console.error('Slow query auto optimization failed', {logId, error: (error as Error)?.message || error});
-			}
-			finally {
-				this.autoOptimizeInFlight.delete(logId);
-			}
-		});
-	}
-
-	private escapeRegex(value: string): string {
-		return String(value || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-	}
-
-	private getEscalationRecipients(): string[] {
-		const unique = new Set<string>();
-		(this.config.escalationEmails || []).forEach((entry) => {
-			const normalized = String(entry || '').trim().toLowerCase();
-			if (normalized) {
-				unique.add(normalized);
-			}
-		});
-		if (!unique.size) {
-			unique.add(DEFAULT_ERROR_ALERT_EMAIL);
-		}
-		return Array.from(unique);
-	}
-
-	private async sendSlowQueryEscalationNotice(log: SlowQueryLogModel, reason: string): Promise<void> {
-		const recipients = this.getEscalationRecipients();
-		if (!recipients.length || !log?._id) {
-			return;
-		}
-
-		const subject = `ResolveIO Slow Query Escalation: ${log.slow_query_count_string || log._id}`;
-		const body = [
-			'Slow-query auto optimization budget was exhausted and additional autonomous attempts were stopped.',
-			'',
-			`Reason: ${reason}`,
-			`Slow Query Log ID: ${log._id}`,
-			`Slow Query Counter: ${log.slow_query_count_string || 'n/a'}`,
-			`Collection: ${log.collection || 'unknown'}`,
-			`Query Hash: ${log.query_hash || 'n/a'}`,
-			`Client: ${log.client_name || log.client_slug || 'unknown'}`,
-			`Environment: ${log.environment || 'unknown'}`,
-			`Attempts: ${log.auto_fix_attempt_count || 0}/${this.config.autoOptimizeMaxAttemptsPerQuery}`,
-			'',
-			'The query has been marked ignored to protect customer AI credits. Manual tuning or explicit allow-list override is required.'
-		].join('\n');
-
-		const methodManager = ResolveIOServer.getMainServer().getMethodManager();
-		for (const recipient of recipients) {
-			try {
-				await methodManager.sendEmail(recipient, subject, body);
-			}
-			catch (error) {
-				console.error('Failed sending slow-query escalation email', {recipient, logId: log._id, error});
-			}
-		}
-	}
-
-	private async resolveSlowQueryClientTarget(log: SlowQueryLogModel): Promise<{ idClient: string; clientName: string }> {
-		const directId = String((log as any)?.id_client || '').trim();
-		if (directId) {
-			return {
-				idClient: directId,
-				clientName: String(log?.client_name || '').trim()
-			};
-		}
-
-		const candidates = [
-			String(log?.client_slug || '').trim(),
-			String(log?.client_name || '').trim(),
-			String(log?.source_app || '').trim()
-		].filter(Boolean);
-		for (const candidate of candidates) {
-			const escaped = this.escapeRegex(candidate);
-			const match = await Clients.findOne({
-				$or: [
-					{name: {$regex: `^${escaped}$`, $options: 'i'}},
-					{demo_name: {$regex: `^${escaped}$`, $options: 'i'}},
-					{project: {$regex: `^${escaped}$`, $options: 'i'}},
-					{repo: {$regex: `^${escaped}$`, $options: 'i'}}
-				]
-			}, {
-				projection: {
-					_id: 1,
-					name: 1
-				}
-			});
-			if (match?._id) {
-				return {
-					idClient: String(match._id || '').trim(),
-					clientName: String(match.name || log?.client_name || candidate || '').trim()
-				};
-			}
-		}
-
-		return {
-			idClient: '',
-			clientName: String(log?.client_name || '').trim()
-		};
-	}
-
-	private buildLocalInternalUserCriteria(): Record<string, any> {
-		return {
-			$and: [
-				{
-					is_customer: {
-						$ne: true
-					}
-				},
-				{
-					$nor: [
-						{
-							'other.id_customer': {
-								$exists: true,
-								$nin: ['', null]
-							}
-						},
-						{
-							id_customer: {
-								$exists: true,
-								$nin: ['', null]
-							}
-						}
-					]
-				}
-			]
-		};
-	}
-
-	private buildLocalAdminUserCriteria(): Record<string, any> {
-		return {
-			$or: [
-				{
-					'roles.super_admin': true
-				},
-				{
-					'roles.groups.name': {
-						$regex: 'admin',
-						$options: 'i'
-					}
-				},
-				{
-					'roles.groups.views': {
-						$regex: '^/manage'
-					}
-				},
-				{
-					'roles.groups.views': '/manage'
-				}
-			]
-		};
-	}
-
-	private async resolveLocalNotificationUserIds(isGeneratedApp: boolean): Promise<string[]> {
-		const andClauses: Record<string, any>[] = [
-			{
-				active: true
-			},
-			{
-				username: {
-					$exists: true
-				}
-			}
-		];
-
-		if (isGeneratedApp) {
-			andClauses.push(this.buildLocalInternalUserCriteria());
-		}
-		else {
-			andClauses.push(this.buildLocalAdminUserCriteria());
-		}
-
-		const users = await Users.find({
-			$and: andClauses
-		}, {
-			projection: {
-				_id: 1
-			},
-			limit: MAX_LOCAL_NOTIFICATION_USERS
-		});
-
-		if (!Array.isArray(users) || !users.length) {
-			return [];
-		}
-
-		const unique = new Set<string>();
-		for (const user of users) {
-			const idUser = String(user?._id || '').trim();
-			if (idUser) {
-				unique.add(idUser);
-			}
-			if (unique.size >= MAX_LOCAL_NOTIFICATION_USERS) {
-				break;
-			}
-		}
-		return Array.from(unique);
-	}
-
-	private async isGeneratedAICoderClient(idClient: string): Promise<boolean> {
-		const normalizedClientId = String(idClient || '').trim();
-		if (!normalizedClientId) {
-			return false;
-		}
-
-		const match = await AICoderApps.findOne({
-			client_id: normalizedClientId
-		}, {
-			projection: {
-				_id: 1
-			}
-		});
-
-		return !!match?._id;
-	}
-
-	private buildAICoderSlowQuerySummary(
-		stage: 'detected_auto_optimize_enabled' | 'completed_success' | 'completed_failed',
-		log: SlowQueryLogModel,
-		extra?: { reason?: string; notes?: string }
-	): string {
-		return buildGeneratedSlowQuerySummary(stage, {
-			collection: String(log?.collection || '').trim(),
-			source_app: String(log?.source_app || '').trim(),
-			environment: String(log?.environment || '').trim(),
-			baseline_duration_ms: Number((log as any)?.auto_fix_result?.baseline?.durationMs),
-			after_duration_ms: Number((log as any)?.auto_fix_result?.after?.durationMs),
-			reason: extra?.reason,
-			notes: extra?.notes
-		}, extra);
-	}
-
-	private buildResolveIOProjectSlowQueryDetails(log: SlowQueryLogModel, extra?: { reason?: string; notes?: string }): string {
-		const runDurations = Array.isArray(log?.verification_runs)
-			? log.verification_runs
-				.map(run => Number(run?.duration_ms))
-				.filter(duration => Number.isFinite(duration) && duration >= 0)
-			: [];
-
-		return buildResolveIOProjectSlowQueryDetails({
-			collection: log.collection || '',
-			client_name: log.client_name || log.client_slug || '',
-			source_app: log.source_app || '',
-			environment: log.environment || '',
-			query_hash: log.query_hash || '',
-			baseline_duration_ms: Number((log as any)?.auto_fix_result?.baseline?.durationMs),
-			after_duration_ms: Number((log as any)?.auto_fix_result?.after?.durationMs),
-			verification_run_durations_ms: runDurations,
-			log_id: log._id || '',
-			reason: extra?.reason,
-			notes: extra?.notes
-		});
-	}
-
-	private async notifyCustomerSlowQueryStatus(
-		stage: 'detected_auto_optimize_enabled' | 'completed_success' | 'completed_failed',
-		log: SlowQueryLogModel,
-		extra?: { reason?: string; notes?: string }
-	): Promise<void> {
-		if (!log?._id) {
-			return;
-		}
-
-		const target = await this.resolveSlowQueryClientTarget(log);
-		let isGeneratedApp = false;
-		if (target.idClient) {
-			isGeneratedApp = await this.isGeneratedAICoderClient(target.idClient);
-		}
-		else {
-			const generatedApp = await this.resolveAutoOptimizeApp(log);
-			isGeneratedApp = !!generatedApp;
-		}
-
-		if (!isGeneratedApp && stage !== 'completed_success') {
-			return;
-		}
-
-		const issueKey = String(log.query_hash || log._id || '').trim();
-		const dedupeKey = `slow-query:${issueKey}:${stage}`;
-		const metadata = {
-			log_id: log._id,
-			query_hash: log.query_hash || '',
-			collection: log.collection || '',
-			environment: log.environment || '',
-			source_app: log.source_app || '',
-			reason: extra?.reason || '',
-			notes: extra?.notes || ''
-		};
-		const targetPayload: Record<string, any> = {};
-		if (target.idClient) {
-			targetPayload.target_type = isGeneratedApp ? 'client_internal' : 'client_admins';
-			targetPayload.id_client = target.idClient;
-			targetPayload.client_name = target.clientName || undefined;
-		}
-		else {
-			const idUsers = await this.resolveLocalNotificationUserIds(isGeneratedApp);
-			if (!idUsers.length) {
-				return;
-			}
-			targetPayload.target_type = 'users';
-			targetPayload.id_users = idUsers;
-			targetPayload.client_name = target.clientName || undefined;
-		}
-
-		let payload: Record<string, any> = {};
-		if (isGeneratedApp) {
-			if (stage === 'detected_auto_optimize_enabled') {
-				payload = {
-					title: 'Slow query detected. Auto-optimization is running.',
-					message: 'We detected a slow query and started an automatic optimization workflow. We will notify you when it is complete.',
-					severity: 'info',
-					details: this.buildAICoderSlowQuerySummary(stage, log, extra)
-				};
-			}
-			else if (stage === 'completed_success') {
-				payload = {
-					title: 'Slow query optimization completed.',
-					message: `We optimized slow performance for ${log.collection || 'a collection'} and published the improvement.`,
-					severity: 'success',
-					details: this.buildAICoderSlowQuerySummary(stage, log, extra)
-				};
-			}
-			else {
-				payload = {
-					title: 'Slow query needs manual review.',
-					message: 'We could not complete automatic optimization for a slow query. Manual tuning is required.',
-					severity: 'warning',
-					details: this.buildAICoderSlowQuerySummary(stage, log, extra)
-				};
-			}
-		}
-		else {
-			payload = {
-				title: 'ResolveIO project slow query optimized',
-				message: `Slow-query optimization completed for ${log.collection || 'a collection'}.`,
-				severity: 'success',
-				details: this.buildResolveIOProjectSlowQueryDetails(log, extra)
-			};
-		}
-
-		try {
-			await ResolveIOServer.getMainServer().getMethodManager().callMethod('createCustomerNotification', {
-				...targetPayload,
-				category: 'slow-query',
-				source: 'slow-query-auto-optimize',
-				source_id: String(log._id || '').trim() || undefined,
-				dedupe_key: dedupeKey,
-				metadata,
-				...payload
-			});
-		}
-		catch (error) {
-			if (this.config.debugLogging) {
-				console.warn('Slow query customer notification failed', {
-					logId: log._id,
-					stage,
-					error: error?.message || error
-				});
-			}
-		}
-	}
-
-	private parseDate(value: any): Date | null {
-		if (!value) {
-			return null;
-		}
-		if (value instanceof Date && !Number.isNaN(value.getTime())) {
-			return value;
-		}
-		const parsed = new Date(value);
-		return Number.isNaN(parsed.getTime()) ? null : parsed;
-	}
-
-	private resolveFingerprintScopeKey(log: SlowQueryLogModel): string {
-		const explicit = String((log as any)?.fingerprint_scope_key || '').trim();
-		if (explicit) {
-			return explicit;
-		}
-
-		const normalize = (value: any): string => {
-			const normalized = String(value || '')
-				.trim()
-				.toLowerCase()
-				.replace(/\s+/g, ' ');
-			return normalized || '_';
-		};
-
-		const clientKey = normalize(log?.client_slug || log?.client_name || '');
-		const sourceApp = normalize(log?.source_app || '');
-		const environment = normalize(log?.environment || '');
-		const publication = normalize(log?.publication || '');
-		const serverUrl = normalize((log as any)?.server_url || '');
-		return [clientKey, sourceApp, environment, publication, serverUrl].join('|');
-	}
-
-	private buildFingerprintMatchQuery(log: SlowQueryLogModel): Record<string, any> {
-		const conditions: Record<string, any>[] = [];
-		const collection = String(log?.collection || '').trim();
-		if (collection) {
-			conditions.push({collection});
-		}
-
-		const explicitScopeKey = String((log as any)?.fingerprint_scope_key || '').trim();
-		const scopeKey = this.resolveFingerprintScopeKey(log);
-		if (scopeKey) {
-			const legacyScopeQuery: Record<string, any> = {};
-			if (String(log?.client_slug || '').trim()) {
-				legacyScopeQuery.client_slug = log.client_slug;
-			}
-			if (String(log?.environment || '').trim()) {
-				legacyScopeQuery.environment = log.environment;
-			}
-			if (String(log?.source_app || '').trim()) {
-				legacyScopeQuery.source_app = log.source_app;
-			}
-			if (String(log?.publication || '').trim()) {
-				legacyScopeQuery.publication = log.publication;
-			}
-			if (String((log as any)?.server_url || '').trim()) {
-				legacyScopeQuery.server_url = (log as any).server_url;
-			}
-			if (explicitScopeKey) {
-				conditions.push({fingerprint_scope_key: scopeKey});
-			}
-			else {
-				const scopeCandidates: Record<string, any>[] = [{_id: log?._id || ''}, {fingerprint_scope_key: scopeKey}];
-				if (Object.keys(legacyScopeQuery).length) {
-					scopeCandidates.push(legacyScopeQuery);
-				}
-				conditions.push({$or: scopeCandidates});
-			}
-		}
-
-		const canonicalHash = String((log as any)?.canonical_fingerprint_hash || '').trim();
-		const queryHash = String(log?.query_hash || '').trim();
-		if (canonicalHash && queryHash && canonicalHash !== queryHash) {
-			conditions.push({
-				$or: [
-					{canonical_fingerprint_hash: canonicalHash},
-					{
-						canonical_fingerprint_hash: {$exists: false},
-						query_hash: queryHash
-					}
-				]
-			});
-		}
-		else if (canonicalHash) {
-			conditions.push({canonical_fingerprint_hash: canonicalHash});
-		}
-		else if (queryHash) {
-			conditions.push({query_hash: queryHash});
-		}
-		else if (log?._id) {
-			conditions.push({_id: log._id});
-		}
-
-		if (!conditions.length) {
-			return {_id: log?._id || ''};
-		}
-		if (conditions.length === 1) {
-			return conditions[0];
-		}
-		return {$and: conditions};
-	}
-
-	private countAttemptsWithinWindow(log: SlowQueryLogModel, windowStart: Date): number {
-		const history = Array.isArray((log as any)?.auto_fix_attempt_history)
-			? ((log as any).auto_fix_attempt_history as any[])
-			: [];
-		let attemptsInWindow = 0;
-		history.forEach((entry) => {
-			const attemptAt = this.parseDate(entry);
-			if (attemptAt && attemptAt.getTime() >= windowStart.getTime()) {
-				attemptsInWindow += 1;
-			}
-		});
-		if (attemptsInWindow > 0) {
-			return attemptsInWindow;
-		}
-
-		const lastAttemptAt = this.parseDate((log as any)?.auto_fix_last_attempt_at);
-		const attemptsUsed = Number.isFinite(Number((log as any)?.auto_fix_attempt_count))
-			? Number((log as any).auto_fix_attempt_count)
-			: 0;
-		if (lastAttemptAt && lastAttemptAt.getTime() >= windowStart.getTime() && attemptsUsed > 0) {
-			return 1;
-		}
-		return 0;
-	}
-
-	private async resolveFingerprintAttemptsInWindow(log: SlowQueryLogModel, windowStart: Date): Promise<number> {
-		const matchQuery = this.buildFingerprintMatchQuery(log);
-		const matches = await SlowQueryLogs.find(matchQuery, {
-			limit: 200,
-			projection: {
-				_id: 1,
-				auto_fix_attempt_history: 1,
-				auto_fix_attempt_count: 1,
-				auto_fix_last_attempt_at: 1
-			}
-		}) as SlowQueryLogModel[];
-
-		let attempts = 0;
-		matches.forEach((entry) => {
-			attempts += this.countAttemptsWithinWindow(entry, windowStart);
-		});
-		return attempts;
-	}
-
-	private resolveCooldownDeadline(log: SlowQueryLogModel): Date | null {
-		const cooldownMinutes = Number.isFinite(Number(this.config.autoOptimizeCooldownMinutes))
-			? Number(this.config.autoOptimizeCooldownMinutes)
-			: 0;
-		if (cooldownMinutes <= 0) {
-			return null;
-		}
-
-		const lastAttemptAt = this.parseDate(log?.auto_fix_last_attempt_at);
-		if (!lastAttemptAt) {
-			return null;
-		}
-
-		return new Date(lastAttemptAt.getTime() + (cooldownMinutes * 60 * 1000));
-	}
-
-	private async markAutoOptimizeCooldownActive(log: SlowQueryLogModel, cooldownUntil: Date): Promise<void> {
-		if (!log?._id) {
-			return;
-		}
-		const reason = `Auto optimize cooldown is active until ${cooldownUntil.toISOString()}.`;
-		await SlowQueryLogs.updateOne({_id: log._id}, {
-			$set: {
-				status: 'investigating',
-				auto_fix_status: 'failed',
-				auto_fix_disabled_reason: reason,
-				verification_notes: reason,
-				verification_status: 'pending',
-				verification_next_run_at: cooldownUntil,
-				last_triaged_by: 'auto-slow-query',
-				last_triaged_at: new Date()
-			}
-		});
-	}
-
-	private async markAutoOptimizeTokenIneligible(log: SlowQueryLogModel, reason: string): Promise<void> {
-		if (!log?._id) {
-			return;
-		}
-
-		const message = `Auto optimize blocked by AI credit preflight: ${reason}`;
-		await SlowQueryLogs.updateOne({_id: log._id}, {
-			$set: {
-				status: 'ignored',
-				ignored: true,
-				auto_fix_status: 'failed',
-				auto_fix_disabled_reason: message,
-				verification_notes: message,
-				last_triaged_by: 'auto-slow-query',
-				last_triaged_at: new Date()
-			},
-			$unset: {
-				verification_next_run_at: ''
-			}
-		});
-
-		const refreshed = (await SlowQueryLogs.findOne({_id: log._id})) || log;
-		await this.sendSlowQueryEscalationNotice(refreshed, message);
-		await this.notifyCustomerSlowQueryStatus('completed_failed', refreshed, {reason: message});
-	}
-
-	private async markAutoOptimizeBudgetExceeded(log: SlowQueryLogModel, reason: string): Promise<void> {
-		if (!log?._id) {
-			return;
-		}
-		const attemptsUsed = Number.isFinite(Number(log.auto_fix_attempt_count))
-			? Number(log.auto_fix_attempt_count)
-			: 0;
-		const maxAttempts = Number.isFinite(Number(this.config.autoOptimizeMaxAttemptsPerQuery))
-			? Number(this.config.autoOptimizeMaxAttemptsPerQuery)
-			: 0;
-		const attemptSummary = maxAttempts > 0
-			? `Attempts on this log: ${attemptsUsed}/${maxAttempts}.`
-			: `Attempts on this log: ${attemptsUsed}.`;
-		const message = `${reason} Query marked ignored pending manual intervention. ${attemptSummary}`;
-		const matchQuery = this.buildFingerprintMatchQuery(log);
-
-		await SlowQueryLogs.updateMany(matchQuery, {
-			$set: {
-				status: 'ignored',
-				ignored: true,
-				auto_fix_status: 'failed',
-				auto_fix_disabled_reason: message,
-				verification_notes: message,
-				verification_status: 'failed',
-				last_triaged_by: 'auto-slow-query',
-				last_triaged_at: new Date()
-			},
-			$unset: {
-				verification_next_run_at: ''
-			}
-		});
-
-		const refreshed = (await SlowQueryLogs.findOne({_id: log._id})) || log;
-		await this.sendSlowQueryEscalationNotice(refreshed, reason);
-		await this.notifyCustomerSlowQueryStatus('completed_failed', refreshed, {reason});
-	}
-
-	private async maybeStopAutoOptimizeAfterFailure(logId: string, reason: string): Promise<void> {
-		if (!logId) {
-			return;
-		}
-		const maxAttempts = Number.isFinite(Number(this.config.autoOptimizeMaxAttemptsPerQuery))
-			? Number(this.config.autoOptimizeMaxAttemptsPerQuery)
-			: 0;
-		if (maxAttempts <= 0) {
-			return;
-		}
-		const latest = await SlowQueryLogs.findOne({_id: logId});
-		if (!latest || latest.ignored) {
-			return;
-		}
-		const attemptsUsed = Number.isFinite(Number(latest.auto_fix_attempt_count))
-			? Number(latest.auto_fix_attempt_count)
-			: 0;
-		if (attemptsUsed < maxAttempts) {
-			return;
-		}
-		await this.markAutoOptimizeBudgetExceeded(latest, reason);
-	}
-
-	private shouldFallbackDashboardMethod(error: any): boolean {
-		const message = `${error?.message || ''}`.toLowerCase();
-		return message.includes('not found')
-			|| message.includes('worker dispatch unavailable')
-			|| message.includes('no worker')
-			|| message.includes('unavailable for aidashboard');
-	}
-
-	private async createDashboardJob(payload: Record<string, any>): Promise<AIDashboardJob> {
-		const methodManager = ResolveIOServer.getMainServer().getMethodManager();
-		try {
-			return await methodManager.callMethod('aiDashboardCreateJob', payload);
-		}
-		catch (error) {
-			if (!this.shouldFallbackDashboardMethod(error)) {
-				throw error;
-			}
-		}
-
-		const manager: any = ResolveIOServer['AIDashboardManager'];
-		if (manager && manager.isEnabled && manager.isEnabled()) {
-			return await manager.createJob(payload);
-		}
-
-		throw new Error('AI Dashboard manager is not available.');
-	}
-
-	private async waitForDashboardJobStop(jobId: string, timeoutMs: number): Promise<void> {
-		const methodManager = ResolveIOServer.getMainServer().getMethodManager();
-		try {
-			await methodManager.callMethod('aiDashboardWaitForJobStop', jobId, timeoutMs);
-			return;
-		}
-		catch (error) {
-			if (!this.shouldFallbackDashboardMethod(error)) {
-				throw error;
-			}
-		}
-
-		const manager: any = ResolveIOServer['AIDashboardManager'];
-		if (manager && manager.isEnabled && manager.isEnabled()) {
-			await manager.waitForJobStop(jobId, timeoutMs);
-			return;
-		}
-
-		throw new Error('AI Dashboard manager is not available.');
-	}
-
-	private async isDashboardJobRunning(jobId: string): Promise<boolean> {
-		const methodManager = ResolveIOServer.getMainServer().getMethodManager();
-		try {
-			const running = await methodManager.callMethod('aiDashboardIsJobRunning', jobId);
-			return !!running;
-		}
-		catch (error) {
-			if (!this.shouldFallbackDashboardMethod(error)) {
-				throw error;
-			}
-		}
-
-		const manager: any = ResolveIOServer['AIDashboardManager'];
-		if (manager && manager.isEnabled && manager.isEnabled()) {
-			return !!manager.isJobRunning(jobId);
-		}
-
-		throw new Error('AI Dashboard manager is not available.');
-	}
-
-	private async publishDashboardJob(jobId: string): Promise<AIDashboardJob> {
-		const methodManager = ResolveIOServer.getMainServer().getMethodManager();
-		try {
-			return await methodManager.callMethod('aiDashboardPublishJob', jobId);
-		}
-		catch (error) {
-			if (!this.shouldFallbackDashboardMethod(error)) {
-				throw error;
-			}
-		}
-
-		const manager: any = ResolveIOServer['AIDashboardManager'];
-		if (manager && manager.isEnabled && manager.isEnabled() && typeof manager.publishJob === 'function') {
-			return await manager.publishJob(jobId);
-		}
-
-		throw new Error('AI Dashboard manager is not available.');
-	}
-
-	private evaluateDashboardPublishOutcome(job: AIDashboardJob): {success: boolean; message: string; branchName?: string} {
-		const logEntries = Array.isArray(job?.log) ? job.log : [];
-		const lastMatch = (predicate): string => {
-			for (let i = logEntries.length - 1; i >= 0; i -= 1) {
-				if (predicate(logEntries[i] || '')) {
-					return logEntries[i];
-				}
-			}
-			return '';
-		};
-
-		const failureEntry = lastMatch(entry => /publish failed|artifact publish failed|deploy failed/i.test(entry || ''));
-		if (failureEntry) {
-			return {success: false, message: failureEntry};
-		}
-
-		const publishEntry = lastMatch(entry => /Published build to /i.test(entry || ''));
-		if (publishEntry) {
-			const branchMatch = publishEntry.match(/\(([^()]+)\)\.?$/);
-			return {
-				success: true,
-				message: publishEntry,
-				branchName: (branchMatch && branchMatch[1]) ? branchMatch[1].trim() : undefined
-			};
-		}
-
-		const skippedEntry = lastMatch(entry => /Publish skipped/i.test(entry || ''));
-		if (skippedEntry) {
-			return {success: false, message: skippedEntry};
-		}
-
-		return {
-			success: false,
-			message: 'Dashboard job completed without a publish confirmation log entry.'
-		};
-	}
-
-	private resolveBaselineDurationMs(log: SlowQueryLogModel): number | undefined {
-		const runs = Array.isArray(log.verification_runs) ? log.verification_runs : [];
-		for (let i = runs.length - 1; i >= 0; i -= 1) {
-			const duration = runs[i]?.duration_ms;
-			if (SlowQueryVerifier.isValidDuration(duration)) {
-				return duration;
-			}
-		}
-		if (SlowQueryVerifier.isValidDuration(log.duration_ms)) {
-			return log.duration_ms;
-		}
-		if (SlowQueryVerifier.isValidDuration(log.avg_duration_ms)) {
-			return log.avg_duration_ms;
-		}
-		return undefined;
-	}
-
-	private static collectMetricValues(node: any, keySet: Set<string>, output: number[]): void {
-		if (!node || typeof node !== 'object') {
-			return;
-		}
-
-		if (Array.isArray(node)) {
-			node.forEach((entry) => SlowQueryVerifier.collectMetricValues(entry, keySet, output));
-			return;
-		}
-
-		Object.keys(node).forEach((key) => {
-			const value = (node as any)[key];
-			if (keySet.has(key) && typeof value === 'number' && Number.isFinite(value) && value >= 0) {
-				output.push(value);
-			}
-			SlowQueryVerifier.collectMetricValues(value, keySet, output);
-		});
-	}
-
-	private static asNonNegativeNumber(value: any): number | undefined {
-		return typeof value === 'number' && Number.isFinite(value) && value >= 0
-			? value
-			: undefined;
-	}
-
-	private static maxNumber(values: Array<number | undefined>): number | undefined {
-		const candidates = values.filter((value): value is number => typeof value === 'number');
-		return candidates.length ? Math.max(...candidates) : undefined;
-	}
-
-	private static sortStageSummaries(input: ExplainStageSummary[]): ExplainStageSummary[] {
-		return input.slice().sort((left, right) => {
-			const timeDiff = (right.executionTimeMs ?? -1) - (left.executionTimeMs ?? -1);
-			if (timeDiff !== 0) {
-				return timeDiff;
-			}
-
-			const docsDiff = (right.docsExamined ?? -1) - (left.docsExamined ?? -1);
-			if (docsDiff !== 0) {
-				return docsDiff;
-			}
-
-			const keysDiff = (right.keysExamined ?? -1) - (left.keysExamined ?? -1);
-			if (keysDiff !== 0) {
-				return keysDiff;
-			}
-
-			return `${left.path}|${left.stage}`.localeCompare(`${right.path}|${right.stage}`);
-		});
-	}
-
-	private static collectExecutionTreeStages(node: any, path: string, output: ExplainStageSummary[]): void {
-		if (!node || typeof node !== 'object') {
-			return;
-		}
-
-		const stageName = typeof node.stage === 'string' ? node.stage : 'execution-stage';
-		const executionTimeMs = SlowQueryVerifier.maxNumber([
-			SlowQueryVerifier.asNonNegativeNumber(node.executionTimeMillis),
-			SlowQueryVerifier.asNonNegativeNumber(node.executionTimeMillisEstimate)
-		]);
-		const docsExamined = SlowQueryVerifier.maxNumber([
-			SlowQueryVerifier.asNonNegativeNumber(node.totalDocsExamined),
-			SlowQueryVerifier.asNonNegativeNumber(node.docsExamined)
-		]);
-		const keysExamined = SlowQueryVerifier.maxNumber([
-			SlowQueryVerifier.asNonNegativeNumber(node.totalKeysExamined),
-			SlowQueryVerifier.asNonNegativeNumber(node.keysExamined)
-		]);
-		const nReturned = SlowQueryVerifier.maxNumber([
-			SlowQueryVerifier.asNonNegativeNumber(node.nReturned)
-		]);
-
-		if (
-			typeof executionTimeMs === 'number'
-			|| typeof docsExamined === 'number'
-			|| typeof keysExamined === 'number'
-			|| typeof nReturned === 'number'
-		) {
-			output.push({
-				stage: stageName,
-				path: path || 'executionStats.executionStages',
-				executionTimeMs,
-				docsExamined,
-				keysExamined,
-				nReturned
-			});
-		}
-
-		const recurse = (child: any, childPath: string) => {
-			if (!child) {
-				return;
-			}
-			if (Array.isArray(child)) {
-				child.forEach((entry, index) => {
-					SlowQueryVerifier.collectExecutionTreeStages(entry, `${childPath}[${index}]`, output);
-				});
-				return;
-			}
-			SlowQueryVerifier.collectExecutionTreeStages(child, childPath, output);
-		};
-
-		recurse(node.inputStage, `${path}.inputStage`);
-		recurse(node.inputStages, `${path}.inputStages`);
-		recurse(node.executionStages, `${path}.executionStages`);
-		recurse(node.outerStage, `${path}.outerStage`);
-		recurse(node.innerStage, `${path}.innerStage`);
-		recurse(node.leftChild, `${path}.leftChild`);
-		recurse(node.rightChild, `${path}.rightChild`);
-		recurse(node.thenStage, `${path}.thenStage`);
-		recurse(node.elseStage, `${path}.elseStage`);
-		recurse(node.shards, `${path}.shards`);
-	}
-
-	private static extractStageSummaries(explainResponse?: Record<string, any>, explainStats?: Record<string, any>): ExplainStageSummary[] {
-		const summaries: ExplainStageSummary[] = [];
-		const stages = explainResponse?.stages;
-
-		if (Array.isArray(stages)) {
-			stages.forEach((stageEntry, index) => {
-				if (!stageEntry || typeof stageEntry !== 'object') {
-					return;
-				}
-
-				const stageKey = Object.keys(stageEntry).find(key => key.startsWith('$')) || `stage_${index}`;
-				const stagePayload = (stageEntry as any)[stageKey];
-				const metricsSource = stageKey === '$cursor' && stagePayload?.executionStats
-					? stagePayload.executionStats
-					: stagePayload;
-				const executionStages = metricsSource?.executionStages || stagePayload?.executionStats?.executionStages;
-				const executionTimeMs = SlowQueryVerifier.maxNumber([
-					SlowQueryVerifier.asNonNegativeNumber(metricsSource?.executionTimeMillis),
-					SlowQueryVerifier.asNonNegativeNumber(metricsSource?.executionTimeMillisEstimate),
-					SlowQueryVerifier.asNonNegativeNumber(executionStages?.executionTimeMillis),
-					SlowQueryVerifier.asNonNegativeNumber(executionStages?.executionTimeMillisEstimate)
-				]);
-				const docsExamined = SlowQueryVerifier.maxNumber([
-					SlowQueryVerifier.asNonNegativeNumber(metricsSource?.totalDocsExamined),
-					SlowQueryVerifier.asNonNegativeNumber(metricsSource?.docsExamined),
-					SlowQueryVerifier.asNonNegativeNumber(executionStages?.totalDocsExamined),
-					SlowQueryVerifier.asNonNegativeNumber(executionStages?.docsExamined)
-				]);
-				const keysExamined = SlowQueryVerifier.maxNumber([
-					SlowQueryVerifier.asNonNegativeNumber(metricsSource?.totalKeysExamined),
-					SlowQueryVerifier.asNonNegativeNumber(metricsSource?.keysExamined),
-					SlowQueryVerifier.asNonNegativeNumber(executionStages?.totalKeysExamined),
-					SlowQueryVerifier.asNonNegativeNumber(executionStages?.keysExamined)
-				]);
-				const nReturned = SlowQueryVerifier.maxNumber([
-					SlowQueryVerifier.asNonNegativeNumber(metricsSource?.nReturned),
-					SlowQueryVerifier.asNonNegativeNumber(executionStages?.nReturned)
-				]);
-
-				if (
-					typeof executionTimeMs === 'number'
-					|| typeof docsExamined === 'number'
-					|| typeof keysExamined === 'number'
-					|| typeof nReturned === 'number'
-				) {
-					summaries.push({
-						stage: stageKey,
-						path: `stages[${index}]`,
-						executionTimeMs,
-						docsExamined,
-						keysExamined,
-						nReturned
-					});
-				}
-
-				if (executionStages) {
-					SlowQueryVerifier.collectExecutionTreeStages(
-						executionStages,
-						`stages[${index}].${stageKey}.executionStages`,
-						summaries
-					);
-				}
-			});
-		}
-
-		const executionRoot = explainStats?.executionStages
-			|| explainResponse?.executionStats?.executionStages
-			|| explainResponse?.executionStats;
-		if (executionRoot) {
-			SlowQueryVerifier.collectExecutionTreeStages(executionRoot, 'executionStats.executionStages', summaries);
-		}
-
-		const deduped = new Map<string, ExplainStageSummary>();
-		summaries.forEach((summary) => {
-			const key = [
-				summary.path,
-				summary.stage,
-				typeof summary.executionTimeMs === 'number' ? summary.executionTimeMs : '',
-				typeof summary.docsExamined === 'number' ? summary.docsExamined : '',
-				typeof summary.keysExamined === 'number' ? summary.keysExamined : '',
-				typeof summary.nReturned === 'number' ? summary.nReturned : ''
-			].join('|');
-			if (!deduped.has(key)) {
-				deduped.set(key, summary);
-			}
-		});
-
-		return SlowQueryVerifier.sortStageSummaries(Array.from(deduped.values()));
-	}
-
-	private resolveExecutionMetrics(
-		explainStats: Record<string, any>,
-		fallbackDuration?: number,
-		stageSummaries: ExplainStageSummary[] = []
-	): ExecutionMetrics {
-		const docsCandidates: number[] = [];
-		const returnedCandidates: number[] = [];
-		SlowQueryVerifier.collectMetricValues(explainStats || {}, new Set(['totalDocsExamined', 'docsExamined']), docsCandidates);
-		SlowQueryVerifier.collectMetricValues(explainStats || {}, new Set(['nReturned']), returnedCandidates);
-
-		const stageDocsCandidates = stageSummaries
-			.map(stage => stage.docsExamined)
-			.filter((value): value is number => typeof value === 'number');
-		const stageReturnedCandidates = stageSummaries
-			.map(stage => stage.nReturned)
-			.filter((value): value is number => typeof value === 'number');
-
-		const docsExamined = docsCandidates.length
-			? Math.max(...docsCandidates)
-			: (stageDocsCandidates.length ? Math.max(...stageDocsCandidates) : undefined);
-		const nReturned = returnedCandidates.length
-			? Math.max(...returnedCandidates)
-			: (stageReturnedCandidates.length ? Math.max(...stageReturnedCandidates) : undefined);
-		const durationMs = SlowQueryVerifier.isValidDuration(fallbackDuration)
-			? fallbackDuration
-			: undefined;
-
-		return {
-			durationMs,
-			docsExamined,
-			nReturned,
-			topStages: stageSummaries.slice(0, 5)
-		};
-	}
-
-	private evaluateOptimizationOutcome(
-		baseline: ExecutionMetrics,
-		after: ExecutionMetrics,
-		outputEquivalence?: OutputEquivalenceResult
-	): {
-		passed: boolean;
-		reason: string;
-		durationRatio?: number;
-		docsRatio?: number;
-		nReturnedDeltaRatio?: number;
-		outputEquivalence?: OutputEquivalenceResult;
-	} {
-		if (this.config.autoOptimizeRequireExactOutput) {
-			if (!this.config.autoOptimizeOutputCompareEnabled) {
-				return {
-					passed: false,
-					reason: 'Exact output equivalence is required but output comparison is disabled.',
-					outputEquivalence
-				};
-			}
-
-			if (!outputEquivalence) {
-				return {
-					passed: false,
-					reason: 'Output equivalence proof is required but was not generated.',
-					outputEquivalence
-				};
-			}
-		}
-
-		if (outputEquivalence && !outputEquivalence.passed) {
-			return {
-				passed: false,
-				reason: `Output equivalence failed: ${outputEquivalence.reason}`,
-				outputEquivalence
-			};
-		}
-
-		if (!SlowQueryVerifier.isValidDuration(baseline.durationMs) || !SlowQueryVerifier.isValidDuration(after.durationMs)) {
-			return {
-				passed: false,
-				reason: 'Unable to compare baseline and post-fix duration.',
-				outputEquivalence
-			};
-		}
-
-		const durationRatio = baseline.durationMs > 0 ? (after.durationMs / baseline.durationMs) : 1;
-		if (durationRatio > this.config.autoOptimizeDurationRatioTarget) {
-			return {
-				passed: false,
-				reason: `Duration did not improve enough (${round(durationRatio * 100, 0)}% of baseline).`,
-				durationRatio,
-				outputEquivalence
-			};
-		}
-
-		if (typeof baseline.docsExamined !== 'number' || typeof after.docsExamined !== 'number' || baseline.docsExamined <= 0) {
-			return {
-				passed: false,
-				reason: 'Docs examined metrics are missing for baseline or post-fix explain.',
-				durationRatio,
-				outputEquivalence
-			};
-		}
-
-		const docsRatio = after.docsExamined / baseline.docsExamined;
-		if (docsRatio > this.config.autoOptimizeDocsRatioTarget) {
-			return {
-				passed: false,
-				reason: `Docs examined did not improve enough (${round(docsRatio * 100, 0)}% of baseline).`,
-				durationRatio,
-				docsRatio,
-				outputEquivalence
-			};
-		}
-
-		if (typeof baseline.nReturned === 'number' && typeof after.nReturned === 'number') {
-			const denominator = Math.max(baseline.nReturned, 1);
-			const nReturnedDeltaRatio = Math.abs(after.nReturned - baseline.nReturned) / denominator;
-			if (nReturnedDeltaRatio > this.config.autoOptimizeReturnedDocsTolerance) {
-				return {
-					passed: false,
-					reason: `Returned document count changed too much (${round(nReturnedDeltaRatio * 100, 0)}% delta).`,
-					durationRatio,
-					docsRatio,
-					nReturnedDeltaRatio,
-					outputEquivalence
-				};
-			}
-
-			return {
-				passed: true,
-				reason: 'Query performance improved while keeping returned document count stable.',
-				durationRatio,
-				docsRatio,
-				nReturnedDeltaRatio,
-				outputEquivalence
-			};
-		}
-
-		return {
-			passed: false,
-			reason: 'Returned document metrics are missing for baseline or post-fix explain.',
-			durationRatio,
-			docsRatio,
-			outputEquivalence
-		};
-	}
-
-	private formatStageSummaryForPrompt(stage: ExplainStageSummary, index: number): string {
-		const metrics: string[] = [];
-		if (typeof stage.executionTimeMs === 'number') {
-			metrics.push(`time=${stage.executionTimeMs}ms`);
-		}
-		if (typeof stage.docsExamined === 'number') {
-			metrics.push(`docs=${stage.docsExamined}`);
-		}
-		if (typeof stage.keysExamined === 'number') {
-			metrics.push(`keys=${stage.keysExamined}`);
-		}
-		if (typeof stage.nReturned === 'number') {
-			metrics.push(`returned=${stage.nReturned}`);
-		}
-		return `${index + 1}. ${stage.stage} @ ${stage.path}${metrics.length ? ` (${metrics.join(', ')})` : ''}`;
-	}
-
-	private buildSlowQueryAutoOptimizeDescription(
-		log: SlowQueryLogModel,
-		app: AICoderAppModel,
-		baseline: ExecutionMetrics,
-		repoSlug: string
-	): string {
-		const topStages = Array.isArray(baseline.topStages) ? baseline.topStages : [];
-		const lookupExprInCount = SlowQueryVerifier.countLookupExprInPattern(Array.isArray(log.pipeline) ? log.pipeline : []);
-		const lines: string[] = [
-			'Autonomous slow-query optimization request.',
-			'',
-			'Hard requirements:',
-			'1. Before changing code, query the project MongoDB diagnostics logs for the latest slow-query context.',
-			'2. Query `slow-query-logs` using `_id` and `query_hash` from this task, then use the newest matching records.',
-			'3. If a previous dashboard job id is provided, query `ai-development-jobs` by that `_id` and review recent failure logs before retrying.',
-			'4. Treat `.dashboard-output/build-*.log` as primary build evidence, and `.build-output/build-*.log` as retained history when diagnosing failures.',
-			'5. Locate the source query in app code and optimize it safely (query shape contract must remain compatible).',
-			'6. Add or adjust indexes/code paths so docs examined and processing time drop significantly.',
-			'7. Measure before/after `explain(\"executionStats\")` and identify the slowest stages by execution time/docs examined.',
-			'8. Returned data must be exactly equivalent before and after optimization. Any output difference is a failed run.',
-			'9. In `$lookup`, avoid `$expr` + `$in` when equivalent `localField` / `foreignField` joins are possible and index-friendly.',
-			'10. Run build/lint checks and iterate until green.',
-			'11. Use workspace context `/var/ai-workspace/<id_slow_query>` and inspect transpiled runtime references under `/var/app/current`.',
-			'12. Publish to default branch and deploy artifacts automatically after build success.',
-			'',
-			`App: ${app.name || app._id}`,
-			`Repo: ${repoSlug || app.repo || 'unknown'}`,
-			`Slow Query #: ${log.slow_query_count_string || log._id || ''}`,
-			`Workspace Context Id: ${String(log?._id || '').trim() || 'n/a'}`,
-			`Workspace Path: /var/ai-workspace/${String(log?._id || '').trim() || '<id_slow_query>'}`,
-			`Collection: ${log.collection}`,
-			`Query Hash: ${log.query_hash}`,
-			`Slow Query Log Id: ${String(log?._id || '').trim() || 'n/a'}`,
-			`Previous Dashboard Job Id: ${String((log as any)?.openai_task_id || '').trim() || 'n/a'}`,
-			`Source App: ${log.source_app || 'n/a'}`,
-			`Environment: ${log.environment || 'n/a'}`,
-			`Baseline Duration (ms): ${typeof baseline.durationMs === 'number' ? baseline.durationMs : 'unknown'}`,
-			`Baseline Docs Examined: ${typeof baseline.docsExamined === 'number' ? baseline.docsExamined : 'unknown'}`,
-			`Baseline Returned Docs: ${typeof baseline.nReturned === 'number' ? baseline.nReturned : 'unknown'}`,
-			`Detected $lookup with $expr+$in: ${lookupExprInCount}`,
-			'',
-			'Baseline Hot Stages:',
-			...(topStages.length
-				? topStages.map((stage, index) => this.formatStageSummaryForPrompt(stage, index))
-				: ['No stage-level metrics were captured.']),
-			'',
-			'Filter:',
-			'```json',
-			JSON.stringify(log.filter || {}, null, 2),
-			'```',
-			'',
-			'Pipeline:',
-			'```json',
-			JSON.stringify(Array.isArray(log.pipeline) ? log.pipeline : [], null, 2),
-			'```',
-			'',
-			'Options:',
-			'```json',
-			JSON.stringify(log.options || {}, null, 2),
-			'```'
-		];
-		return lines.join('\n');
-	}
-
-	private resolveAutoOptimizeRepoSlug(app: AICoderAppModel | null): string {
-		const configuredRepo = String(this.config?.autofixGithubRepo || '').trim();
-		const configuredOwner = String(this.config?.autofixGithubOwner || 'resolveio').trim() || 'resolveio';
-		if (configuredRepo) {
-			return `${configuredOwner}/${configuredRepo}`;
-		}
-		return String(app?.repo || '').trim();
-	}
-
-	private resolveAutoOptimizeRepoPath(app: AICoderAppModel | null): string {
-		const configuredPath = String(this.config?.autofixRepoRoot || '').trim();
-		if (configuredPath) {
-			return configuredPath;
-		}
-		return String(app?.git_local_path || '').trim();
-	}
-
-	private static queryHasExplicitSort(pipeline?: any[], findOptions?: Record<string, any>): boolean {
-		const hasFindSort = !!(findOptions?.sort && typeof findOptions.sort === 'object' && Object.keys(findOptions.sort).length);
-		if (hasFindSort) {
-			return true;
-		}
-
-		if (!Array.isArray(pipeline)) {
-			return false;
-		}
-
-		return pipeline.some((stage) => {
-			if (!stage || typeof stage !== 'object') {
-				return false;
-			}
-			const sort = (stage as any).$sort;
-			return !!(sort && typeof sort === 'object' && Object.keys(sort).length);
-		});
-	}
-
-	private static countLookupExprInPattern(pipeline?: any[]): number {
-		if (!Array.isArray(pipeline)) {
-			return 0;
-		}
-
-		let count = 0;
-		pipeline.forEach((stage) => {
-			const lookup = stage && typeof stage === 'object' ? (stage as any).$lookup : undefined;
-			if (!lookup || typeof lookup !== 'object' || !Array.isArray(lookup.pipeline)) {
-				return;
-			}
-
-			const lookupPipelineJson = JSON.stringify(lookup.pipeline);
-			if (lookupPipelineJson.includes('"$expr"') && lookupPipelineJson.includes('"$in"')) {
-				count += 1;
-			}
-		});
-		return count;
-	}
-
-	private static buildBoundedPipelineForOutputCompare(pipeline: any[], maxDocs: number): any[] {
-		const cloned = SlowQueryVerifier.deepClone(pipeline);
-		if (!Number.isFinite(maxDocs) || maxDocs <= 0) {
-			return cloned;
-		}
-
-		cloned.push({
-			$limit: maxDocs + 1
-		});
-		return cloned;
-	}
-
-	private static buildBoundedFindOptionsForOutputCompare(findOptions: Record<string, any> | undefined, maxDocs: number): Record<string, any> | undefined {
-		const bounded = findOptions ? SlowQueryVerifier.deepClone(findOptions) : {};
-		if (!Number.isFinite(maxDocs) || maxDocs <= 0) {
-			return Object.keys(bounded).length ? bounded : undefined;
-		}
-
-		const compareLimit = maxDocs + 1;
-		if (typeof bounded.limit === 'number' && bounded.limit > 0) {
-			bounded.limit = Math.min(bounded.limit, compareLimit);
-		}
-		else {
-			bounded.limit = compareLimit;
-		}
-
-		return Object.keys(bounded).length ? bounded : undefined;
-	}
-
-	private static normalizeOutputValue(value: any): any {
-		if (value === null) {
-			return null;
-		}
-		if (typeof value === 'undefined') {
-			return null;
-		}
-		if (value instanceof Date) {
-			return {$date: value.toISOString()};
-		}
-		if (Buffer.isBuffer(value)) {
-			return {$binary: value.toString('base64')};
-		}
-
-		const valueType = typeof value;
-		if (valueType === 'string' || valueType === 'boolean') {
-			return value;
-		}
-		if (valueType === 'number') {
-			if (!Number.isFinite(value)) {
-				return '__non_finite_number__';
-			}
-			return value;
-		}
-		if (valueType === 'bigint') {
-			return value.toString();
-		}
-		if (valueType === 'function') {
-			return '__function__';
-		}
-
-		if (Array.isArray(value)) {
-			return value.map(entry => SlowQueryVerifier.normalizeOutputValue(entry));
-		}
-
-		if (valueType === 'object') {
-			if (typeof (value as any).toHexString === 'function') {
-				try {
-					return {$oid: (value as any).toHexString()};
-				}
-				catch {
-					// continue into generic object handling
-				}
-			}
-
-			if (typeof (value as any).toJSON === 'function') {
-				try {
-					return SlowQueryVerifier.normalizeOutputValue((value as any).toJSON());
-				}
-				catch {
-					// continue into generic object handling
-				}
-			}
-
-			const normalized: Record<string, any> = {};
-			Object.keys(value).sort().forEach((key) => {
-				normalized[key] = SlowQueryVerifier.normalizeOutputValue(value[key]);
-			});
-			return normalized;
-		}
-
-		return `${value}`;
-	}
-
-	private static digestOutputDocument(doc: any): string {
-		const normalized = SlowQueryVerifier.normalizeOutputValue(doc);
-		const serialized = JSON.stringify(normalized);
-		return createHash('sha256').update(serialized, 'utf8').digest('hex');
-	}
-
-	private async captureOutputFingerprint(log: SlowQueryLogModel, overrides?: SlowQueryExecutionOverride): Promise<OutputFingerprint> {
-		const collectionName = log.collection;
-		if (!collectionName) {
-			throw new Error('Slow query missing collection name.');
-		}
-
-		const target = await this.resolveExplainTarget(log);
-		let client: MongoClient | undefined;
-		let db: any;
-
-		try {
-			if (target.type === 'client') {
-				if (!target.uri) {
-					throw new SlowQueryVerifierError('client_db_missing_uri', 'Client DB missing uri.');
-				}
-
-				client = await MongoClient.connect(target.uri, {
-					connectTimeoutMS: 10000,
-					serverSelectionTimeoutMS: 10000,
-					readPreference: 'secondaryPreferred'
-				});
-				db = client.db(target.dbName);
-			}
-			else {
-				db = ResolveIOServer.getMainDB();
-			}
-
-			if (!db) {
-				throw new SlowQueryVerifierError('main_db_unavailable', 'Main server DB is not available.');
-			}
-
-			const maxDocs = Number.isFinite(Number(this.config.autoOptimizeOutputCompareMaxDocs))
-				? Number(this.config.autoOptimizeOutputCompareMaxDocs)
-				: AUTO_OPTIMIZE_DEFAULT_OUTPUT_COMPARE_MAX_DOCS;
-			const effectiveMaxDocs = maxDocs > 0 ? Math.floor(maxDocs) : AUTO_OPTIMIZE_DEFAULT_OUTPUT_COMPARE_MAX_DOCS;
-			const effectiveLog = SlowQueryVerifier.applyQueryOverrides(log, overrides);
-			const pipeline = SlowQueryVerifier.extractPipelineFromLog(effectiveLog);
-			const filter = effectiveLog.filter ?? {};
-			const findOptions = SlowQueryVerifier.extractFindOptions(effectiveLog.options);
-			const aggregateOptions = SlowQueryVerifier.extractAggregateOptions(effectiveLog.options);
-			const explicitSort = SlowQueryVerifier.queryHasExplicitSort(pipeline, findOptions);
-
-			let cursor: any;
-			if (pipeline) {
-				if (SlowQueryVerifier.pipelineHasWriteStage(pipeline as any[])) {
-					throw new SlowQueryVerifierError('aggregate_write_stage', 'Aggregate pipeline includes a write stage; output comparison skipped.');
-				}
-
-				const boundedPipeline = SlowQueryVerifier.buildBoundedPipelineForOutputCompare(
-					pipeline,
-					effectiveMaxDocs
-				);
-				cursor = db.collection(collectionName)
-					.aggregate(boundedPipeline, {
-						...(aggregateOptions || {}),
-						readPreference: 'secondaryPreferred'
-					});
-			}
-			else {
-				const boundedFindOptions = SlowQueryVerifier.buildBoundedFindOptionsForOutputCompare(
-					findOptions,
-					effectiveMaxDocs
-				);
-				cursor = SlowQueryVerifier.buildFindCursor(
-					db.collection(collectionName),
-					filter,
-					boundedFindOptions
-				);
-				}
-
-				const orderedHasher = createHash('sha256');
-				let unorderedSum = 0;
-				let unorderedXor = 0;
-				let docsCompared = 0;
-				let truncated = false;
-				let firstDocDigest = '';
-				let lastDocDigest = '';
-				const startedAt = Date.now();
-
-			try {
-				for await (const doc of cursor) {
-					if (docsCompared >= effectiveMaxDocs) {
-						truncated = true;
-						break;
-					}
-
-					const docDigest = SlowQueryVerifier.digestOutputDocument(doc);
-					if (!firstDocDigest) {
-						firstDocDigest = docDigest;
-					}
-						lastDocDigest = docDigest;
-						orderedHasher.update(docDigest, 'utf8');
-
-						const head = (parseInt(docDigest.slice(0, 8), 16) ^ parseInt(docDigest.slice(8, 16), 16)) >>> 0;
-						const tail = (parseInt(docDigest.slice(16, 24), 16) ^ parseInt(docDigest.slice(24, 32), 16)) >>> 0;
-						unorderedSum = (unorderedSum + head + tail) >>> 0;
-						unorderedXor = (unorderedXor ^ head ^ tail) >>> 0;
-						docsCompared += 1;
-					}
-				}
-				finally {
-				if (cursor && typeof cursor.close === 'function') {
-					await cursor.close();
-				}
-			}
-
-			const durationMs = Date.now() - startedAt;
-			return {
-				explicitSort,
-					docsCompared,
-					truncated,
-					orderedDigest: orderedHasher.digest('hex'),
-					unorderedDigest: `${unorderedSum.toString(16).padStart(8, '0')}:${unorderedXor.toString(16).padStart(8, '0')}`,
-					firstDocDigest,
-					lastDocDigest,
-					durationMs: SlowQueryVerifier.isValidDuration(durationMs) ? durationMs : -1,
-				maxDocs: effectiveMaxDocs
-			};
-		}
-		finally {
-			if (client) {
-				await client.close();
-			}
-		}
-	}
-
-	private compareOutputEquivalence(baseline: OutputFingerprint, after: OutputFingerprint): OutputEquivalenceResult {
-		const mode: 'ordered' | 'unordered' = (baseline.explicitSort || after.explicitSort)
-			? 'ordered'
-			: 'unordered';
-
-		if (baseline.truncated || after.truncated) {
-			return {
-				passed: false,
-				reason: `Result set exceeded output comparison cap (${Math.max(baseline.maxDocs, after.maxDocs)} docs).`,
-				mode,
-				baseline,
-				after
-			};
-		}
-
-		if (baseline.docsCompared !== after.docsCompared) {
-			return {
-				passed: false,
-				reason: `Returned row count changed (${baseline.docsCompared} -> ${after.docsCompared}).`,
-				mode,
-				baseline,
-				after
-			};
-		}
-
-		if (mode === 'ordered') {
-			if (baseline.orderedDigest !== after.orderedDigest) {
-				return {
-					passed: false,
-					reason: 'Ordered output digest changed.',
-					mode,
-					baseline,
-					after
-				};
-			}
-		}
-		else if (baseline.unorderedDigest !== after.unorderedDigest) {
-			return {
-				passed: false,
-				reason: 'Output set digest changed.',
-				mode,
-				baseline,
-				after
-			};
-		}
-
-		return {
-			passed: true,
-			reason: 'Output fingerprints are equivalent.',
-			mode,
-			baseline,
-			after
-		};
-	}
-
-	private async resolveAutoOptimizeApp(log: SlowQueryLogModel): Promise<AICoderAppModel | null> {
-		const exactRepoCandidate = String(log.environment || '').trim();
-		if (exactRepoCandidate && exactRepoCandidate.includes('/')) {
-			const escaped = this.escapeRegex(exactRepoCandidate);
-			const byRepo = await AICoderApps.findOne({
-				repo: {$regex: `^${escaped}$`, $options: 'i'}
-			}, {
-				sort: {
-					updatedAt: -1,
-					createdAt: -1
-				}
-			});
-			if (byRepo) {
-				return byRepo;
-			}
-		}
-
-		const clientCandidates = [
-			String(log.client_slug || '').trim(),
-			String(log.client_name || '').trim(),
-			String(log.source_app || '').trim()
-		].filter(Boolean);
-
-		for (const candidate of clientCandidates) {
-			const escaped = this.escapeRegex(candidate);
-			const byApp = await AICoderApps.findOne({
-				$or: [
-					{slug: {$regex: `^${escaped}$`, $options: 'i'}},
-					{name: {$regex: `^${escaped}$`, $options: 'i'}}
-				]
-			}, {
-				sort: {
-					updatedAt: -1,
-					createdAt: -1
-				}
-			});
-			if (byApp) {
-				return byApp;
-			}
-
-			const clientDoc = await Clients.findOne({
-				$or: [
-					{name: {$regex: `^${escaped}$`, $options: 'i'}},
-					{demo_name: {$regex: `^${escaped}$`, $options: 'i'}},
-					{project: {$regex: `^${escaped}$`, $options: 'i'}},
-					{repo: {$regex: `^${escaped}$`, $options: 'i'}}
-				]
-			});
-			if (!clientDoc?._id) {
-				continue;
-			}
-			const byClient = await AICoderApps.findOne({client_id: clientDoc._id}, {
-				sort: {
-					updatedAt: -1,
-					createdAt: -1
-				}
-			});
-			if (byClient) {
-				return byClient;
-			}
-		}
-
-		return null;
-	}
-
-	private async runAutoOptimization(logId: string, force = false): Promise<void> {
-		const autoOptimizeEnabled = await this.resolveAutoOptimizeEnabled();
-		if (!logId || (!autoOptimizeEnabled && !force)) {
-			return;
-		}
-
-		const log = await SlowQueryLogs.findOne({_id: logId});
-		if (!log || !log._id || log.ignored) {
-			return;
-		}
-		if (log.status === 'optimized' && !force) {
-			return;
-		}
-		if (log.auto_fix_status === 'running') {
-			return;
-		}
-		if (log.auto_fix_status === 'queued' && String(log.openai_task_id || '').trim()) {
-			return;
-		}
-
-		if (!force) {
-			const attemptsUsed = Number.isFinite(Number(log.auto_fix_attempt_count))
-				? Number(log.auto_fix_attempt_count)
-				: 0;
-			const maxAttempts = Number.isFinite(Number(this.config.autoOptimizeMaxAttemptsPerQuery))
-				? Number(this.config.autoOptimizeMaxAttemptsPerQuery)
-				: 0;
-			if (maxAttempts > 0 && attemptsUsed >= maxAttempts) {
-				await this.markAutoOptimizeBudgetExceeded(log, 'Auto optimize skipped');
-				return;
-			}
-
-			const cooldownDeadline = this.resolveCooldownDeadline(log);
-			if (cooldownDeadline && cooldownDeadline.getTime() > Date.now()) {
-				await this.markAutoOptimizeCooldownActive(log, cooldownDeadline);
-				return;
-			}
-
-			const fingerprintMaxAttempts = Number.isFinite(Number(this.config.autoOptimizeMaxAttemptsPerFingerprint))
-				? Number(this.config.autoOptimizeMaxAttemptsPerFingerprint)
-				: 0;
-			if (fingerprintMaxAttempts > 0) {
-				const windowHours = Number.isFinite(Number(this.config.autoOptimizeFingerprintWindowHours))
-					? Number(this.config.autoOptimizeFingerprintWindowHours)
-					: AUTO_OPTIMIZE_DEFAULT_FINGERPRINT_WINDOW_HOURS;
-				const windowStart = new Date(Date.now() - (windowHours * 60 * 60 * 1000));
-				const fingerprintAttempts = await this.resolveFingerprintAttemptsInWindow(log, windowStart);
-				if (fingerprintAttempts >= fingerprintMaxAttempts) {
-					await this.markAutoOptimizeBudgetExceeded(
-						log,
-						`Auto optimize skipped: fingerprint budget reached (${fingerprintAttempts}/${fingerprintMaxAttempts}) in the last ${windowHours}h.`
-					);
-					return;
-				}
-			}
-		}
-
-		const app = await this.resolveAutoOptimizeApp(log);
-		const resolvedRepoSlug = this.resolveAutoOptimizeRepoSlug(app);
-		const resolvedRepoPath = this.resolveAutoOptimizeRepoPath(app);
-		if (!app?._id || !resolvedRepoSlug) {
-			await SlowQueryLogs.updateOne({_id: logId}, {
-				$set: {
-					status: 'investigating',
-					auto_fix_status: 'failed',
-					verification_notes: 'Auto optimize skipped: unable to map slow query to AI Coder app/repo configuration.',
-					last_triaged_by: 'auto-slow-query',
-					last_triaged_at: new Date()
-				}
-			});
-			return;
-		}
-		const tokenEligibility = await checkAICoderTokenEligibility(
-			app._id,
-			this.config.autoOptimizeRequiredTokens > 0 ? this.config.autoOptimizeRequiredTokens : undefined
-		);
-		if (!tokenEligibility.allowed) {
-			const reason = `${tokenEligibility.message} Available: ${tokenEligibility.summary.available_tokens.toLocaleString()} tokens; required: ${tokenEligibility.required_tokens.toLocaleString()}.`;
-			await this.markAutoOptimizeTokenIneligible(log, reason);
-			return;
-		}
-
-		let baselineExplain: ExplainResult;
-		try {
-			baselineExplain = await this.runExplain(log);
-		}
-		catch (error) {
-			await SlowQueryLogs.updateOne({_id: logId}, {
-				$set: {
-					status: 'investigating',
-					auto_fix_status: 'failed',
-					auto_fix_result: {
-						baseline_error: error?.message || 'unknown'
-					},
-					verification_notes: `Auto optimize baseline measurement failed: ${error?.message || 'unknown error'}`,
-					last_triaged_by: 'auto-slow-query',
-					last_triaged_at: new Date()
-				}
-			});
-			await this.maybeStopAutoOptimizeAfterFailure(logId, 'Auto optimize baseline measurement failed');
-			return;
-		}
-
-		const baselineFallbackDuration = this.resolveBaselineDurationMs(log);
-		const baselineDurationMs = SlowQueryVerifier.isValidDuration(baselineExplain.durationMs)
-			? baselineExplain.durationMs
-			: baselineFallbackDuration;
-		const baselineMetrics = this.resolveExecutionMetrics(
-			baselineExplain.explainStats || {},
-			baselineDurationMs,
-			baselineExplain.stageSummaries || []
-		);
-
-		let baselineOutputFingerprint: OutputFingerprint | undefined;
-		if (this.config.autoOptimizeOutputCompareEnabled) {
-			try {
-				baselineOutputFingerprint = await this.captureOutputFingerprint(log);
-			}
-			catch (error) {
-				await SlowQueryLogs.updateOne({_id: logId}, {
-					$set: {
-						status: 'investigating',
-						auto_fix_status: 'failed',
-						auto_fix_result: {
-							baseline_error: error?.message || 'unknown'
-						},
-						verification_notes: `Auto optimize baseline output comparison failed: ${error?.message || 'unknown error'}`,
-						last_triaged_by: 'auto-slow-query',
-						last_triaged_at: new Date()
-					}
-				});
-				await this.maybeStopAutoOptimizeAfterFailure(logId, 'Auto optimize baseline output comparison failed');
-				return;
-			}
-		}
-
-		const title = `Optimize slow query ${log.slow_query_count_string || log.collection}`;
-		const description = this.buildSlowQueryAutoOptimizeDescription(log, app, baselineMetrics, resolvedRepoSlug);
-
-		let job: AIDashboardJob;
-		try {
-			job = await this.createDashboardJob({
-				project: app._id,
-				title,
-				description,
-				repo: resolvedRepoSlug,
-				path: resolvedRepoPath || undefined,
-				projectRoot: app.project_root || undefined
-			});
-		}
-		catch (error) {
-			await SlowQueryLogs.updateOne({_id: logId}, {
-				$set: {
-					status: 'investigating',
-					auto_fix_status: 'failed',
-					verification_notes: `Auto optimize enqueue failed: ${error?.message || 'unknown error'}`,
-					last_triaged_by: 'auto-slow-query',
-					last_triaged_at: new Date()
-				}
-			});
-			await this.maybeStopAutoOptimizeAfterFailure(logId, 'Auto optimize wait failed');
-			return;
-		}
-
-		const jobId = String(job?._id || '').trim();
-		if (!jobId) {
-			await SlowQueryLogs.updateOne({_id: logId}, {
-				$set: {
-					status: 'investigating',
-					auto_fix_status: 'failed',
-					verification_notes: 'Auto optimize enqueue failed: dashboard job id missing.',
-					last_triaged_by: 'auto-slow-query',
-					last_triaged_at: new Date()
-				}
-			});
-			return;
-		}
-
-		const attemptStartedAt = new Date();
-		await SlowQueryLogs.updateOne({_id: logId}, {
-			$inc: {
-				auto_fix_attempt_count: 1
-			},
-			$push: {
-				auto_fix_attempt_history: {
-					$each: [attemptStartedAt],
-					$slice: -100
-				}
-			},
-			$set: {
-				status: 'queued',
-				auto_fix_status: 'running',
-				openai_task_id: jobId,
-				auto_fix_last_attempt_at: attemptStartedAt,
-				auto_fix_disabled_reason: '',
-				verification_notes: `Auto optimize job queued (${jobId}).`,
-				last_triaged_by: 'auto-slow-query',
-				last_triaged_at: new Date()
-			}
-		});
-		const queuedLog = (await SlowQueryLogs.findOne({_id: logId})) || log;
-		await this.notifyCustomerSlowQueryStatus('detected_auto_optimize_enabled', queuedLog);
-
-		try {
-			await this.waitForDashboardJobStop(jobId, this.config.autoOptimizeWaitTimeoutMs);
-		}
-		catch (error) {
-			await SlowQueryLogs.updateOne({_id: logId}, {
-				$set: {
-					status: 'investigating',
-					auto_fix_status: 'failed',
-					auto_fix_result: {
-						job_id: jobId,
-						error: error?.message || 'timeout'
-					},
-					verification_notes: `Auto optimize wait failed: ${error?.message || 'timeout'}`,
-					last_triaged_by: 'auto-slow-query',
-					last_triaged_at: new Date()
-				}
-			});
-			await this.maybeStopAutoOptimizeAfterFailure(logId, 'Auto optimize job state check failed');
-			return;
-		}
-
-		let isRunning = false;
-		try {
-			isRunning = await this.isDashboardJobRunning(jobId);
-		}
-		catch (error) {
-			await SlowQueryLogs.updateOne({_id: logId}, {
-				$set: {
-					status: 'investigating',
-					auto_fix_status: 'failed',
-					auto_fix_result: {
-						job_id: jobId,
-						error: error?.message || 'unknown'
-					},
-					verification_notes: `Unable to confirm dashboard job state: ${error?.message || 'unknown error'}`,
-					last_triaged_by: 'auto-slow-query',
-					last_triaged_at: new Date()
-				}
-			});
-			return;
-		}
-
-		if (isRunning) {
-			await SlowQueryLogs.updateOne({_id: logId}, {
-				$set: {
-					status: 'investigating',
-					auto_fix_status: 'failed',
-					auto_fix_result: {
-						job_id: jobId,
-						error: 'still_running_after_timeout'
-					},
-					verification_notes: `Auto optimize timed out while waiting for dashboard job ${jobId}.`,
-					last_triaged_by: 'auto-slow-query',
-					last_triaged_at: new Date()
-				}
-			});
-			await this.maybeStopAutoOptimizeAfterFailure(logId, 'Auto optimize timed out');
-			return;
-		}
-
-		const finalJob = await AIDashboardJobs.findOne({_id: jobId}) as AIDashboardJob | null;
-		if (!finalJob || finalJob.phase !== 'COMPLETE' || finalJob.paused) {
-			await SlowQueryLogs.updateOne({_id: logId}, {
-				$set: {
-					status: 'investigating',
-					auto_fix_status: 'failed',
-					auto_fix_result: {
-						job_id: jobId,
-						job_phase: finalJob?.phase || 'missing',
-						job_paused: !!finalJob?.paused
-					},
-					verification_notes: `Auto optimize job ${jobId} did not complete successfully.`,
-					last_triaged_by: 'auto-slow-query',
-					last_triaged_at: new Date()
-				}
-			});
-			await this.maybeStopAutoOptimizeAfterFailure(logId, 'Auto optimize job did not complete');
-			return;
-		}
-
-		const publishOutcome = this.evaluateDashboardPublishOutcome(finalJob);
-		if (!publishOutcome.success) {
-			await SlowQueryLogs.updateOne({_id: logId}, {
-				$set: {
-					status: 'investigating',
-					auto_fix_status: 'failed',
-					auto_fix_result: {
-						job_id: jobId,
-						publish_message: publishOutcome.message,
-						publish_branch: publishOutcome.branchName || ''
-					},
-					verification_notes: `Auto optimize publish/deploy failed: ${publishOutcome.message}`,
-					last_triaged_by: 'auto-slow-query',
-					last_triaged_at: new Date()
-				}
-			});
-			await this.maybeStopAutoOptimizeAfterFailure(logId, 'Auto optimize publish/deploy failed');
-			return;
-		}
-
-		const refreshedLog = (await SlowQueryLogs.findOne({_id: logId})) || log;
-		let afterExplain: ExplainResult;
-		try {
-			afterExplain = await this.runExplain(refreshedLog);
-		}
-		catch (error) {
-			await SlowQueryLogs.updateOne({_id: logId}, {
-				$set: {
-					status: 'investigating',
-					auto_fix_status: 'failed',
-					auto_fix_result: {
-						job_id: jobId,
-						publish_message: publishOutcome.message,
-						publish_branch: publishOutcome.branchName || '',
-						validation_error: error?.message || 'unknown'
-					},
-					verification_notes: `Post-deploy validation failed: ${error?.message || 'unknown error'}`,
-					last_triaged_by: 'auto-slow-query',
-					last_triaged_at: new Date()
-				}
-			});
-			await this.maybeStopAutoOptimizeAfterFailure(logId, 'Auto optimize post-deploy validation failed');
-			return;
-		}
-
-		const afterMetrics = this.resolveExecutionMetrics(
-			afterExplain.explainStats || {},
-			afterExplain.durationMs,
-			afterExplain.stageSummaries || []
-		);
-
-		let outputEquivalence: OutputEquivalenceResult | undefined;
-		if (this.config.autoOptimizeOutputCompareEnabled) {
-			if (!baselineOutputFingerprint) {
-				outputEquivalence = {
-					passed: false,
-					reason: 'Baseline output fingerprint missing.',
-					mode: 'unknown'
-				};
-			}
-			else {
-				try {
-					const afterOutputFingerprint = await this.captureOutputFingerprint(refreshedLog);
-					outputEquivalence = this.compareOutputEquivalence(baselineOutputFingerprint, afterOutputFingerprint);
-				}
-				catch (error) {
-					await SlowQueryLogs.updateOne({_id: logId}, {
-						$set: {
-							status: 'investigating',
-							auto_fix_status: 'failed',
-							auto_fix_result: {
-								job_id: jobId,
-								publish_message: publishOutcome.message,
-								publish_branch: publishOutcome.branchName || '',
-								baseline: baselineMetrics,
-								after: afterMetrics,
-								output_equivalence_error: error?.message || 'unknown'
-							},
-							verification_notes: `Post-deploy output comparison failed: ${error?.message || 'unknown error'}`,
-							explain_plan: afterExplain.explainPlan,
-							explain_execution_stats: afterExplain.explainStats,
-							explain_generated_at: new Date(),
-							last_triaged_by: 'auto-slow-query',
-							last_triaged_at: new Date()
-						},
-						$push: {
-							verification_runs: {
-								timestamp: new Date(),
-								duration_ms: afterExplain.durationMs
-							}
-						}
-					});
-					await this.maybeStopAutoOptimizeAfterFailure(logId, 'Auto optimize output comparison failed');
-					return;
-				}
-			}
-		}
-
-		const validation = this.evaluateOptimizationOutcome(baselineMetrics, afterMetrics, outputEquivalence);
-		const autoFixResult = {
-			job_id: jobId,
-			publish_message: publishOutcome.message,
-			publish_branch: publishOutcome.branchName || '',
-			baseline: baselineMetrics,
-			after: afterMetrics,
-			output_equivalence: outputEquivalence,
-			validation
-		};
-
-		if (!validation.passed) {
-			await SlowQueryLogs.updateOne({_id: logId}, {
-				$set: {
-					status: 'investigating',
-					auto_fix_status: 'failed',
-					auto_fix_result: autoFixResult,
-					verification_notes: `Auto optimize validation failed: ${validation.reason}`,
-					explain_plan: afterExplain.explainPlan,
-					explain_execution_stats: afterExplain.explainStats,
-					explain_generated_at: new Date(),
-					last_triaged_by: 'auto-slow-query',
-					last_triaged_at: new Date()
-				},
-				$push: {
-					verification_runs: {
-						timestamp: new Date(),
-						duration_ms: afterExplain.durationMs
-					}
-				}
-			});
-			await this.maybeStopAutoOptimizeAfterFailure(logId, 'Auto optimize validation failed');
-			return;
-		}
-
-		await SlowQueryLogs.updateOne({_id: logId}, {
-			$set: {
-				status: 'optimized',
-				auto_fix_status: 'completed',
-				auto_fix_result: autoFixResult,
-				verification_notes: `Auto optimize completed: ${validation.reason}`,
-				explain_plan: afterExplain.explainPlan,
-				explain_execution_stats: afterExplain.explainStats,
-				explain_generated_at: new Date(),
-				last_triaged_by: 'auto-slow-query',
-				last_triaged_at: new Date()
-			},
-			$push: {
-				verification_runs: {
-					timestamp: new Date(),
-					duration_ms: afterExplain.durationMs
-				}
-			}
-		});
-		const optimizedLog = (await SlowQueryLogs.findOne({_id: logId})) || log;
-		await this.notifyCustomerSlowQueryStatus('completed_success', optimizedLog, {notes: validation.reason});
-	}
-
-	private async resolveClientDB(log: SlowQueryLogModel): Promise<ClientDBModel | undefined> {
-		const candidates = [
-			log.client_slug,
-			log.client_name,
-			log.source_app
-		].filter(Boolean);
-
-		if (!candidates.length) {
-			return undefined;
-		}
-
-		const matches = await ClientDBs.find({
-			$or: [
-				{ client: { $in: candidates } },
-				{ name: { $in: candidates } }
-			]
-		}, {
-			limit: 10
-		});
-
-		if (!Array.isArray(matches) || !matches.length) {
-			return undefined;
-		}
-
-		const prodMatch = matches.find(match => match && match.dev_server === false);
-		if (prodMatch) {
-			return prodMatch;
-		}
-
-		const devMatch = matches.find(match => match && match.dev_server === true);
-		if (devMatch) {
-			return devMatch;
-		}
-
-		return matches[0];
-	}
-
-	private async resolveExplainTarget(log: SlowQueryLogModel): Promise<ExplainTarget> {
-		const clientDB = await this.resolveClientDB(log);
-
-		if (clientDB) {
-			const dbName = clientDB.database || clientDB.name;
-			if (!dbName) {
-				throw new SlowQueryVerifierError('client_db_missing_database', 'Client DB missing database name.');
-			}
-
-			return {
-				type: 'client',
-				dbName,
-				uri: clientDB.uri
-			};
-		}
-
-		if (!this.config.fallbackToMainDB) {
-			throw new SlowQueryVerifierError('client_db_not_found', 'Could not resolve client DB for slow query verification.');
-		}
-
-		const mainDb = ResolveIOServer.getMainDB();
-		const mainDbName = mainDb?.databaseName;
-
-		if (!mainDb || !mainDbName) {
-			throw new SlowQueryVerifierError('main_db_unavailable', 'Main server DB is not available.');
-		}
-
-		return {
-			type: 'main',
-			dbName: mainDbName
-		};
-	}
-
-	private static extractPipelineFromLog(log: SlowQueryLogModel): any[] | undefined {
-		if (!log) {
-			return undefined;
-		}
-
-		if (Array.isArray(log.pipeline)) {
-			return log.pipeline;
-		}
-
-		if (log.filter && Array.isArray((log.filter as any).pipeline)) {
-			return (log.filter as any).pipeline;
-		}
-
-		return SlowQueryVerifier.extractPipelineOptions(log.options);
-	}
-
-	private static applyQueryOverrides(log: SlowQueryLogModel, overrides?: SlowQueryExecutionOverride): SlowQueryLogModel {
-		if (!overrides) {
-			return log;
-		}
-
-		const merged: SlowQueryLogModel = {...log};
-
-		if (overrides.filter !== undefined) {
-			merged.filter = overrides.filter;
-		}
-
-		if (overrides.options !== undefined) {
-			merged.options = overrides.options;
-		}
-
-		if (overrides.pipeline !== undefined) {
-			merged.pipeline = overrides.pipeline;
-		}
-
-		return merged;
-	}
-
-	private static extractPipelineOptions(options?: Record<string, any>): any[] | undefined {
-		if (!options) {
-			return undefined;
-		}
-
-		if (Array.isArray(options)) {
-			return options;
-		}
-
-		if (Array.isArray(options.pipeline)) {
-			return options.pipeline;
-		}
-
-		return undefined;
-	}
-
-	private static extractFindOptions(options?: Record<string, any>): Record<string, any> | undefined {
-		if (!options || Array.isArray(options)) {
-			return undefined;
-		}
-
-		const normalized: Record<string, any> = {...options};
-		if (Array.isArray(normalized.pipeline)) {
-			delete normalized.pipeline;
-		}
-
-		if (!Object.keys(normalized).length) {
-			return undefined;
-		}
-
-		return normalized;
-	}
-
-	private static resolveDurationMs(explainResponse: Record<string, any>): number {
-		const stats = explainResponse?.executionStats;
-		if (!stats) {
-			const stages = explainResponse?.stages;
-			if (Array.isArray(stages)) {
-				for (const stage of stages) {
-					const stageStats = stage?.$cursor?.executionStats;
-					const candidates = [
-						stageStats?.executionTimeMillis,
-						stageStats?.executionTimeMillisEstimate,
-						stageStats?.executionStages?.executionTimeMillis,
-						stageStats?.executionStages?.executionTimeMillisEstimate
-					];
-
-					for (const candidate of candidates) {
-						if (SlowQueryVerifier.isValidDuration(candidate)) {
-							return candidate;
-						}
-					}
-				}
-			}
-
-			return -1;
-		}
-
-		const candidates = [
-			stats.executionTimeMillis,
-			stats.executionTimeMillisEstimate,
-			stats.executionStages?.executionTimeMillis,
-			stats.executionStages?.executionTimeMillisEstimate
-		];
-
-		for (const candidate of candidates) {
-			if (SlowQueryVerifier.isValidDuration(candidate)) {
-				return candidate;
-			}
-		}
-
-		return -1;
-	}
-
-	private static pipelineHasWriteStage(pipeline: any[]): boolean {
-		if (!Array.isArray(pipeline)) {
-			return false;
-		}
-
-		return pipeline.some(stage => {
-			if (!stage || typeof stage !== 'object') {
-				return false;
-			}
-
-			return typeof (stage as any).$out !== 'undefined' || typeof (stage as any).$merge !== 'undefined';
-		});
-	}
-
-	private static extractAggregateOptions(options?: Record<string, any>): Record<string, any> | undefined {
-		if (!options || Array.isArray(options) || typeof options !== 'object') {
-			return undefined;
-		}
-
-		const allowedKeys = [
-			'allowDiskUse',
-			'bypassDocumentValidation',
-			'collation',
-			'comment',
-			'hint',
-			'let',
-			'maxTimeMS',
-			'maxAwaitTimeMS'
-		];
-
-		const result: Record<string, any> = {};
-		allowedKeys.forEach(key => {
-			if (typeof (options as any)[key] !== 'undefined') {
-				result[key] = (options as any)[key];
-			}
-		});
-
-		return Object.keys(result).length ? result : undefined;
-	}
-
-	private static buildAggregateExplainCommand(
-		collectionName: string,
-		pipeline: any[],
-		options?: Record<string, any>,
-		verbosity: ExplainVerbosity = 'executionStats'
-	): Record<string, any> {
-		const aggregateCommand: Record<string, any> = {
-			aggregate: collectionName,
-			pipeline,
-			cursor: {}
-		};
-
-		if (options && typeof options === 'object') {
-			Object.keys(options).forEach(key => {
-				if (typeof (options as any)[key] !== 'undefined') {
-					aggregateCommand[key] = (options as any)[key];
-				}
-			});
-		}
-
-		return {
-			explain: aggregateCommand,
-			verbosity
-		};
-	}
-
-	private static isAggregateExplainWriteConcernError(err: any): boolean {
-		const message = `${err?.message || ''}`;
-		return message.includes('Option "explain" cannot be used on an aggregate call with writeConcern');
-	}
-
-	private static isBsonObjectTooLargeError(err: any): boolean {
-		const message = `${err?.message || ''}`;
-		return message.includes('BSONObj size:') && message.includes('is invalid');
-	}
-
-	private static isValidDuration(value: any): value is number {
-		return typeof value === 'number' && !Number.isNaN(value) && value >= 0;
-	}
-
-	private static buildFindCursor(collection: any, filter: Record<string, any>, findOptions?: Record<string, any>) {
-		const cursorOptions: Record<string, any> = {};
-
-		if (findOptions) {
-			Object.keys(findOptions).forEach(key => {
-				if (['sort', 'skip', 'limit', 'projection', 'fields'].includes(key)) {
-					return;
-				}
-
-				cursorOptions[key] = findOptions[key];
-			});
-		}
-
-		cursorOptions.readPreference = 'secondaryPreferred';
-
-		let cursor = collection.find(filter || {}, cursorOptions);
-
-		const projection = findOptions?.projection ?? findOptions?.fields;
-		if (projection && typeof projection === 'object') {
-			cursor = cursor.project(projection);
-		}
-
-		const sort = findOptions?.sort;
-		if (sort && typeof sort === 'object') {
-			cursor = cursor.sort(sort);
-		}
-
-		const skip = findOptions?.skip;
-		if (typeof skip === 'number') {
-			cursor = cursor.skip(skip);
-		}
-
-		const limit = findOptions?.limit;
-		if (typeof limit === 'number') {
-			cursor = cursor.limit(limit);
-		}
-
-		return cursor;
-	}
-
-	private static async measureExecution(
-		db: any,
-		collectionName: string,
-		pipeline?: any[],
-		filter?: Record<string, any>,
-		findOptions?: Record<string, any>,
-		aggregateOptions?: Record<string, any>
-	): Promise<number> {
-		const start = Date.now();
-
-		try {
-			if (Array.isArray(pipeline)) {
-				await db.collection(collectionName)
-					.aggregate(pipeline, {
-						...(aggregateOptions || {}),
-						readPreference: 'secondaryPreferred'
-					})
-					.toArray();
-			}
-			else {
-				const cursor = SlowQueryVerifier.buildFindCursor(
-					db.collection(collectionName),
-					filter ?? {},
-					findOptions
-				);
-				await cursor.toArray();
-			}
-		}
-		catch (err) {
-			if (!SlowQueryVerifier.isBsonObjectTooLargeError(err)) {
-				console.error('Slow query measurement execution failed for', collectionName, err);
-			}
-			return -1;
-		}
-
-		const duration = Date.now() - start;
-		return SlowQueryVerifier.isValidDuration(duration) ? duration : -1;
-	}
-
-	private static normalizeExplainPayload(input?: any): Record<string, any> {
-		const cloned = SlowQueryVerifier.deepClone(input ?? {});
-		return typeof cloned === 'object' && cloned !== null ? cloned : {};
-	}
-
-	private static sanitizeExplainPayload(payload: Record<string, any>, maxBytes = 2 * 1024 * 1024): Record<string, any> {
-		try {
-			const json = JSON.stringify(payload);
-			const bytes = Buffer.byteLength(json, 'utf8');
-			return bytes <= maxBytes ? payload : {};
-		}
-		catch {
-			return {};
-		}
-	}
-
-	private static deepClone(value: any): any {
-		if (value === null || typeof value !== 'object') {
-			return value;
-		}
-
-		if (Array.isArray(value)) {
-			return value.map(item => SlowQueryVerifier.deepClone(item));
-		}
-
-		if (typeof value.toJSON === 'function') {
-			try {
-				return SlowQueryVerifier.deepClone(value.toJSON());
-			}
-			catch {
-				// fall through to manual clone
-			}
-		}
-
-		const result: Record<string, any> = {};
-		Object.keys(value).forEach(key => {
-			result[key] = SlowQueryVerifier.deepClone(value[key]);
-		});
-
-		return result;
-	}
-}