@resolveio/server-lib 22.3.220 → 22.3.221

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

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