@resolveio/server-lib 22.3.221 → 22.3.222

package/src/managers/error-auto-fix.manager.ts

@@ -1,2767 +0,0 @@
-import { ResolveIOServer } from '../resolveio-server-app';
-import { objectIdHexString, pad } from '../util/common';
-import axios, { AxiosRequestConfig } from 'axios';
-import { createHash } from 'crypto';
-import { URL } from 'url';
-import { Users } from '../collections/user.collection';
-import { AppSettings } from '../collections/app-setting.collection';
-import { buildGeneratedAppAutoFixSummary, buildResolveIOProjectAutoFixDetails } from './customer-notification-content.manager';
-import { ErrorReportAttachment, ErrorReportPayload } from '../types/error-report';
-
-type AICoderAppModel = Record<string, any>;
-type AIDashboardJob = Record<string, any>;
-type ClientModel = Record<string, any>;
-type ErrorAutoFixLogModel = Record<string, any>;
-
-export interface ErrorAutoFixManagerDependencies {
-	Clients?: any;
-	ErrorAutoFixLogs: any;
-	AICoderApps?: any;
-	AIDashboardJobs?: any;
-}
-
-const OPTIONAL_COLLECTION = {
-	findOne: () => Promise.resolve(null),
-	findById: () => Promise.resolve(null),
-	find: () => Promise.resolve([])
-};
-
-let AICoderApps: any = OPTIONAL_COLLECTION;
-let AIDashboardJobs: any = OPTIONAL_COLLECTION;
-let Clients: any = OPTIONAL_COLLECTION;
-let ErrorAutoFixLogs: any = null;
-let configuredErrorAutoFixDependencies: ErrorAutoFixManagerDependencies | null = null;
-
-function resolveErrorAutoFixManagerDependencies(
-	overrides?: Partial<ErrorAutoFixManagerDependencies>
-): ErrorAutoFixManagerDependencies {
-	const resolved: ErrorAutoFixManagerDependencies = {
-		...(configuredErrorAutoFixDependencies || {} as ErrorAutoFixManagerDependencies),
-		...(overrides || {})
-	};
-
-	if (!resolved.ErrorAutoFixLogs) {
-		throw new Error('ErrorAutoFixManager dependencies are not configured.');
-	}
-
-	return resolved;
-}
-
-function applyErrorAutoFixDependencies(dependencies: ErrorAutoFixManagerDependencies): void {
-	configuredErrorAutoFixDependencies = dependencies;
-	Clients = dependencies.Clients || OPTIONAL_COLLECTION;
-	ErrorAutoFixLogs = dependencies.ErrorAutoFixLogs;
-	AICoderApps = dependencies.AICoderApps || OPTIONAL_COLLECTION;
-	AIDashboardJobs = dependencies.AIDashboardJobs || OPTIONAL_COLLECTION;
-}
-
-export function registerErrorAutoFixManagerDependencies(dependencies: ErrorAutoFixManagerDependencies): void {
-	applyErrorAutoFixDependencies(dependencies);
-	ensureErrorAutoFixManager();
-}
-
-interface AutoFixConfig {
-	enabled: boolean;
-	repoRoot: string;
-	baseBranch: string;
-	branchPrefix: string;
-	githubToken?: string;
-	githubOwner: string;
-	githubRepo: string;
-	commandTimeoutMs: number;
-	notifyEmails: string[];
-	debugLogging: boolean;
-	configSource: string;
-	openaiEnvironment?: string;
-	openaiProjectId?: string;
-	autoOptimizeEnabled: boolean;
-	ingestKeys: string[];
-	dashboardWorkflowEnabled: boolean;
-	dashboardFallbackToGithub: boolean;
-	dashboardWaitTimeoutMs: number;
-	dashboardPublishRequired: boolean;
-	maxAutoRunAttemptsPerIssue: number;
-	escalationEmails: string[];
-}
-
-interface ErrorEmail {
-	key: string;
-	subject: string;
-	body: string;
-	from?: string;
-	messageId?: string;
-	hash?: string;
-	rawHash?: string;
-	issueHash?: string;
-	logId?: string;
-	raw: string;
-	fromAddress?: string;
-	id_client?: string;
-	client_name?: string;
-	source_type?: 'app' | 'infrastructure' | 'noise';
-	classification_reason?: string;
-	openai_environment?: string;
-	sourceApp?: string;
-	sourceEnvironment?: string;
-	severity?: string;
-	reportedBy?: string;
-	reportMetadata?: Record<string, any>;
-	reportContext?: Record<string, any>;
-	attachments?: ErrorReportAttachment[];
-	reportedAt?: Date;
-}
-
-interface AutoFixResult {
-	status: 'skipped' | 'failed' | 'success' | 'in_progress';
-	email: ErrorEmail;
-	error?: string;
-	branchName?: string;
-	prUrl?: string;
-	log?: ErrorAutoFixLogModel;
-	reason?: string;
-	summary?: string;
-	notes?: string;
-}
-
-interface LogReservation {
-	proceed: boolean;
-	log?: ErrorAutoFixLogModel;
-	reason?: string;
-}
-
-interface EmailClassification {
-	source: 'app' | 'infrastructure' | 'noise';
-	skip: boolean;
-	reason?: string;
-	notify?: boolean;
-	markIgnored?: boolean;
-}
-
-interface LibraryIssueGateDecision {
-	blocked: boolean;
-	reason?: string;
-	evidence: string[];
-}
-
-const INFRA_SUBJECT_KEYWORDS = [
-	'failed snapshot',
-	'replica set',
-	'data size used',
-	'oplog',
-	'lock during backup',
-	'backup',
-	'no primary',
-	'no secondary',
-	'preferred primary',
-	'exceeding memory',
-	'exceeding storage',
-	'unhealthy status',
-	'disconnected status',
-	'replication lag',
-	'database storage size',
-	'compacting collections',
-	'failed connection',
-	'heartbeat',
-	'high cpu usage',
-	'high ram usage'
-];
-const MONGO_SOURCE_KEYWORDS = [
-	'mongo-explorer',
-	'mongo explorer',
-	'mongo-manager',
-	'mongo manager',
-	'mongomanager',
-	'mongodb'
-];
-const MONGO_TEXT_PATTERNS: RegExp[] = [
-	/\[mongo\]/i,
-	/\bmongo(?:db)?\s+(?:server\s+)?error\b/i,
-	/\bmongoservererror\b/i,
-	/\bmongonetwork(?:timeout)?error\b/i,
-	/\bmongonetworktimeouterror\b/i
-];
-const DEFAULT_ERROR_ALERT_EMAIL = 'dev@resolveio.com';
-const MAX_LOCAL_NOTIFICATION_USERS = 5000;
-const LIBRARY_MARKER_PATTERNS: Array<{label: string; pattern: RegExp}> = [
-	{label: 'node_modules stack', pattern: /(?:^|[\/\\])node_modules(?:[\/\\]|$)/i},
-	{label: '@resolveio/client-lib', pattern: /@resolveio\/client-lib(?:-[a-z0-9-]+)?/i},
-	{label: '@resolveio/server-lib', pattern: /@resolveio\/server-lib/i},
-	{label: 'resolveio-client-lib path', pattern: /(?:^|[\/\\])resolveio-client-lib(?:[\/\\]|$)/i},
-	{label: 'resolveio-server-lib path', pattern: /(?:^|[\/\\])resolveio-server-lib(?:[\/\\]|$)/i},
-	{label: 'base template path', pattern: /(?:^|[\/\\])aicoder[\/\\]templates[\/\\]base_(?:small|medium|large|tool)(?:[\/\\]|$)/i}
-];
-const APP_OWNED_PATH_PATTERN = /(?:^|[\/\\])(angular[\/\\]app|server[\/\\]src)(?:[\/\\]|$)/i;
-const FILE_PATH_PATTERN = /(?:webpack:\/\/\/?|\/|\.\/|[A-Za-z]:\\)[^\s'"`]+?\.(?:ts|tsx|js|jsx|mjs|cjs|html|scss|css)/g;
-
-interface RepoTarget {
-	owner: string;
-	repo: string;
-}
-
-interface GithubPullRequest {
-	number: number;
-	html_url: string;
-}
-
-interface ErrorReportIngestResult {
-	status: 'queued' | 'skipped' | 'duplicate' | 'ignored' | 'success' | 'failed' | 'in_progress';
-	reason?: string;
-	log?: ErrorAutoFixLogModel;
-}
-
-export interface DevErrorReportOptions {
-	subject: string;
-	body?: string;
-	sourceApp?: string;
-	environment?: string;
-	severity?: string;
-	fingerprint?: string;
-	idempotencyKey?: string;
-	metadata?: Record<string, any>;
-	clientId?: string;
-	clientName?: string;
-	clientSlug?: string;
-}
-
-export class ErrorAutoFixManager {
-	private config: AutoFixConfig;
-	private _serverConfig = null;
-	private readonly githubApiBase = 'https://api.github.com';
-	private readonly dashboardMonitors = new Map<string, Promise<void>>();
-	private static readonly APP_SETTINGS_CACHE_TTL_MS = 10000;
-	private appSettingsAutoOptimizeCacheExpiresAt = 0;
-	private appSettingsAutoOptimizeCacheValue: boolean | null = null;
-	private ready = false;
-
-	constructor(serverConfig, dependencies?: Partial<ErrorAutoFixManagerDependencies>) {
-		const resolvedDependencies = resolveErrorAutoFixManagerDependencies(dependencies);
-		applyErrorAutoFixDependencies(resolvedDependencies);
-
-		this._serverConfig = serverConfig || {};
-		this.config = this.resolveConfig();
-
-		if (!resolvedDependencies.AICoderApps || !resolvedDependencies.AIDashboardJobs) {
-			this.config.dashboardWorkflowEnabled = false;
-		}
-
-		if (!this.config.enabled) {
-			return;
-		}
-
-		if (!this.config.dashboardWorkflowEnabled && (!this.config.repoRoot || !this.config.githubOwner || !this.config.githubRepo)) {
-			console.warn('ErrorAutoFixManager auto-optimize unavailable - missing repository configuration. Ingest and manual runs remain available.');
-		}
-
-		this.ready = true;
-
-		// console.log('ErrorAutoFixManager initialized (HTTP intake mode).');
-		// console.log('ErrorAutoFixManager config source:', this.config.configSource);
-		// if (this.config.debugLogging) {
-		// 	console.log('ErrorAutoFixManager debug logging enabled.');
-		// }
-		// if (!this.config.autoOptimizeEnabled) {
-		// 	console.log('ErrorAutoFixManager auto-run disabled. Manual OpenAI runs required.');
-		// }
-	}
-
-	public isReady(): boolean {
-		return !!(this.ready && this.config?.enabled);
-	}
-
-	public validateIngestKey(candidate?: string): boolean {
-		const keys = Array.isArray(this.config?.ingestKeys) ? this.config.ingestKeys.filter(Boolean) : [];
-
-		if (!keys.length) {
-			return true;
-		}
-
-		if (!candidate) {
-			return false;
-		}
-
-		return keys.includes(candidate.trim());
-	}
-
-	private debugLog(message: string, details?: any): void {
-		if (!this.config?.debugLogging) {
-			return;
-		}
-
-		return;
-
-		if (typeof details === 'undefined') {
-			console.log(`[ErrorAutoFixManager][debug] ${message}`);
-		}
-		else {
-			console.log(`[ErrorAutoFixManager][debug] ${message}`, details);
-		}
-	}
-
-	private resolveConfig(): AutoFixConfig {
-		const scAutofix = (this._serverConfig && (this._serverConfig.autofix || this._serverConfig.AUTOFIX)) || {};
-		let notifyEmails: string[] = [];
-		let escalationEmails: string[] = [];
-
-		if (process.env.AUTOFIX_NOTIFY_EMAILS) {
-			notifyEmails = process.env.AUTOFIX_NOTIFY_EMAILS.split(',').map(a => a.trim()).filter(Boolean);
-		}
-		else if (Array.isArray(scAutofix.notifyEmails)) {
-			notifyEmails = scAutofix.notifyEmails.map(a => (a || '').trim()).filter(Boolean);
-		}
-		else if (typeof scAutofix.notifyEmails === 'string') {
-			notifyEmails = scAutofix.notifyEmails.split(',').map(a => a.trim()).filter(Boolean);
-		}
-
-		if (process.env.AUTOFIX_ESCALATION_EMAILS) {
-			escalationEmails = process.env.AUTOFIX_ESCALATION_EMAILS.split(',').map(a => a.trim()).filter(Boolean);
-		}
-		else if (Array.isArray(scAutofix.escalationEmails)) {
-			escalationEmails = scAutofix.escalationEmails.map(a => (a || '').trim()).filter(Boolean);
-		}
-		else if (typeof scAutofix.escalationEmails === 'string') {
-			escalationEmails = scAutofix.escalationEmails.split(',').map(a => a.trim()).filter(Boolean);
-		}
-
-		const getString = (envKey: string, scKey: string, fallback = ''): string => {
-			return process.env[envKey] || scAutofix[scKey] || fallback;
-		};
-
-		const getNumber = (envKey: string, scKey: string, fallback: number) => {
-			const envVal = Number(process.env[envKey]);
-			if (!Number.isNaN(envVal) && process.env[envKey] !== undefined) {
-				return envVal;
-			}
-			const scVal = Number(scAutofix[scKey]);
-			if (!Number.isNaN(scVal) && scAutofix[scKey] !== undefined) {
-				return scVal;
-			}
-			return fallback;
-		};
-
-		const getBoolean = (envKey: string, scKey: string, fallback = false) => {
-			if (typeof process.env[envKey] !== 'undefined') {
-				return process.env[envKey] === 'true';
-			}
-			if (typeof scAutofix[scKey] !== 'undefined') {
-				return !!scAutofix[scKey];
-			}
-			return fallback;
-		};
-
-		const parseKeyList = (value: any): string[] => {
-			if (Array.isArray(value)) {
-				return value.map(val => `${val || ''}`.trim()).filter(Boolean);
-			}
-
-			if (typeof value === 'string') {
-				return value.split(',').map(val => val.trim()).filter(Boolean);
-			}
-
-			return [];
-		};
-
-		const normalizePositiveInt = (value: number, fallback: number): number => {
-			if (!Number.isFinite(value) || value <= 0) {
-				return fallback;
-			}
-			return Math.floor(value);
-		};
-
-		const openaiProjectId = getString('OPENAI_PROJECT_ID', 'openaiProjectId');
-		const openaiEnvironment = getString('OPENAI_ENVIRONMENT', 'openaiEnvironment', openaiProjectId);
-		const ingestSource = typeof process.env.AUTOFIX_INGEST_KEYS !== 'undefined'
-			? process.env.AUTOFIX_INGEST_KEYS
-			: scAutofix.ingestKeys;
-		const hasAutoOptimizeEnv = typeof process.env.AUTOFIX_AUTO_OPTIMIZE_ENABLED !== 'undefined';
-		const autoOptimizeEnabled = getBoolean('AUTOFIX_AUTO_OPTIMIZE_ENABLED', 'autoOptimizeEnabled', false);
-
-		return {
-			enabled: true,
-			repoRoot: getString('AUTOFIX_REPO_ROOT', 'repoRoot', ''),
-			baseBranch: getString('AUTOFIX_BASE_BRANCH', 'baseBranch', 'main'),
-			branchPrefix: getString('AUTOFIX_BRANCH_PREFIX', 'branchPrefix', 'openai/auto'),
-			githubToken: getString('GITHUB_TOKEN', 'githubToken', getString('AUTOFIX_GITHUB_TOKEN', 'githubToken')),
-			githubOwner: getString('AUTOFIX_GITHUB_OWNER', 'githubOwner', 'resolveio'),
-			githubRepo: getString('AUTOFIX_GITHUB_REPO', 'githubRepo', 'resolveio-all'),
-			commandTimeoutMs: getNumber('AUTOFIX_COMMAND_TIMEOUT_MS', 'commandTimeoutMs', 600000),
-			notifyEmails,
-			debugLogging: getBoolean('AUTOFIX_DEBUG_LOGS', 'debugLogging', false),
-			configSource: hasAutoOptimizeEnv ? 'environment' : (Object.keys(scAutofix).length ? 'serverConfig' : 'defaults'),
-			openaiEnvironment,
-			openaiProjectId,
-			autoOptimizeEnabled: autoOptimizeEnabled,
-			ingestKeys: parseKeyList(ingestSource),
-			dashboardWorkflowEnabled: getBoolean('AUTOFIX_DASHBOARD_WORKFLOW_ENABLED', 'dashboardWorkflowEnabled', true),
-			dashboardFallbackToGithub: getBoolean('AUTOFIX_DASHBOARD_FALLBACK_TO_GITHUB', 'dashboardFallbackToGithub', true),
-			dashboardWaitTimeoutMs: getNumber('AUTOFIX_DASHBOARD_WAIT_TIMEOUT_MS', 'dashboardWaitTimeoutMs', 45 * 60 * 1000),
-			dashboardPublishRequired: getBoolean('AUTOFIX_DASHBOARD_PUBLISH_REQUIRED', 'dashboardPublishRequired', true),
-			maxAutoRunAttemptsPerIssue: normalizePositiveInt(
-				getNumber('AUTOFIX_MAX_AUTORUN_ATTEMPTS_PER_ISSUE', 'maxAutoRunAttemptsPerIssue', 3),
-				3
-			),
-			escalationEmails
-		};
-	}
-
-	private extractEmailAddress(value: string): string {
-		if (!value) {
-			return '';
-		}
-
-		let email = value;
-		const angleMatch = value.match(/<([^>]+)>/);
-
-		if (angleMatch && angleMatch[1]) {
-			email = angleMatch[1];
-		}
-
-		email = email.split(';')[0].split(',')[0];
-		return email.trim().toLowerCase();
-	}
-
-	private escapeRegex(value: string): string {
-		return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-	}
-
-	private async resolveClientForEnvironment(environment?: string): Promise<ClientModel> {
-		const host = this.extractHostFromUrl(environment);
-		if (!host) {
-			return null;
-		}
-
-		try {
-			const escaped = this.escapeRegex(host);
-			const query = {
-				website: {
-					$regex: escaped,
-					$options: 'i'
-				}
-			};
-
-			return await Clients.findOne(query);
-		}
-		catch (err) {
-			console.error('ErrorAutoFixManager resolveClientForEnvironment error:', err);
-			return null;
-		}
-	}
-
-	private extractHostFromUrl(value?: string): string | null {
-		if (!value) {
-			return null;
-		}
-
-		const trimmed = value.trim();
-		if (!trimmed) {
-			return null;
-		}
-
-		try {
-			const parsed = new URL(trimmed);
-			return parsed.hostname.toLowerCase();
-		}
-		catch {
-			return trimmed.toLowerCase();
-		}
-	}
-
-private async resolveClientForReport(report: ErrorReportPayload): Promise<ClientModel> {
-	if (!report) {
-		return null;
-	}
-
-		try {
-			if (report.clientId) {
-				const byId = await Clients.findById(report.clientId);
-				if (byId) {
-					return byId;
-				}
-			}
-
-			const tryField = async (field: string, value?: string): Promise<ClientModel> => {
-				if (!value) {
-					return null;
-				}
-
-				const escaped = this.escapeRegex(value);
-				const query: {[key: string]: any} = {};
-				query[field] = {$regex: `^${escaped}$`, $options: 'i'};
-				return await Clients.findOne(query);
-			};
-
-			return (
-				(await tryField('name', report.clientName)) ||
-				(await tryField('demo_name', report.clientSlug)) ||
-				(await tryField('repo', report.clientRepo)) ||
-				(await this.resolveClientForEnvironment(report.environment))
-			);
-		}
-		catch (err) {
-			console.error('ErrorAutoFixManager resolveClientForReport error:', err);
-			return null;
-		}
-	}
-
-	private determineOpenAIEnvironment(client?: ClientModel): string {
-		const repoCandidate = (client?.repo || '').trim();
-
-		if (repoCandidate) {
-			return repoCandidate;
-		}
-
-		const configEnv = (this.config.openaiEnvironment || '').trim();
-
-		if (configEnv) {
-			return configEnv;
-		}
-
-		if ((this.config.githubOwner || '').trim() && (this.config.githubRepo || '').trim()) {
-			return `${this.config.githubOwner}/${this.config.githubRepo}`.trim();
-		}
-
-		return '';
-	}
-
-	private resolveEnvironmentForTask(email: ErrorEmail, log: ErrorAutoFixLogModel): string {
-		if (email && email.openai_environment && email.openai_environment.trim()) {
-			return email.openai_environment.trim();
-		}
-
-		if (log && log.openai_environment && log.openai_environment.trim()) {
-			return log.openai_environment.trim();
-		}
-
-		return this.determineOpenAIEnvironment();
-	}
-
-
-	private buildEmailFromReport(report: ErrorReportPayload): ErrorEmail {
-		const timestamp = report.reportedAt instanceof Date && !Number.isNaN(report.reportedAt.getTime())
-			? report.reportedAt
-			: new Date();
-		const safeMessage = (report.message || '').toString().trim() || 'Unknown error';
-		const subjectBase = `[AppError] ${report.sourceApp || 'application'}${report.environment ? ` (${report.environment})` : ''}`;
-		const subject = `${subjectBase} - ${safeMessage.slice(0, 120)}`;
-		const lines: string[] = [
-			`Source App:\t${report.sourceApp}`,
-			`Environment:\t${report.environment || 'n/a'}`,
-			`Severity:\t${report.severity || 'error'}`,
-			`Client Hint:\t${report.clientName || report.clientSlug || report.clientRepo || report.clientId || 'n/a'}`,
-			`Reported By:\t${report.reportedBy || report.clientEmail || 'n/a'}`,
-			`Reported At:\t${timestamp.toISOString()}`,
-			`Message:\t${safeMessage}`
-		];
-
-		if (report.stack) {
-			lines.push('', 'Stack Trace:', report.stack);
-		}
-
-		if (report.context && typeof report.context === 'object' && Object.keys(report.context).length) {
-			lines.push('', 'Context JSON:', JSON.stringify(report.context, null, 2));
-		}
-
-		if (report.metadata && typeof report.metadata === 'object' && Object.keys(report.metadata).length) {
-			lines.push('', 'Metadata JSON:', JSON.stringify(report.metadata, null, 2));
-		}
-
-		if (Array.isArray(report.attachments) && report.attachments.length) {
-			lines.push('', 'Attachments:');
-			report.attachments.forEach((att: ErrorReportAttachment) => {
-				const desc: string[] = [];
-				if (att.name) {
-					desc.push(att.name);
-				}
-				if (att.contentType) {
-					desc.push(att.contentType);
-				}
-				if (typeof att.size === 'number') {
-					desc.push(`${att.size}b`);
-				}
-
-				const summary = desc.length ? desc.join(' | ') : 'attachment';
-				lines.push(`- ${summary}${att.url ? ` -> ${att.url}` : ''}`);
-			});
-		}
-
-		if (report.fingerprint) {
-			lines.push('', `Fingerprint:\t${report.fingerprint}`);
-		}
-
-		if (report.idempotencyKey) {
-			lines.push(`Idempotency Key:\t${report.idempotencyKey}`);
-		}
-
-		const body = lines.join('\n');
-
-		return {
-			key: `report:${timestamp.getTime().toString(36)}:${Math.random().toString(36).slice(2, 10)}`,
-			subject,
-			body,
-			raw: body,
-			from: report.reportedBy || report.clientEmail || 'errors@resolveio.com',
-			sourceApp: report.sourceApp,
-			sourceEnvironment: report.environment,
-			severity: report.severity,
-			reportedBy: report.reportedBy,
-			reportMetadata: report.metadata,
-			reportContext: report.context,
-			attachments: Array.isArray(report.attachments) ? report.attachments : [],
-			openai_environment: report.clientRepo,
-			reportedAt: timestamp
-		};
-	}
-
-	private classifyEmail(email: ErrorEmail): EmailClassification {
-		const subject = (email.subject || '').toLowerCase();
-		const body = email.body || '';
-		const normalizedBody = body.toLowerCase();
-
-		if (
-			subject.includes('autofix') &&
-			(normalizedBody.includes('auto-fix workflow') || normalizedBody.includes('autofix workflow'))
-		) {
-			return {source: 'noise', skip: true, reason: 'AutoFix status notification'};
-		}
-
-		if (this.isMongoOriginError(email)) {
-			return {
-				source: 'infrastructure',
-				skip: true,
-				reason: 'Mongo-origin error ignored for auto-fix',
-				markIgnored: true
-			};
-		}
-
-		if (subject.includes('[database]') || subject.includes('[server]')) {
-			return {source: 'infrastructure', skip: true, reason: 'Infrastructure alert (subject tag)'};
-		}
-
-		const infraKeyword = INFRA_SUBJECT_KEYWORDS.find(keyword => subject.includes(keyword));
-		if (infraKeyword) {
-			return {source: 'infrastructure', skip: true, reason: `Infrastructure alert (${infraKeyword})`};
-		}
-
-		if (!body.trim()) {
-			return {source: 'noise', skip: true, reason: 'Empty error payload'};
-		}
-
-		const emptyErrorsRegex = /errors\s*[\r\n]+(\{\s*\}|\[\s*\])/i;
-		if (emptyErrorsRegex.test(body)) {
-			return {source: 'noise', skip: true, reason: 'Empty error details'};
-		}
-
-		if (subject.includes('database is down') || normalizedBody.includes('database is down')) {
-			return {source: 'infrastructure', skip: true, reason: 'Database outage alert'};
-		}
-
-		return {source: 'app', skip: false};
-	}
-
-	private isMongoOriginError(email: ErrorEmail): boolean {
-		const sourceApp = String(email?.sourceApp || '').toLowerCase();
-		const sourceEnvironment = String(email?.sourceEnvironment || '').toLowerCase();
-		const subject = String(email?.subject || '').toLowerCase();
-		const body = String(email?.body || '');
-
-		const sourceMatches = MONGO_SOURCE_KEYWORDS.some(keyword =>
-			sourceApp.includes(keyword) || sourceEnvironment.includes(keyword)
-		);
-		if (sourceMatches) {
-			return true;
-		}
-
-		const text = `${subject}\n${body}`;
-		return MONGO_TEXT_PATTERNS.some(pattern => pattern.test(text));
-	}
-
-	private generateRawEmailHash(email: ErrorEmail): string {
-		return createHash('sha256').update(`${email.subject || ''}\n${email.body || ''}`, 'utf8').digest('hex');
-	}
-
-	private generateIssueHash(email: ErrorEmail): string {
-		const subject = this.normalizeTextForHash(email.subject || '');
-		const body = this.normalizeBodyForHash(email.body || '');
-		return createHash('sha256').update(`${subject}\n${body}`, 'utf8').digest('hex');
-	}
-
-	private normalizeTextForHash(value: string): string {
-		if (!value) {
-			return '';
-		}
-
-		const normalized = value
-			.replace(/\r/g, '\n')
-			.toLowerCase()
-			.replace(/0x[0-9a-f]+/gi, '0x#')
-			.replace(/\b[0-9a-f]{7,64}\b/gi, '#')
-			.replace(/\b[0-9]{4}[-/][0-9]{2}[-/][0-9]{2}(?:[ t][0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]{1,6})?)?\b/g, '#datetime#')
-			.replace(/\b[0-9]{2}:[0-9]{2}:[0-9]{2}\b/g, '#time#')
-			.replace(/[0-9]+/g, '#')
-			.replace(/[^\S\n]+/g, ' ')
-			.split('\n')
-			.map(line => line.trim())
-			.filter(Boolean)
-			.slice(0, 60)
-			.join('\n');
-
-		return normalized.length > 4000 ? normalized.slice(0, 4000) : normalized;
-	}
-
-	private normalizeBodyForHash(body: string): string {
-		if (!body) {
-			return '';
-		}
-
-		const withoutStackNoise = body
-			.replace(/=+\s*stack trace\s*=+/gi, 'stack trace')
-			.replace(/-{3,}/g, '-')
-			.replace(/\[[^\]]*request id[^\]]*\]/gi, '[request id]')
-			.replace(/guid:[^\s]+/gi, 'guid:#')
-			.replace(/request id:[^\s]+/gi, 'request id:#')
-			.replace(/correlation id:[^\s]+/gi, 'correlation id:#');
-
-		return this.normalizeTextForHash(withoutStackNoise);
-	}
-
-	private parseRepoTarget(env: string): RepoTarget {
-		const trimmed = (env || '').trim();
-		if (!trimmed) {
-			return null;
-		}
-
-		const [owner, repo] = trimmed.split('/', 2);
-		if (!owner || !repo) {
-			return null;
-		}
-
-		return {
-			owner: owner.trim(),
-			repo: repo.trim()
-		};
-	}
-
-	private buildWorkBranch(hash: string): string {
-		const shortHash = (hash || '').toLowerCase().replace(/[^a-z0-9]/g, '').slice(0, 12) || 'autofix';
-		const prefix = (this.config.branchPrefix || 'openai/auto').trim();
-		if (!prefix) {
-			return shortHash;
-		}
-
-		const segments = prefix.split('/').map(segment => segment.trim()).filter(Boolean);
-		const sanitized = segments.map(segment => segment.replace(/[^a-zA-Z0-9._-]/g, '-'));
-		return `${sanitized.join('/')}/${shortHash}`;
-	}
-
-	private normalizeEmailText(value: string, limit = 20000): string {
-		if (!value) {
-			return '';
-		}
-
-		const cleaned = value.replace(/\r/g, '');
-		if (cleaned.length <= limit) {
-			return cleaned;
-		}
-
-		return `${cleaned.slice(0, limit)}\n... (truncated)`;
-	}
-
-	private buildContextMarkdown(email: ErrorEmail, identifier: string, normalizedBody: string): string {
-		const lines: string[] = [
-			`# OpenAI Error Context: ${identifier}`,
-			'',
-			`**Subject**: ${email.subject || '(no subject)'}`,
-			email.fromAddress ? `**From**: ${email.fromAddress}` : undefined,
-			email.client_name ? `**Client**: ${email.client_name}` : undefined,
-			email.source_type ? `**Classification**: ${email.source_type}${email.classification_reason ? ` (${email.classification_reason})` : ''}` : undefined,
-			email.id_client ? `**Client Id**: ${email.id_client}` : undefined,
-			'',
-			'## Body',
-			'```',
-			normalizedBody || '(empty body)',
-			'```',
-			'',
-			'_Generated by ErrorAutoFixManager_'
-		];
-
-		return lines.filter(line => typeof line !== 'undefined').join('\n');
-	}
-
-	private buildOpenAIComment(email: ErrorEmail, contextPath: string, normalizedBody: string): string {
-		const lines: string[] = [
-			'@openai review',
-			'',
-			`**Email Subject**: ${email.subject || '(no subject)'}`,
-			email.fromAddress ? `**From**: ${email.fromAddress}` : undefined,
-			email.client_name ? `**Client**: ${email.client_name}` : undefined,
-			contextPath ? `Context file: \`${contextPath}\`` : undefined,
-			'',
-			'```',
-			normalizedBody || '(empty body)',
-			'```',
-			'',
-			'Please investigate this error and propose a minimal, safe fix.'
-		];
-
-		return lines.filter(line => typeof line !== 'undefined').join('\n');
-	}
-
-	private formatGithubError(error: any): string {
-		if (!error) {
-			return 'GitHub request failed.';
-		}
-
-		const status = error?.response?.status;
-		const message = error?.response?.data?.message || error?.message || 'GitHub request failed.';
-
-		if (status) {
-			return `GitHub API error (${status}): ${message}`;
-		}
-
-		return `GitHub API error: ${message}`;
-	}
-
-	private buildGithubAuthHeader(token?: string): string {
-		const trimmed = (token || '').trim();
-		if (!trimmed) {
-			return '';
-		}
-
-		if (/^(token|Bearer)\s+/i.test(trimmed)) {
-			return trimmed;
-		}
-
-		if (trimmed.includes('.') && !trimmed.startsWith('gh')) {
-			return `Bearer ${trimmed}`;
-		}
-
-		return `token ${trimmed}`;
-	}
-
-	private async githubRequest<T>(config: AxiosRequestConfig, allow404 = false): Promise<T> {
-		const authHeader = this.buildGithubAuthHeader(this.config.githubToken);
-		const headers = {
-			...(authHeader ? {Authorization: authHeader} : {}),
-			Accept: 'application/vnd.github+json',
-			'User-Agent': 'ResolveIO-AutoFix',
-			'X-GitHub-Api-Version': '2022-11-28'
-		};
-
-		const finalConfig: AxiosRequestConfig = {
-			...config,
-			baseURL: this.githubApiBase,
-			headers: {
-				...headers,
-				...(config.headers || {})
-			},
-			timeout: Math.min(Math.max(this.config.commandTimeoutMs || 600000, 1000), 120000)
-		};
-
-		try {
-			const response = await axios.request<T>(finalConfig);
-			return response.data;
-		}
-		catch (err) {
-			const status = err?.response?.status;
-			if (allow404 && status === 404) {
-				return null as unknown as T;
-			}
-			throw new Error(this.formatGithubError(err));
-		}
-	}
-
-	private async resolveBaseBranch(target: RepoTarget): Promise<string> {
-		const fallback = (this.config.baseBranch || 'main').trim();
-		try {
-			const repo = await this.githubRequest<{default_branch?: string}>(
-				{method: 'GET', url: `/repos/${target.owner}/${target.repo}`}
-			);
-			const defaultBranch = (repo?.default_branch || '').trim();
-			return defaultBranch || fallback;
-		}
-		catch (err) {
-			this.debugLog('Failed to fetch default branch. Falling back to configured branch.', {
-				target,
-				error: err?.message
-			});
-			return fallback;
-		}
-	}
-
-	private async getBranchSha(target: RepoTarget, branch: string): Promise<string> {
-		const ref = await this.githubRequest<{object?: {sha?: string}}>(
-			{method: 'GET', url: `/repos/${target.owner}/${target.repo}/git/ref/heads/${branch}`}
-		);
-		const sha = ref?.object?.sha;
-		if (!sha) {
-			throw new Error(`Base branch ${branch} not found.`);
-		}
-		return sha;
-	}
-
-	private async ensureBranch(target: RepoTarget, newBranch: string, baseBranch: string, baseSha: string): Promise<void> {
-		const existing = await this.githubRequest<any>(
-			{method: 'GET', url: `/repos/${target.owner}/${target.repo}/git/ref/heads/${newBranch}`},
-			true
-		);
-		if (existing) {
-			return;
-		}
-
-		await this.githubRequest(
-			{
-				method: 'POST',
-				url: `/repos/${target.owner}/${target.repo}/git/refs`,
-				data: {
-					ref: `refs/heads/${newBranch}`,
-					sha: baseSha
-				}
-			}
-		);
-	}
-
-	private async upsertContextFile(target: RepoTarget, branch: string, contextPath: string, content: string): Promise<void> {
-		const encodedPath = encodeURIComponent(contextPath).replace(/%2F/g, '/');
-		const existing = await this.githubRequest<any>(
-			{
-				method: 'GET',
-				url: `/repos/${target.owner}/${target.repo}/contents/${encodedPath}`,
-				params: {ref: branch}
-			},
-			true
-		);
-		const sha = existing && existing.sha ? existing.sha : undefined;
-		const commitMessage = `chore(openai): update error context ${contextPath}`;
-
-		await this.githubRequest(
-			{
-				method: 'PUT',
-				url: `/repos/${target.owner}/${target.repo}/contents/${encodedPath}`,
-				data: {
-					message: commitMessage.slice(0, 200),
-					content: Buffer.from(content, 'utf8').toString('base64'),
-					branch,
-					sha
-				}
-			}
-		);
-	}
-
-	private async findOpenPullRequest(target: RepoTarget, branch: string, base: string): Promise<GithubPullRequest> {
-		const prs = await this.githubRequest<GithubPullRequest[]>(
-			{
-				method: 'GET',
-				url: `/repos/${target.owner}/${target.repo}/pulls`,
-				params: {
-					state: 'open',
-					head: `${target.owner}:${branch}`,
-					base,
-					per_page: 1
-				}
-			}
-		);
-		if (prs && prs.length) {
-			return prs[0];
-		}
-		return null;
-	}
-
-	private async createPullRequest(target: RepoTarget, branch: string, base: string, title: string, body: string): Promise<GithubPullRequest> {
-		const pr = await this.githubRequest<GithubPullRequest>(
-			{
-				method: 'POST',
-				url: `/repos/${target.owner}/${target.repo}/pulls`,
-				data: {
-					title,
-					head: branch,
-					base,
-					body
-				}
-			}
-		);
-		return pr;
-	}
-
-	private async commentOnPullRequest(target: RepoTarget, prNumber: number, body: string): Promise<void> {
-		await this.githubRequest(
-			{
-				method: 'POST',
-				url: `/repos/${target.owner}/${target.repo}/issues/${prNumber}/comments`,
-				data: {
-					body
-				}
-			}
-		);
-	}
-
-	private parseBooleanEnv(envKey: string): boolean | null {
-		if (typeof process.env[envKey] === 'undefined') {
-			return null;
-		}
-
-		return process.env[envKey] === 'true';
-	}
-
-	private async resolveAutoOptimizeEnabled(): Promise<boolean> {
-		const now = Date.now();
-		if (this.appSettingsAutoOptimizeCacheValue !== null && now < this.appSettingsAutoOptimizeCacheExpiresAt) {
-			return this.appSettingsAutoOptimizeCacheValue;
-		}
-
-		const envValue = this.parseBooleanEnv('AUTOFIX_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_auto_fix === 'boolean') {
-					enabled = !!activeSetting.enable_auto_fix;
-				}
-			}
-		}
-		catch (error) {
-			if (this.config?.debugLogging) {
-				console.warn('ErrorAutoFixManager failed to read app settings auto-fix toggle', error);
-			}
-		}
-
-		this.appSettingsAutoOptimizeCacheValue = enabled;
-		this.appSettingsAutoOptimizeCacheExpiresAt = now + ErrorAutoFixManager.APP_SETTINGS_CACHE_TTL_MS;
-		return enabled;
-	}
-
-	private async reserveLog(email: ErrorEmail, client?: ClientModel, autoOptimizeEnabled = false): Promise<LogReservation> {
-		const hash = email.hash;
-		const rawHash = email.rawHash || hash;
-		const now = email.reportedAt || new Date();
-
-		let existing: ErrorAutoFixLogModel = null;
-
-		if (hash) {
-			existing = await ErrorAutoFixLogs.findOne({issue_hash: hash});
-		}
-
-		if (!existing && rawHash) {
-			existing = await ErrorAutoFixLogs.findOne({email_hash: rawHash});
-		}
-
-		if (!existing && hash && hash !== rawHash) {
-			existing = await ErrorAutoFixLogs.findOne({email_hash: hash});
-		}
-
-		if (existing) {
-			await this.markDuplicate(existing._id, now);
-			const updatedExisting = await ErrorAutoFixLogs.findOne({_id: existing._id}) || existing;
-
-			const metaUpdate: Partial<ErrorAutoFixLogModel> = {};
-
-			if (hash && (!updatedExisting.issue_hash || updatedExisting.issue_hash !== hash)) {
-				metaUpdate.issue_hash = hash;
-			}
-
-			if (rawHash && (!updatedExisting.email_hash || updatedExisting.email_hash !== rawHash)) {
-				metaUpdate.email_hash = rawHash;
-			}
-
-			if (email.fromAddress && email.fromAddress !== updatedExisting.from_email) {
-				metaUpdate.from_email = email.fromAddress;
-			}
-
-			if (client) {
-				if (!updatedExisting.id_client || updatedExisting.id_client !== client._id) {
-					metaUpdate.id_client = client._id;
-				}
-
-				if (!updatedExisting.client_name || updatedExisting.client_name !== client.name) {
-					metaUpdate.client_name = client.name;
-				}
-			}
-
-			if (email.openai_environment && email.openai_environment !== updatedExisting.openai_environment) {
-				metaUpdate.openai_environment = email.openai_environment;
-			}
-
-			if (email.sourceApp && email.sourceApp !== updatedExisting.source_app) {
-				metaUpdate.source_app = email.sourceApp;
-			}
-
-			if (email.sourceEnvironment && email.sourceEnvironment !== updatedExisting.source_environment) {
-				metaUpdate.source_environment = email.sourceEnvironment;
-			}
-
-			if (email.severity && email.severity !== updatedExisting.severity) {
-				metaUpdate.severity = email.severity;
-			}
-
-			if (email.reportedBy && email.reportedBy !== updatedExisting.reported_by) {
-				metaUpdate.reported_by = email.reportedBy;
-			}
-
-			if (typeof email.reportMetadata !== 'undefined') {
-				metaUpdate.report_metadata = email.reportMetadata;
-			}
-
-			if (typeof email.reportContext !== 'undefined') {
-				metaUpdate.report_context = email.reportContext;
-			}
-
-			if (typeof email.attachments !== 'undefined') {
-				metaUpdate.attachments = email.attachments;
-			}
-
-			metaUpdate.last_reported_at = now;
-
-			if (Object.keys(metaUpdate).length) {
-				await this.updateLog(updatedExisting._id, metaUpdate);
-			}
-
-			if (updatedExisting.status === 'completed') {
-				const reactivated = (await ErrorAutoFixLogs.findOneAndUpdate({_id: updatedExisting._id}, {
-					$set: {
-						status: 'pending',
-						ignored: false,
-						last_error: '',
-						openai_task_id: '',
-						branch_name: '',
-						pr_url: ''
-					}
-				}, {
-					returnDocument: 'after'
-				})) || updatedExisting;
-
-				return {
-					proceed: true,
-					log: reactivated
-				};
-			}
-
-			if (updatedExisting.ignored) {
-				return {
-					proceed: false,
-					log: updatedExisting,
-					reason: 'ignored'
-				};
-			}
-
-			if (autoOptimizeEnabled && (updatedExisting.status === 'failed' || updatedExisting.status === 'skipped') && !updatedExisting.ignored) {
-				const attemptsUsed = Number.isFinite(Number(updatedExisting.attempt_count))
-					? Number(updatedExisting.attempt_count)
-					: 0;
-				const maxAttempts = Number.isFinite(Number(this.config.maxAutoRunAttemptsPerIssue))
-					? Number(this.config.maxAutoRunAttemptsPerIssue)
-					: 0;
-				if (maxAttempts > 0 && attemptsUsed >= maxAttempts) {
-					const reason = `Auto-fix attempt budget reached (${attemptsUsed}/${maxAttempts}).`;
-					const exhausted = (await ErrorAutoFixLogs.findOneAndUpdate({_id: updatedExisting._id}, {
-						$set: {
-							status: 'skipped',
-							ignored: true,
-							last_error: `${reason} Marked ignored pending manual intervention.`,
-							last_result_at: now,
-							updatedAt: now
-						}
-					}, {
-						returnDocument: 'after'
-					})) || updatedExisting;
-
-					await this.sendEscalationNotice(exhausted, reason);
-					return {
-						proceed: false,
-						log: exhausted,
-						reason: 'budget_exhausted'
-					};
-				}
-
-				const resumed = await ErrorAutoFixLogs.findOneAndUpdate({_id: updatedExisting._id}, {
-					$inc: {
-						attempt_count: 1
-					},
-					$set: {
-						status: 'in_progress',
-						last_attempt_at: now,
-						openai_task_id: '',
-						branch_name: '',
-						pr_url: '',
-						last_error: ''
-					}
-				}, {
-					returnDocument: 'after'
-				});
-
-				return {
-					proceed: true,
-					log: resumed || updatedExisting
-				};
-			}
-
-			if (updatedExisting.status === 'in_progress') {
-				return {
-					proceed: false,
-					log: updatedExisting,
-					reason: 'in_progress'
-				};
-			}
-
-			if (updatedExisting.status === 'success') {
-				return {
-					proceed: false,
-					log: updatedExisting,
-					reason: 'success'
-				};
-			}
-
-			return {
-				proceed: false,
-				log: updatedExisting,
-				reason: 'duplicate'
-			};
-		}
-
-		const counterValue = await ResolveIOServer.getMainServer().getMethodManager().callMethod('incCounter', 'autofix_error');
-		const counterString = pad(counterValue, 6);
-
-		const doc: ErrorAutoFixLogModel = {
-			_id: objectIdHexString(),
-			email_hash: rawHash,
-			issue_hash: hash,
-			subject: email.subject,
-			message_id: email.messageId,
-			body: email.body,
-			status: autoOptimizeEnabled ? 'in_progress' : 'pending',
-			ignored: false,
-			attempt_count: autoOptimizeEnabled ? 1 : 0,
-			duplicate_count: 0,
-			autofix_error_count: counterValue,
-			autofix_error_count_string: counterString,
-			first_seen_at: now,
-			last_attempt_at: autoOptimizeEnabled ? now : undefined,
-			from_email: email.fromAddress || '',
-			id_client: client?._id,
-			client_name: client?.name,
-			openai_environment: email.openai_environment || this.determineOpenAIEnvironment(client),
-			source_app: email.sourceApp,
-			source_environment: email.sourceEnvironment,
-			severity: email.severity,
-			reported_by: email.reportedBy || email.fromAddress || '',
-			last_reported_at: now,
-			report_metadata: email.reportMetadata,
-			report_context: email.reportContext,
-			attachments: email.attachments
-		};
-
-		await ErrorAutoFixLogs.insertOne(doc as any);
-
-		return {
-			proceed: true,
-			log: doc
-		};
-	}
-
-	private async markDuplicate(logId: string, timestamp: Date): Promise<void> {
-		await ErrorAutoFixLogs.updateOne({_id: logId}, {
-			$inc: {
-				duplicate_count: 1
-			},
-			$set: {
-				last_duplicate_at: timestamp,
-				last_reported_at: timestamp,
-				updatedAt: timestamp
-			}
-		});
-	}
-
-	private async updateLog(logId: string, set: Partial<ErrorAutoFixLogModel>, inc?: {[key: string]: number}): Promise<ErrorAutoFixLogModel> {
-		const cleanedSet: {[key: string]: any} = {};
-		const rawSet: {[key: string]: any} = set ? {...set} : {};
-
-		Object.keys(rawSet).forEach(key => {
-			if (typeof rawSet[key] !== 'undefined') {
-				cleanedSet[key] = rawSet[key];
-			}
-		});
-
-		cleanedSet.updatedAt = new Date();
-
-		const update: any = {
-			$set: cleanedSet
-		};
-
-		if (inc) {
-			update.$inc = inc;
-		}
-
-		const result = await ErrorAutoFixLogs.findOneAndUpdate({_id: logId}, update, {
-			returnDocument: 'after'
-		});
-
-		return result;
-	}
-
-	private getEscalationRecipients(): string[] {
-		const unique = new Set<string>();
-		const add = (value: string) => {
-			const normalized = String(value || '').trim().toLowerCase();
-			if (!normalized) {
-				return;
-			}
-			unique.add(normalized);
-		};
-
-		(this.config.escalationEmails || []).forEach(add);
-		(this.config.notifyEmails || []).forEach(add);
-		if (!unique.size) {
-			add(DEFAULT_ERROR_ALERT_EMAIL);
-		}
-		return Array.from(unique);
-	}
-
-	private async sendEscalationNotice(log: ErrorAutoFixLogModel, reason: string): Promise<void> {
-		const recipients = this.getEscalationRecipients();
-		if (!recipients.length || !log?._id) {
-			return;
-		}
-
-		const identifier = log.autofix_error_count_string || log._id;
-		const subject = `ResolveIO AutoFix Escalation: ${identifier}`;
-		const body = [
-			'Auto-fix retry budget was exhausted for this recurring issue and further autonomous attempts were stopped.',
-			'',
-			`Reason: ${reason}`,
-			`Issue Log ID: ${log._id}`,
-			`Issue Counter: ${log.autofix_error_count_string || 'n/a'}`,
-			`Client: ${log.client_name || log.id_client || 'unknown'}`,
-			`Source App: ${log.source_app || 'unknown'}`,
-			`Environment: ${log.source_environment || log.openai_environment || 'unknown'}`,
-			`Attempts: ${log.attempt_count || 0}/${this.config.maxAutoRunAttemptsPerIssue}`,
-			`Issue Hash: ${log.issue_hash || log.email_hash || 'n/a'}`,
-			'',
-			'The issue is now marked ignored for auto-fix to protect customer token usage. Manual intervention 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 auto-fix escalation email', {recipient, logId: log._id, error});
-			}
-		}
-	}
-
-	private collectLibraryIssueSignalText(email: ErrorEmail, log: ErrorAutoFixLogModel): string {
-		const attachments = Array.isArray(log?.attachments) ? log.attachments : [];
-		const attachmentSignals = attachments.map((attachment) => {
-			return [
-				attachment?.name || '',
-				attachment?.url || '',
-				attachment?.contentType || ''
-			].filter(Boolean).join(' ');
-		});
-		const metadata = log?.report_metadata && Object.keys(log.report_metadata).length
-			? JSON.stringify(log.report_metadata)
-			: '';
-		const context = log?.report_context && Object.keys(log.report_context).length
-			? JSON.stringify(log.report_context)
-			: '';
-		return [
-			email?.subject || '',
-			email?.body || '',
-			log?.body || '',
-			metadata,
-			context,
-			attachmentSignals.join('\n')
-		].filter(Boolean).join('\n');
-	}
-
-	private evaluateLibraryIssueGate(email: ErrorEmail, log: ErrorAutoFixLogModel): LibraryIssueGateDecision {
-		const signalText = this.collectLibraryIssueSignalText(email, log);
-		if (!signalText) {
-			return {blocked: false, evidence: []};
-		}
-
-		const evidence: string[] = [];
-		let markerHits = 0;
-		for (const marker of LIBRARY_MARKER_PATTERNS) {
-			if (!marker.pattern.test(signalText)) {
-				continue;
-			}
-			markerHits += 1;
-			evidence.push(marker.label);
-		}
-
-		const rawPaths = signalText.match(FILE_PATH_PATTERN) || [];
-		const normalizedPaths = rawPaths
-			.map((value) => String(value || '').trim())
-			.filter(Boolean)
-			.map((value) => value.replace(/\\/g, '/').toLowerCase());
-		const appOwnedPathCount = normalizedPaths.filter((value) => APP_OWNED_PATH_PATTERN.test(value)).length;
-		const libraryPathCount = normalizedPaths.filter((value) => {
-			return value.includes('/node_modules/')
-				|| value.includes('@resolveio/client-lib')
-				|| value.includes('@resolveio/server-lib')
-				|| value.includes('/resolveio-client-lib/')
-				|| value.includes('/resolveio-server-lib/')
-				|| value.includes('/aicoder/templates/base_');
-		}).length;
-
-		const shouldBlock = (libraryPathCount > 0 && appOwnedPathCount === 0)
-			|| (markerHits >= 2 && appOwnedPathCount === 0)
-			|| (markerHits >= 1 && libraryPathCount >= 2);
-		if (!shouldBlock) {
-			return {blocked: false, evidence};
-		}
-
-		const compactEvidence = Array.from(new Set([
-			...evidence,
-			...(libraryPathCount ? [`library_paths=${libraryPathCount}`] : []),
-			...(appOwnedPathCount ? [`app_paths=${appOwnedPathCount}`] : [])
-		])).slice(0, 8);
-		return {
-			blocked: true,
-			reason: 'Root cause appears to be in shared ResolveIO libraries/templates; app-level auto-fix was blocked.',
-			evidence: compactEvidence
-		};
-	}
-
-	private async sendLibraryIssueNotice(log: ErrorAutoFixLogModel, reason: string, evidence: string[]): Promise<void> {
-		const recipients = this.getEscalationRecipients();
-		if (!recipients.length || !log?._id) {
-			return;
-		}
-
-		const identifier = log.autofix_error_count_string || log._id;
-		const subject = `ResolveIO AutoFix Blocked (Library): ${identifier}`;
-		const body = [
-			'Auto-fix was blocked because the issue appears library-owned, so no autonomous patch was attempted.',
-			'',
-			`Reason: ${reason}`,
-			evidence.length ? `Evidence: ${evidence.join(', ')}` : '',
-			`Issue Log ID: ${log._id}`,
-			`Issue Counter: ${log.autofix_error_count_string || 'n/a'}`,
-			`Client: ${log.client_name || log.id_client || 'unknown'}`,
-			`Source App: ${log.source_app || 'unknown'}`,
-			`Environment: ${log.source_environment || log.openai_environment || 'unknown'}`,
-			`Issue Hash: ${log.issue_hash || log.email_hash || 'n/a'}`,
-			'',
-			'Manual library release/fix is required. App-level auto-fix remains blocked for this issue to protect credits.'
-		].filter(Boolean).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 library-issue auto-fix email', {recipient, logId: log._id, error});
-			}
-		}
-	}
-
-	private async blockLibraryOwnedIssue(email: ErrorEmail, log: ErrorAutoFixLogModel, gate: LibraryIssueGateDecision): Promise<AutoFixResult> {
-		const reason = gate.reason || 'Library-owned issue detected.';
-		const details = gate.evidence.length ? `Signals: ${gate.evidence.join(', ')}` : '';
-		const message = [reason, details].filter(Boolean).join(' ');
-		const updated = (await this.updateLog(log._id, {
-			status: 'skipped',
-			ignored: true,
-			last_error: message,
-			last_result_at: new Date()
-		})) || log;
-		await this.notifyCustomerWorkflowStatus('blocked_library_issue', email, updated, {
-			error: reason,
-			notes: details
-		});
-		await this.sendLibraryIssueNotice(updated, reason, gate.evidence);
-		return {
-			status: 'skipped',
-			email,
-			error: message,
-			log: updated,
-			reason: 'library_issue_blocked',
-			summary: updated.plan_summary || email.subject,
-			notes: details
-		};
-	}
-
-	private shouldNotifySkip(reason: string): boolean {
-		return ['in_progress', 'success', 'ignored', 'duplicate', 'pending'].indexOf(reason) === -1;
-	}
-
-	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 buildAICoderWorkflowSummary(
-		stage: 'detected_autofix_enabled' | 'detected_autofix_disabled' | 'completed_success' | 'completed_failed' | 'blocked_library_issue',
-		email: ErrorEmail,
-		log: ErrorAutoFixLogModel,
-		extra?: { error?: string; notes?: string }
-	): string {
-		return buildGeneratedAppAutoFixSummary(stage, {
-			source_app: String(log?.source_app || email?.sourceApp || '').trim(),
-			environment: String(log?.source_environment || email?.sourceEnvironment || '').trim(),
-			severity: String(log?.severity || email?.severity || '').trim(),
-			error: extra?.error
-		}, extra);
-	}
-
-	private buildResolveIOProjectWorkflowDetails(
-		email: ErrorEmail,
-		log: ErrorAutoFixLogModel,
-		extra?: { error?: string; notes?: string }
-	): string {
-		return buildResolveIOProjectAutoFixDetails({
-			client_name: log?.client_name || email?.client_name || '',
-			issue_counter: log?.autofix_error_count_string || '',
-			source_app: log?.source_app || email?.sourceApp || '',
-			environment: log?.source_environment || email?.sourceEnvironment || log?.openai_environment || '',
-			severity: log?.severity || email?.severity || '',
-			issue_hash: log?.issue_hash || email?.issueHash || log?.email_hash || '',
-			log_id: log?._id || '',
-			notes: extra?.notes,
-			error: extra?.error
-		});
-	}
-
-	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 notifyCustomerWorkflowStatus(
-		stage: 'detected_autofix_enabled' | 'detected_autofix_disabled' | 'completed_success' | 'completed_failed' | 'blocked_library_issue',
-		email: ErrorEmail,
-		log: ErrorAutoFixLogModel,
-		extra?: { error?: string; notes?: string }
-	): Promise<void> {
-		const idClient = String(log?.id_client || email?.id_client || '').trim();
-		let isGeneratedApp = false;
-		if (idClient) {
-			isGeneratedApp = await this.isGeneratedAICoderClient(idClient);
-		}
-		else {
-			const resolvedEnvironment = this.resolveEnvironmentForTask(email, log);
-			const app = await this.resolveAutoFixApp(email, log, resolvedEnvironment);
-			isGeneratedApp = !!app;
-		}
-
-		if (!isGeneratedApp && stage !== 'completed_success') {
-			return;
-		}
-
-		const issueKey = String(log?.issue_hash || log?.email_hash || email?.issueHash || email?.hash || log?._id || '').trim();
-		const clientName = String(log?.client_name || email?.client_name || '').trim();
-		const targetPayload: Record<string, any> = {};
-		if (idClient) {
-			targetPayload.target_type = isGeneratedApp ? 'client_internal' : 'client_admins';
-			targetPayload.id_client = idClient;
-			targetPayload.client_name = clientName || undefined;
-		}
-		else {
-			const idUsers = await this.resolveLocalNotificationUserIds(isGeneratedApp);
-			if (!idUsers.length) {
-				return;
-			}
-			targetPayload.target_type = 'users';
-			targetPayload.id_users = idUsers;
-			targetPayload.client_name = clientName || undefined;
-		}
-
-		const basePayload: Record<string, any> = {
-			...targetPayload,
-			category: 'autofix',
-			source: 'error-auto-fix',
-			source_id: String(log?._id || '').trim() || undefined,
-			dedupe_key: issueKey ? `autofix:${issueKey}:${stage}` : `autofix:${String(log?._id || '').trim()}:${stage}`,
-			metadata: {
-				issue_hash: log?.issue_hash || email?.issueHash || '',
-				log_id: log?._id || '',
-				severity: log?.severity || email?.severity || '',
-				source_app: log?.source_app || email?.sourceApp || '',
-				source_environment: log?.source_environment || email?.sourceEnvironment || '',
-				error: extra?.error || '',
-				notes: extra?.notes || ''
-			}
-		};
-
-		let payload: Record<string, any> = {};
-		if (isGeneratedApp) {
-			if (stage === 'detected_autofix_enabled') {
-				payload = {
-					title: 'Issue detected. Auto-fix is in progress.',
-					message: 'We detected an issue in your app and started an automatic fix workflow. We will notify you when it is complete.',
-					severity: 'info',
-					details: this.buildAICoderWorkflowSummary(stage, email, log, extra)
-				};
-			}
-			else if (stage === 'detected_autofix_disabled') {
-				payload = {
-					title: 'Issue detected. Auto-fix is disabled.',
-					message: 'We detected an issue, but automatic fixing is not enabled. Please ask the AI assistant to investigate this issue.',
-					severity: 'warning',
-					details: this.buildAICoderWorkflowSummary(stage, email, log, extra)
-				};
-			}
-			else if (stage === 'completed_success') {
-				payload = {
-					title: 'Auto-fix completed successfully.',
-					message: 'Your issue was fixed automatically and the update was published.',
-					severity: 'success',
-					details: this.buildAICoderWorkflowSummary(stage, email, log, extra)
-				};
-			}
-			else if (stage === 'blocked_library_issue') {
-				payload = {
-					title: 'Issue requires a platform library update.',
-					message: 'We detected this issue in shared platform libraries, so app auto-fix was stopped. Our engineering team has been notified to ship a library-level fix.',
-					severity: 'warning',
-					details: this.buildAICoderWorkflowSummary(stage, email, log, extra)
-				};
-			}
-			else {
-				payload = {
-					title: 'Auto-fix needs manual review.',
-					message: 'We could not complete an automatic fix for this issue. Manual follow-up is required.',
-					severity: 'warning',
-					details: this.buildAICoderWorkflowSummary(stage, email, log, extra)
-				};
-			}
-		}
-		else {
-			payload = {
-				title: 'ResolveIO project auto-fix completed',
-				message: `A fix for ${String(log?.source_app || email?.sourceApp || 'the project').trim()} completed successfully.`,
-				severity: 'success',
-				details: this.buildResolveIOProjectWorkflowDetails(email, log, extra)
-			};
-		}
-
-		try {
-			await ResolveIOServer.getMainServer().getMethodManager().callMethod('createCustomerNotification', {
-				...basePayload,
-				...payload
-			});
-		}
-		catch (error) {
-			this.debugLog('Failed to create customer auto-fix notification', {
-				logId: log?._id,
-				stage,
-				error: error?.message || error
-			});
-		}
-	}
-
-	private async delay(ms: number): Promise<void> {
-		// eslint-disable-next-line no-restricted-syntax
-		await new Promise(resolve => setTimeout(resolve, ms));
-	}
-
-	public async reportDevError(options: DevErrorReportOptions): Promise<void> {
-		const subject = (options?.subject || '').trim() || 'ResolveIO alert';
-		const body = options?.body || '';
-		const sourceApp = options?.sourceApp || ResolveIOServer.getClientName() || 'resolveio-server';
-		const environment = options?.environment || process.env.NODE_ENV || '';
-		const severity = options?.severity || 'infrastructure';
-		const fingerprint = (options?.fingerprint || createHash('sha256').update(`${sourceApp}:${environment || 'env'}:${subject}`).digest('hex')).trim();
-		const metadata = options?.metadata && Object.keys(options.metadata).length ? options.metadata : undefined;
-
-		if (!this.isReady()) {
-			console.warn('AutoFix manager not ready for dev alert', {subject, environment});
-			return;
-		}
-
-		try {
-			await this.ingestErrorReport({
-				sourceApp,
-				environment,
-				message: subject,
-				stack: body,
-				severity,
-				metadata,
-				fingerprint,
-				idempotencyKey: options?.idempotencyKey,
-				clientId: options?.clientId,
-				clientName: options?.clientName,
-				clientSlug: options?.clientSlug,
-				reportedBy: 'resolveio-server'
-			});
-		}
-		catch (err) {
-			console.error('Failed to log developer alert', subject, err);
-		}
-	}
-
-	public async ingestErrorReport(report: ErrorReportPayload): Promise<ErrorReportIngestResult> {
-		if (!this.isReady()) {
-			throw new Error('ErrorAutoFixManager is not enabled.');
-		}
-
-		if (!report || !report.sourceApp || !report.message) {
-			throw new Error('Invalid error report payload.');
-		}
-
-		const normalizedReport: ErrorReportPayload = {
-			...report,
-			message: (report.message || '').toString(),
-			stack: report.stack ? report.stack.toString() : undefined,
-			metadata: report.metadata || undefined,
-			context: report.context || undefined,
-			attachments: Array.isArray(report.attachments) ? report.attachments : undefined,
-			reportedAt: report.reportedAt instanceof Date && !Number.isNaN(report.reportedAt.getTime()) ? report.reportedAt : new Date()
-		};
-
-		const email = this.buildEmailFromReport(normalizedReport);
-		email.reportedAt = normalizedReport.reportedAt;
-		email.openai_environment = normalizedReport.clientRepo || email.openai_environment;
-		email.fromAddress = this.extractEmailAddress(normalizedReport.clientEmail || normalizedReport.reportedBy || email.from || '');
-		if (!email.fromAddress && normalizedReport.clientSlug) {
-			email.fromAddress = `${normalizedReport.clientSlug}@errors.resolveio.com`;
-		}
-
-		const rawHash = normalizedReport.idempotencyKey ? normalizedReport.idempotencyKey.trim() : '';
-		email.rawHash = rawHash || this.generateRawEmailHash(email);
-		const fingerprint = normalizedReport.fingerprint ? normalizedReport.fingerprint.trim() : '';
-		if (fingerprint) {
-			email.issueHash = fingerprint;
-			email.hash = fingerprint;
-		}
-		else {
-			email.issueHash = this.generateIssueHash(email);
-			email.hash = email.issueHash || email.rawHash;
-		}
-
-		const client = await this.resolveClientForReport(normalizedReport);
-		const autoOptimizeEnabled = await this.resolveAutoOptimizeEnabled();
-		const reservation = await this.reserveLog(email, client, autoOptimizeEnabled);
-
-		if (!reservation.proceed) {
-			if (reservation.reason && this.shouldNotifySkip(reservation.reason)) {
-				await this.notify({
-					status: 'skipped',
-					email,
-					reason: reservation.reason,
-					error: `Skipped auto-fix (${reservation.reason}).`,
-					log: reservation.log
-				});
-			}
-
-			return {
-				status: reservation.reason === 'duplicate' ? 'duplicate' : (reservation.reason as any) || 'skipped',
-				reason: reservation.reason,
-				log: reservation.log
-			};
-		}
-
-		email.logId = reservation.log._id;
-		const classification = this.classifyEmail(email);
-		await this.updateLog(email.logId, {
-			id_client: client?._id,
-			client_name: client?.name,
-			from_email: email.fromAddress,
-			source_type: classification.source,
-			classification_reason: classification.reason || '',
-			openai_environment: email.openai_environment || reservation.log.openai_environment || this.determineOpenAIEnvironment(client),
-			source_app: email.sourceApp,
-			source_environment: email.sourceEnvironment,
-			severity: email.severity,
-			reported_by: email.reportedBy || email.fromAddress,
-			report_metadata: email.reportMetadata,
-			report_context: email.reportContext,
-			attachments: email.attachments,
-			last_reported_at: email.reportedAt || new Date()
-		});
-
-		if (classification.skip) {
-			const updated = await this.updateLog(email.logId, {
-				status: 'skipped',
-				ignored: !!classification.markIgnored,
-				last_error: classification.reason || 'Ignored non-app alert',
-				last_result_at: new Date()
-			});
-
-			if (classification.notify) {
-				await this.notify({
-					status: 'skipped',
-					email,
-					error: classification.reason,
-					log: updated,
-					reason: 'classified'
-				});
-			}
-
-			return {
-				status: 'skipped',
-				reason: classification.reason,
-				log: updated
-			};
-		}
-
-		if (!autoOptimizeEnabled) {
-			const queued = await this.updateLog(email.logId, {
-				status: 'pending'
-			});
-			await this.notifyCustomerWorkflowStatus('detected_autofix_disabled', email, queued || reservation.log);
-
-			return {
-				status: 'queued',
-				log: queued
-			};
-		}
-
-		await this.notifyCustomerWorkflowStatus('detected_autofix_enabled', email, reservation.log);
-		const result = await this.processEmail(email, reservation.log);
-		await this.notify(result);
-		const finalLog = result.log || (await ErrorAutoFixLogs.findOne({_id: email.logId}));
-		return {
-			status: result.status,
-			reason: result.reason,
-			log: finalLog || result.log
-		};
-	}
-
-	public async runLog(logId: string): Promise<AutoFixResult> {
-		if (!this.config.enabled) {
-			throw new Error('Auto-fix manager disabled.');
-		}
-
-		const log = await ErrorAutoFixLogs.findOne({_id: logId});
-		if (!log) {
-			throw new Error('Auto-fix log not found.');
-		}
-
-		if (log.ignored) {
-			throw new Error('Auto-fix log is ignored.');
-		}
-
-		if (log.status === 'in_progress') {
-			throw new Error('Auto-fix workflow already running.');
-		}
-
-		if (!log.body) {
-			throw new Error('Auto-fix log is missing email body.');
-		}
-
-		const now = new Date();
-		const email = this.buildEmailFromLog(log);
-		const classification = this.classifyEmail(email);
-		if (classification.skip && classification.markIgnored) {
-			const ignoredLog = await this.updateLog(logId, {
-				status: 'skipped',
-				ignored: true,
-				last_error: classification.reason || 'Mongo-origin error ignored for auto-fix',
-				last_result_at: now
-			});
-			return {
-				status: 'skipped',
-				email,
-				reason: 'classified',
-				error: classification.reason || 'Mongo-origin error ignored for auto-fix',
-				log: ignoredLog
-			};
-		}
-
-		const inProgressLog = (await ErrorAutoFixLogs.findOneAndUpdate({_id: logId}, {
-			$inc: {
-				attempt_count: 1
-			},
-			$set: {
-				status: 'in_progress',
-				last_attempt_at: now,
-				last_error: '',
-				ignored: false
-			}
-		}, {
-			returnDocument: 'after'
-		})) || log;
-
-		const result = await this.processEmail(email, inProgressLog);
-		await this.notify(result);
-		return result;
-	}
-
-	private buildEmailFromLog(log: ErrorAutoFixLogModel): ErrorEmail {
-		return {
-			key: log.message_id || log._id,
-			subject: log.subject,
-			body: log.body || '',
-			messageId: log.message_id,
-			hash: log.issue_hash || log.email_hash,
-			rawHash: log.email_hash,
-			issueHash: log.issue_hash,
-			raw: log.body || '',
-			id_client: log.id_client,
-			client_name: log.client_name,
-			fromAddress: log.from_email,
-			source_type: log.source_type || 'app',
-			classification_reason: log.classification_reason,
-			openai_environment: log.openai_environment,
-			sourceApp: log.source_app,
-			sourceEnvironment: log.source_environment,
-			severity: log.severity,
-			reportedBy: log.reported_by,
-			reportMetadata: log.report_metadata,
-			reportContext: log.report_context,
-			attachments: log.attachments,
-			reportedAt: log.last_reported_at
-		};
-	}
-
-	private async processEmail(email: ErrorEmail, log: ErrorAutoFixLogModel): Promise<AutoFixResult> {
-		const libraryIssueGate = this.evaluateLibraryIssueGate(email, log);
-		if (libraryIssueGate.blocked) {
-			return await this.blockLibraryOwnedIssue(email, log, libraryIssueGate);
-		}
-
-		if (this.config.dashboardWorkflowEnabled) {
-			const dashboardResult = await this.dispatchDashboardWorkflow(email, log);
-			if (dashboardResult.status === 'in_progress' || dashboardResult.status === 'success') {
-				return dashboardResult;
-			}
-			if (!this.config.dashboardFallbackToGithub) {
-				return dashboardResult;
-			}
-
-			this.debugLog('Dashboard workflow unavailable; falling back to GitHub workflow.', {
-				logId: log?._id,
-				reason: dashboardResult.reason,
-				error: dashboardResult.error
-			});
-		}
-
-		return await this.dispatchGithubWorkflow(email, log);
-	}
-
-	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 resolveAutoFixApp(email: ErrorEmail, log: ErrorAutoFixLogModel, resolvedEnvironment: string): Promise<AICoderAppModel | null> {
-		const clientId = (email.id_client || log.id_client || '').trim();
-		if (clientId) {
-			const byClientId = await AICoderApps.findOne({client_id: clientId}, {
-				sort: {
-					updatedAt: -1,
-					createdAt: -1
-				}
-			});
-			if (byClientId) {
-				return byClientId;
-			}
-		}
-
-		const lookupClientCandidates = [
-			(email.client_name || '').trim(),
-			(log.client_name || '').trim()
-		].filter(Boolean);
-		for (const candidate of lookupClientCandidates) {
-			const escaped = this.escapeRegex(candidate);
-			const clientDoc = await Clients.findOne({
-				$or: [
-					{name: {$regex: `^${escaped}$`, $options: 'i'}},
-					{demo_name: {$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;
-			}
-		}
-
-		const environmentRepo = (resolvedEnvironment || '').trim();
-		if (environmentRepo) {
-			const escapedRepo = this.escapeRegex(environmentRepo);
-			const byRepo = await AICoderApps.findOne({
-				repo: {
-					$regex: `^${escapedRepo}$`,
-					$options: 'i'
-				}
-			}, {
-				sort: {
-					updatedAt: -1,
-					createdAt: -1
-				}
-			});
-			if (byRepo) {
-				return byRepo;
-			}
-		}
-
-		const appNameCandidates = [
-			(email.sourceApp || '').trim(),
-			(log.source_app || '').trim()
-		].filter(Boolean);
-		for (const candidate of appNameCandidates) {
-			const escaped = this.escapeRegex(candidate);
-			const bySlugOrName = await AICoderApps.findOne({
-				$or: [
-					{slug: {$regex: `^${escaped}$`, $options: 'i'}},
-					{name: {$regex: `^${escaped}$`, $options: 'i'}}
-				]
-			}, {
-				sort: {
-					updatedAt: -1,
-					createdAt: -1
-				}
-			});
-			if (bySlugOrName) {
-				return bySlugOrName;
-			}
-		}
-
-		return null;
-	}
-
-	private buildDashboardAutoFixTitle(email: ErrorEmail, log: ErrorAutoFixLogModel, app: AICoderAppModel): string {
-		const identifier = log.autofix_error_count_string || (log._id || '').slice(-6) || 'error';
-		const source = (email.sourceApp || log.source_app || app?.name || 'application').trim();
-		return `Auto-fix ${identifier}: ${source}`;
-	}
-
-	private buildDashboardAutoFixDescription(email: ErrorEmail, log: ErrorAutoFixLogModel, app: AICoderAppModel): string {
-		const normalizedBody = this.normalizeEmailText(email.body || log.body || '', 15000);
-		const metadata = log.report_metadata && Object.keys(log.report_metadata).length
-			? JSON.stringify(log.report_metadata, null, 2)
-			: '';
-		const context = log.report_context && Object.keys(log.report_context).length
-			? JSON.stringify(log.report_context, null, 2)
-			: '';
-		const attachments = Array.isArray(log.attachments) ? log.attachments : [];
-		const attachmentLines = attachments.length
-			? attachments.map(att => `- ${(att?.name || 'attachment').trim()} ${att?.url ? `(${att.url})` : ''}`.trim()).join('\n')
-			: '(none)';
-		const lines: string[] = [
-			'Autonomous production error remediation request.',
-			'',
-			'Hard requirements:',
-			'1. Before changing code, query the project MongoDB diagnostics logs for the latest context.',
-			'2. Query `error-autofix-logs` using `_id`, `issue_hash`, and `email_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. Reproduce and fix the reported issue with the smallest safe code change.',
-			'6. Keep query/result behavior backward compatible unless explicitly required by the bug fix.',
-			'7. Run project build checks and continue iterating until the build is green.',
-			'8. Ensure there are no new lint/type/runtime regressions introduced by the fix.',
-			'9. Finish by publishing the passing fix to the default branch and deploying artifacts.',
-			'',
-			`App: ${app?.name || app?._id || 'unknown'}`,
-			`Repo: ${app?.repo || 'unknown'}`,
-			`Environment: ${email.sourceEnvironment || log.source_environment || 'unknown'}`,
-			`Severity: ${email.severity || log.severity || 'error'}`,
-			`Fingerprint: ${email.issueHash || log.issue_hash || log.email_hash || 'n/a'}`,
-			`Error Log Id: ${String(log?._id || '').trim() || 'n/a'}`,
-			`Previous Dashboard Job Id: ${String(log?.openai_task_id || '').trim() || 'n/a'}`,
-			'',
-			'Reported error payload:',
-			'```',
-			normalizedBody || '(empty error body)',
-			'```',
-			'',
-			'Attachments:',
-			attachmentLines
-		];
-		if (metadata) {
-			lines.push('', 'Metadata JSON:', '```json', metadata, '```');
-		}
-		if (context) {
-			lines.push('', 'Context JSON:', '```json', context, '```');
-		}
-		return lines.join('\n');
-	}
-
-	private evaluateDashboardPublishOutcome(job: AIDashboardJob): { success: boolean; branchName?: string; message: 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,
-				branchName: (branchMatch && branchMatch[1]) ? branchMatch[1].trim() : undefined,
-				message: publishEntry
-			};
-		}
-
-		const skippedEntry = lastMatch(entry => /Publish skipped/i.test(entry || ''));
-		if (skippedEntry) {
-			return {
-				success: !this.config.dashboardPublishRequired,
-				message: skippedEntry
-			};
-		}
-
-		return {
-			success: !this.config.dashboardPublishRequired,
-			message: 'Dashboard job completed without a publish confirmation log entry.'
-		};
-	}
-
-	private queueDashboardMonitor(log: ErrorAutoFixLogModel, email: ErrorEmail, jobId: string, effectiveEnvironment: string): void {
-		const logId = (log?._id || '').trim();
-		const normalizedJobId = (jobId || '').trim();
-		if (!logId || !normalizedJobId) {
-			return;
-		}
-		if (this.dashboardMonitors.has(logId)) {
-			return;
-		}
-
-		const monitor = (async () => {
-			try {
-				await this.monitorDashboardAutoFixJob(log, email, normalizedJobId, effectiveEnvironment);
-			}
-			catch (error) {
-				console.error('Auto-fix dashboard monitor failed', {logId, jobId: normalizedJobId, error});
-			}
-			finally {
-				this.dashboardMonitors.delete(logId);
-			}
-		})();
-
-		this.dashboardMonitors.set(logId, monitor);
-	}
-
-	private async monitorDashboardAutoFixJob(log: ErrorAutoFixLogModel, email: ErrorEmail, jobId: string, effectiveEnvironment: string): Promise<void> {
-		const logId = (log?._id || '').trim();
-		if (!logId) {
-			return;
-		}
-
-			const fail = async (message: string): Promise<void> => {
-				const failedLog = (await this.updateLog(logId, {
-					status: 'failed',
-				last_error: message,
-				last_result_at: new Date(),
-				openai_task_id: jobId,
-					openai_environment: effectiveEnvironment
-				})) || log;
-				await this.notifyCustomerWorkflowStatus('completed_failed', email, failedLog, {error: message});
-				await this.notify({
-					status: 'failed',
-					email,
-				error: message,
-				log: failedLog,
-				summary: failedLog.plan_summary || email.subject
-			});
-		};
-
-		try {
-			await this.waitForDashboardJobStop(jobId, this.config.dashboardWaitTimeoutMs);
-		}
-		catch (error) {
-			const message = error?.message || 'Failed while waiting for dashboard job completion.';
-			await fail(message);
-			return;
-		}
-
-		let isRunning = false;
-		try {
-			isRunning = await this.isDashboardJobRunning(jobId);
-		}
-		catch (error) {
-			const message = error?.message || 'Unable to confirm dashboard job completion state.';
-			await fail(message);
-			return;
-		}
-
-		if (isRunning) {
-			await fail(`Dashboard job ${jobId} timed out before completion.`);
-			return;
-		}
-
-		const job = await AIDashboardJobs.findOne({_id: jobId}) as AIDashboardJob | null;
-		if (!job) {
-			await fail(`Dashboard job ${jobId} not found.`);
-			return;
-		}
-
-		if (job.phase !== 'COMPLETE' || job.paused) {
-			await fail(`Dashboard job ${jobId} ended in phase ${job.phase || 'unknown'}${job.paused ? ' (paused)' : ''}.`);
-			return;
-		}
-
-		const publishOutcome = this.evaluateDashboardPublishOutcome(job);
-		if (!publishOutcome.success) {
-			await fail(publishOutcome.message);
-			return;
-		}
-
-		const fallbackBranch = (String(this._serverConfig?.['GITHUB_DEFAULT_BRANCH'] || process.env.GITHUB_DEFAULT_BRANCH || 'main').trim() || 'main');
-		const branchName = publishOutcome.branchName || fallbackBranch;
-			const successLog = (await this.updateLog(logId, {
-				status: 'success',
-			branch_name: branchName,
-			pr_url: '',
-			last_error: '',
-			last_result_at: new Date(),
-			openai_task_id: jobId,
-				openai_environment: effectiveEnvironment
-			})) || log;
-			await this.notifyCustomerWorkflowStatus('completed_success', email, successLog, {notes: publishOutcome.message});
-
-			await this.notify({
-				status: 'success',
-			email,
-			branchName,
-			log: successLog,
-			summary: successLog.plan_summary || email.subject,
-			notes: publishOutcome.message
-		});
-	}
-
-	private async dispatchDashboardWorkflow(email: ErrorEmail, log: ErrorAutoFixLogModel): Promise<AutoFixResult> {
-		const fail = async (
-			status: 'failed' | 'skipped',
-			reason: string,
-			message: string
-		): Promise<AutoFixResult> => {
-			const updated = (await this.updateLog(log._id, {
-				status,
-				last_error: message,
-				last_result_at: new Date()
-			})) || log;
-			return {
-				status,
-				email,
-				error: message,
-				log: updated,
-				reason
-			};
-		};
-
-		const openaiEnvironment = this.resolveEnvironmentForTask(email, log);
-		const app = await this.resolveAutoFixApp(email, log, openaiEnvironment);
-		if (!app?._id) {
-			return await fail('skipped', 'dashboard_app_not_found', 'No AI Coder app found for this error log.');
-		}
-
-		const repo = (app.repo || '').trim();
-		if (!repo) {
-			return await fail('skipped', 'dashboard_repo_missing', 'Resolved AI Coder app is missing repo configuration.');
-		}
-
-		const effectiveEnvironment = repo;
-		const emailHash = email.issueHash || email.hash || this.generateIssueHash(email);
-		const rawHash = email.rawHash || this.generateRawEmailHash(email);
-		const title = this.buildDashboardAutoFixTitle(email, log, app);
-		const description = this.buildDashboardAutoFixDescription(email, log, app);
-
-		let job: AIDashboardJob;
-		try {
-			job = await this.createDashboardJob({
-				project: app._id,
-				title,
-				description,
-				repo,
-				path: app.git_local_path || undefined,
-				projectRoot: app.project_root || undefined
-			});
-		}
-		catch (error) {
-			const message = error?.message || 'Unable to enqueue dashboard auto-fix job.';
-			return await fail('failed', 'dashboard_job_create_failed', message);
-		}
-
-		const jobId = (job?._id || '').trim();
-		if (!jobId) {
-			return await fail('failed', 'dashboard_job_missing_id', 'Dashboard job created without an id.');
-		}
-
-			const queuedLog = (await this.updateLog(log._id, {
-				status: 'in_progress',
-				last_attempt_at: new Date(),
-			branch_name: '',
-			pr_url: '',
-			last_error: '',
-			openai_environment: effectiveEnvironment,
-			issue_hash: emailHash,
-			email_hash: rawHash,
-			openai_task_id: jobId,
-			plan_summary: title,
-				plan_body: description
-			})) || log;
-			this.queueDashboardMonitor(queuedLog, email, jobId, effectiveEnvironment);
-
-			return {
-			status: 'in_progress',
-			email,
-			log: queuedLog,
-			reason: 'dashboard_job_queued',
-			summary: title,
-			notes: `Dashboard job ${jobId} queued for autonomous build/fix/publish/deploy.`
-		};
-	}
-
-	private async dispatchGithubWorkflow(email: ErrorEmail, log: ErrorAutoFixLogModel): Promise<AutoFixResult> {
-		const openaiEnvironment = this.resolveEnvironmentForTask(email, log);
-		const fallbackEnv = this.config.githubOwner && this.config.githubRepo ? `${this.config.githubOwner}/${this.config.githubRepo}` : '';
-		const resolvedEnvironment = (openaiEnvironment || fallbackEnv || '').trim();
-		const repoTarget = this.parseRepoTarget(resolvedEnvironment) || this.parseRepoTarget(fallbackEnv);
-
-		this.debugLog('Starting GitHub PR workflow.', {
-			emailKey: email.key,
-			logId: log._id,
-			openaiEnvironment: resolvedEnvironment,
-			repoTarget
-		});
-
-		if (!this.config.githubToken) {
-			const updated = (await this.updateLog(log._id, {
-				status: 'skipped',
-				last_error: 'GitHub token not configured',
-				last_result_at: new Date(),
-				id_client: email.id_client,
-				client_name: email.client_name,
-				from_email: email.fromAddress,
-				source_type: email.source_type,
-				classification_reason: email.classification_reason || '',
-				openai_environment: resolvedEnvironment
-			})) || log;
-
-			return {
-				status: 'skipped',
-				email,
-				error: 'GitHub token not configured',
-				log: updated,
-				reason: 'missing_github_token'
-			};
-		}
-
-		if (!repoTarget) {
-			const updated = (await this.updateLog(log._id, {
-				status: 'skipped',
-				last_error: 'GitHub repository not configured',
-				last_result_at: new Date(),
-				id_client: email.id_client,
-				client_name: email.client_name,
-				from_email: email.fromAddress,
-				source_type: email.source_type,
-				classification_reason: email.classification_reason || '',
-				openai_environment: resolvedEnvironment
-			})) || log;
-
-			return {
-				status: 'skipped',
-				email,
-				error: 'GitHub repository not configured',
-				log: updated,
-				reason: 'missing_github_repo'
-			};
-		}
-
-		const effectiveEnv = `${repoTarget.owner}/${repoTarget.repo}`;
-		const emailHash = email.issueHash || email.hash || this.generateIssueHash(email);
-		const rawHash = email.rawHash || this.generateRawEmailHash(email);
-		const workBranch = this.buildWorkBranch(emailHash);
-		const contextIdentifier = (emailHash || '').slice(0, 12) || 'autofix';
-		const contextPath = `.openai/error-context/${contextIdentifier}.md`;
-		const normalizedBody = this.normalizeEmailText(email.body || '');
-		const contextContent = this.buildContextMarkdown(email, contextIdentifier, normalizedBody);
-		const commentBody = this.buildOpenAIComment(email, contextPath, normalizedBody);
-
-		await this.updateLog(log._id, {
-			status: 'in_progress',
-			last_attempt_at: new Date(),
-			branch_name: workBranch,
-			pr_url: '',
-			last_error: '',
-			openai_environment: effectiveEnv,
-			issue_hash: emailHash,
-			email_hash: rawHash
-		});
-
-		try {
-			const baseBranch = await this.resolveBaseBranch(repoTarget);
-			const baseSha = await this.getBranchSha(repoTarget, baseBranch);
-			await this.ensureBranch(repoTarget, workBranch, baseBranch, baseSha);
-			await this.upsertContextFile(repoTarget, workBranch, contextPath, contextContent);
-
-				let pr = await this.findOpenPullRequest(repoTarget, workBranch, baseBranch);
-				if (!pr) {
-					const title = `AI Autofix: ${(email.subject || 'ResolveIO Error').slice(0, 180)}`;
-					const bodyLines = [
-						'This PR was opened automatically to let AI investigate the reported failure.',
-						'',
-						`Context file: \`${contextPath}\``
-					];
-				pr = await this.createPullRequest(repoTarget, workBranch, baseBranch, title, bodyLines.join('\n'));
-			}
-
-			await this.commentOnPullRequest(repoTarget, pr.number, commentBody);
-
-			const updated = (await this.updateLog(log._id, {
-				status: 'success',
-				branch_name: workBranch,
-				pr_url: pr.html_url,
-				plan_summary: email.subject,
-				plan_body: commentBody,
-				last_result_at: new Date(),
-				id_client: email.id_client,
-				client_name: email.client_name,
-				from_email: email.fromAddress,
-				source_type: email.source_type,
-				classification_reason: email.classification_reason || '',
-				openai_environment: effectiveEnv,
-				issue_hash: emailHash,
-				email_hash: rawHash
-			})) || log;
-
-			return {
-				status: 'success',
-				email,
-				branchName: workBranch,
-				prUrl: pr.html_url,
-				log: updated,
-				summary: email.subject,
-				notes: `Context file: ${contextPath}`
-			};
-		}
-		catch (err) {
-			const message = err?.message || 'GitHub workflow failed.';
-				const updated = (await this.updateLog(log._id, {
-					status: 'failed',
-					last_error: message,
-					last_result_at: new Date(),
-					id_client: email.id_client,
-					client_name: email.client_name,
-					from_email: email.fromAddress,
-					source_type: email.source_type,
-					classification_reason: email.classification_reason || '',
-					openai_environment: effectiveEnv,
-					issue_hash: emailHash,
-					email_hash: rawHash
-			})) || log;
-
-			return {
-				status: 'failed',
-				email,
-				error: message,
-				log: updated
-			};
-		}
-	}
-
-	private async notify(result: AutoFixResult): Promise<void> {
-		if (result.status === 'in_progress') {
-			return;
-		}
-
-		if (result.status === 'skipped' && result.reason && !this.shouldNotifySkip(result.reason)) {
-			return;
-		}
-
-		const recipients = this.config.notifyEmails.length
-			? this.config.notifyEmails
-			: (result.status === 'failed' ? [DEFAULT_ERROR_ALERT_EMAIL] : []);
-		if (!recipients.length) {
-			return;
-		}
-
-		let subject = '';
-		let bodyLines: string[] = [];
-		const logId = result.log?._id || '';
-		const summary = result.summary || result.log?.plan_summary || result.email.subject;
-
-		if (result.status === 'success') {
-			subject = `ResolveIO AutoFix ✔ ${summary}`;
-			bodyLines = [
-				'Auto-fix workflow completed successfully.',
-				`Client: ${result.log?.client_name || result.email.client_name || 'Unknown'}`,
-				`Source: ${result.log?.source_type || result.email.source_type || 'app'}`,
-				'',
-				`Branch: ${result.branchName || 'unknown'}`,
-				`PR: ${result.prUrl || 'pending'}`,
-				'',
-				'Summary:',
-				summary || '(none)',
-				''
-			];
-
-			if (result.notes) {
-				bodyLines.push(`Notes: ${result.notes}`, '');
-			}
-
-			if (logId) {
-				bodyLines.push(`Log ID: ${logId}`);
-			}
-		}
-		else if (result.status === 'failed') {
-			subject = `ResolveIO AutoFix ✖ ${summary}`;
-			bodyLines = [
-				'Auto-fix workflow failed.',
-				`Reason: ${result.error || result.log?.last_error || 'Unknown error'}`,
-				`Client: ${result.log?.client_name || result.email.client_name || 'Unknown'}`,
-				`Source: ${result.log?.source_type || result.email.source_type || 'app'}`,
-				'',
-				'Email Subject:',
-				result.email.subject
-			];
-
-			if (logId) {
-				bodyLines.push('', `Log ID: ${logId}`);
-			}
-		}
-		else {
-			subject = `ResolveIO AutoFix ⚠ ${result.email.subject}`;
-			const reason = result.reason || 'skipped';
-
-			bodyLines = [
-				`Auto-fix skipped. Reason: ${reason}.`,
-				result.error && result.error !== reason ? `Details: ${result.error}` : '',
-				`Client: ${result.log?.client_name || result.email.client_name || 'Unknown'}`,
-				`Source: ${result.log?.source_type || result.email.source_type || 'app'}`,
-				''
-			];
-
-			if (logId) {
-				bodyLines.push(`Log ID: ${logId}`);
-			}
-
-			bodyLines.push('Update or remove the log entry to retry processing.');
-		}
-
-		const textBody = bodyLines.filter(line => line !== undefined && line !== null && line !== '').join('\n');
-
-		for (let email of recipients) {
-			await ResolveIOServer.getMainServer().getMethodManager().sendEmail(email, subject, textBody);
-		}
-	}
-
-}
-
-export function ensureErrorAutoFixManager(serverConfig?: any): ErrorAutoFixManager | null {
-	const existing = ResolveIOServer['AutoFixManager'] as ErrorAutoFixManager | null;
-	if (existing) {
-		return existing;
-	}
-
-	if (!configuredErrorAutoFixDependencies) {
-		return null;
-	}
-
-	const resolvedServerConfig = serverConfig || ResolveIOServer.getServerConfig();
-	if (!resolvedServerConfig) {
-		return null;
-	}
-
-	const manager = new ErrorAutoFixManager(resolvedServerConfig);
-	ResolveIOServer['AutoFixManager'] = manager;
-	return manager;
-}
-
-export async function reportDevError(options: DevErrorReportOptions): Promise<void> {
-	const manager = ensureErrorAutoFixManager();
-	if (!manager) {
-		console.warn('AutoFix manager not initialized for dev alert', options?.subject);
-		return;
-	}
-
-	await manager.reportDevError(options);
-}