@resolveio/server-lib 22.2.5 → 22.2.7

package/managers/error-auto-fix.manager.js

@@ -0,0 +1,2934 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorAutoFixManager = void 0;
+exports.registerErrorAutoFixManagerDependencies = registerErrorAutoFixManagerDependencies;
+exports.ensureErrorAutoFixManager = ensureErrorAutoFixManager;
+exports.reportDevError = reportDevError;
+var resolveio_server_app_1 = require("../resolveio-server-app");
+var common_1 = require("../util/common");
+var axios_1 = require("axios");
+var crypto_1 = require("crypto");
+var url_1 = require("url");
+var user_collection_1 = require("../collections/user.collection");
+var customer_notification_content_manager_1 = require("./customer-notification-content.manager");
+var OPTIONAL_COLLECTION = {
+    findOne: function () { return Promise.resolve(null); },
+    findById: function () { return Promise.resolve(null); },
+    find: function () { return Promise.resolve([]); }
+};
+var AICoderApps = OPTIONAL_COLLECTION;
+var AIDashboardJobs = OPTIONAL_COLLECTION;
+var Clients = OPTIONAL_COLLECTION;
+var ErrorAutoFixLogs = null;
+var configuredErrorAutoFixDependencies = null;
+function resolveErrorAutoFixManagerDependencies(overrides) {
+    var resolved = __assign(__assign({}, (configuredErrorAutoFixDependencies || {})), (overrides || {}));
+    if (!resolved.ErrorAutoFixLogs) {
+        throw new Error('ErrorAutoFixManager dependencies are not configured.');
+    }
+    return resolved;
+}
+function applyErrorAutoFixDependencies(dependencies) {
+    configuredErrorAutoFixDependencies = dependencies;
+    Clients = dependencies.Clients || OPTIONAL_COLLECTION;
+    ErrorAutoFixLogs = dependencies.ErrorAutoFixLogs;
+    AICoderApps = dependencies.AICoderApps || OPTIONAL_COLLECTION;
+    AIDashboardJobs = dependencies.AIDashboardJobs || OPTIONAL_COLLECTION;
+}
+function registerErrorAutoFixManagerDependencies(dependencies) {
+    applyErrorAutoFixDependencies(dependencies);
+    ensureErrorAutoFixManager();
+}
+var 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'
+];
+var DEFAULT_ERROR_ALERT_EMAIL = 'dev@resolveio.com';
+var MAX_LOCAL_NOTIFICATION_USERS = 5000;
+var LIBRARY_MARKER_PATTERNS = [
+    { 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 }
+];
+var APP_OWNED_PATH_PATTERN = /(?:^|[\/\\])(angular[\/\\]app|server[\/\\]src)(?:[\/\\]|$)/i;
+var FILE_PATH_PATTERN = /(?:webpack:\/\/\/?|\/|\.\/|[A-Za-z]:\\)[^\s'"`]+?\.(?:ts|tsx|js|jsx|mjs|cjs|html|scss|css)/g;
+var ErrorAutoFixManager = /** @class */ (function () {
+    function ErrorAutoFixManager(serverConfig, dependencies) {
+        this._serverConfig = null;
+        this.githubApiBase = 'https://api.github.com';
+        this.dashboardMonitors = new Map();
+        this.ready = false;
+        var 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 disabled - missing critical configuration.');
+            return;
+        }
+        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.autoRunEnabled) {
+        // 	console.log('ErrorAutoFixManager auto-run disabled. Manual OpenAI runs required.');
+        // }
+    }
+    ErrorAutoFixManager.prototype.isReady = function () {
+        var _a;
+        return !!(this.ready && ((_a = this.config) === null || _a === void 0 ? void 0 : _a.enabled));
+    };
+    ErrorAutoFixManager.prototype.validateIngestKey = function (candidate) {
+        var _a;
+        var keys = Array.isArray((_a = this.config) === null || _a === void 0 ? void 0 : _a.ingestKeys) ? this.config.ingestKeys.filter(Boolean) : [];
+        if (!keys.length) {
+            return true;
+        }
+        if (!candidate) {
+            return false;
+        }
+        return keys.includes(candidate.trim());
+    };
+    ErrorAutoFixManager.prototype.debugLog = function (message, details) {
+        var _a;
+        if (!((_a = this.config) === null || _a === void 0 ? void 0 : _a.debugLogging)) {
+            return;
+        }
+        return;
+        if (typeof details === 'undefined') {
+            console.log("[ErrorAutoFixManager][debug] ".concat(message));
+        }
+        else {
+            console.log("[ErrorAutoFixManager][debug] ".concat(message), details);
+        }
+    };
+    ErrorAutoFixManager.prototype.resolveConfig = function () {
+        var scAutofix = (this._serverConfig && (this._serverConfig.autofix || this._serverConfig.AUTOFIX)) || {};
+        var notifyEmails = [];
+        var escalationEmails = [];
+        if (process.env.AUTOFIX_NOTIFY_EMAILS) {
+            notifyEmails = process.env.AUTOFIX_NOTIFY_EMAILS.split(',').map(function (a) { return a.trim(); }).filter(Boolean);
+        }
+        else if (Array.isArray(scAutofix.notifyEmails)) {
+            notifyEmails = scAutofix.notifyEmails.map(function (a) { return (a || '').trim(); }).filter(Boolean);
+        }
+        else if (typeof scAutofix.notifyEmails === 'string') {
+            notifyEmails = scAutofix.notifyEmails.split(',').map(function (a) { return a.trim(); }).filter(Boolean);
+        }
+        if (process.env.AUTOFIX_ESCALATION_EMAILS) {
+            escalationEmails = process.env.AUTOFIX_ESCALATION_EMAILS.split(',').map(function (a) { return a.trim(); }).filter(Boolean);
+        }
+        else if (Array.isArray(scAutofix.escalationEmails)) {
+            escalationEmails = scAutofix.escalationEmails.map(function (a) { return (a || '').trim(); }).filter(Boolean);
+        }
+        else if (typeof scAutofix.escalationEmails === 'string') {
+            escalationEmails = scAutofix.escalationEmails.split(',').map(function (a) { return a.trim(); }).filter(Boolean);
+        }
+        var getString = function (envKey, scKey, fallback) {
+            if (fallback === void 0) { fallback = ''; }
+            return process.env[envKey] || scAutofix[scKey] || fallback;
+        };
+        var getNumber = function (envKey, scKey, fallback) {
+            var envVal = Number(process.env[envKey]);
+            if (!Number.isNaN(envVal) && process.env[envKey] !== undefined) {
+                return envVal;
+            }
+            var scVal = Number(scAutofix[scKey]);
+            if (!Number.isNaN(scVal) && scAutofix[scKey] !== undefined) {
+                return scVal;
+            }
+            return fallback;
+        };
+        var getBoolean = function (envKey, scKey, fallback) {
+            if (fallback === void 0) { fallback = false; }
+            if (typeof process.env[envKey] !== 'undefined') {
+                return process.env[envKey] === 'true';
+            }
+            if (typeof scAutofix[scKey] !== 'undefined') {
+                return !!scAutofix[scKey];
+            }
+            return fallback;
+        };
+        var parseKeyList = function (value) {
+            if (Array.isArray(value)) {
+                return value.map(function (val) { return "".concat(val || '').trim(); }).filter(Boolean);
+            }
+            if (typeof value === 'string') {
+                return value.split(',').map(function (val) { return val.trim(); }).filter(Boolean);
+            }
+            return [];
+        };
+        var normalizePositiveInt = function (value, fallback) {
+            if (!Number.isFinite(value) || value <= 0) {
+                return fallback;
+            }
+            return Math.floor(value);
+        };
+        var openaiProjectId = getString('OPENAI_PROJECT_ID', 'openaiProjectId');
+        var openaiEnvironment = getString('OPENAI_ENVIRONMENT', 'openaiEnvironment', openaiProjectId);
+        var ingestSource = typeof process.env.AUTOFIX_INGEST_KEYS !== 'undefined'
+            ? process.env.AUTOFIX_INGEST_KEYS
+            : scAutofix.ingestKeys;
+        return {
+            enabled: getBoolean('AUTOFIX_ENABLED', 'enabled', false),
+            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: notifyEmails,
+            debugLogging: getBoolean('AUTOFIX_DEBUG_LOGS', 'debugLogging', false),
+            configSource: process.env.AUTOFIX_ENABLED ? 'environment' : (Object.keys(scAutofix).length ? 'serverConfig' : 'defaults'),
+            openaiEnvironment: openaiEnvironment,
+            openaiProjectId: openaiProjectId,
+            autoRunEnabled: getBoolean('AUTOFIX_AUTORUN_ENABLED', 'autoRunEnabled', false),
+            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: escalationEmails
+        };
+    };
+    ErrorAutoFixManager.prototype.extractEmailAddress = function (value) {
+        if (!value) {
+            return '';
+        }
+        var email = value;
+        var angleMatch = value.match(/<([^>]+)>/);
+        if (angleMatch && angleMatch[1]) {
+            email = angleMatch[1];
+        }
+        email = email.split(';')[0].split(',')[0];
+        return email.trim().toLowerCase();
+    };
+    ErrorAutoFixManager.prototype.escapeRegex = function (value) {
+        return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    };
+    ErrorAutoFixManager.prototype.resolveClientForEnvironment = function (environment) {
+        return __awaiter(this, void 0, void 0, function () {
+            var host, escaped, query, err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        host = this.extractHostFromUrl(environment);
+                        if (!host) {
+                            return [2 /*return*/, null];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        escaped = this.escapeRegex(host);
+                        query = {
+                            website: {
+                                $regex: escaped,
+                                $options: 'i'
+                            }
+                        };
+                        return [4 /*yield*/, Clients.findOne(query)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                    case 3:
+                        err_1 = _a.sent();
+                        console.error('ErrorAutoFixManager resolveClientForEnvironment error:', err_1);
+                        return [2 /*return*/, null];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.extractHostFromUrl = function (value) {
+        if (!value) {
+            return null;
+        }
+        var trimmed = value.trim();
+        if (!trimmed) {
+            return null;
+        }
+        try {
+            var parsed = new url_1.URL(trimmed);
+            return parsed.hostname.toLowerCase();
+        }
+        catch (_a) {
+            return trimmed.toLowerCase();
+        }
+    };
+    ErrorAutoFixManager.prototype.resolveClientForReport = function (report) {
+        return __awaiter(this, void 0, void 0, function () {
+            var byId, tryField, _a, _b, _c, err_2;
+            var _this = this;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (!report) {
+                            return [2 /*return*/, null];
+                        }
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 11, , 12]);
+                        if (!report.clientId) return [3 /*break*/, 3];
+                        return [4 /*yield*/, Clients.findById(report.clientId)];
+                    case 2:
+                        byId = _d.sent();
+                        if (byId) {
+                            return [2 /*return*/, byId];
+                        }
+                        _d.label = 3;
+                    case 3:
+                        tryField = function (field, value) { return __awaiter(_this, void 0, void 0, function () {
+                            var escaped, query;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!value) {
+                                            return [2 /*return*/, null];
+                                        }
+                                        escaped = this.escapeRegex(value);
+                                        query = {};
+                                        query[field] = { $regex: "^".concat(escaped, "$"), $options: 'i' };
+                                        return [4 /*yield*/, Clients.findOne(query)];
+                                    case 1: return [2 /*return*/, _a.sent()];
+                                }
+                            });
+                        }); };
+                        return [4 /*yield*/, tryField('name', report.clientName)];
+                    case 4:
+                        _c = (_d.sent());
+                        if (_c) return [3 /*break*/, 6];
+                        return [4 /*yield*/, tryField('demo_name', report.clientSlug)];
+                    case 5:
+                        _c = (_d.sent());
+                        _d.label = 6;
+                    case 6:
+                        _b = _c;
+                        if (_b) return [3 /*break*/, 8];
+                        return [4 /*yield*/, tryField('repo', report.clientRepo)];
+                    case 7:
+                        _b = (_d.sent());
+                        _d.label = 8;
+                    case 8:
+                        _a = _b;
+                        if (_a) return [3 /*break*/, 10];
+                        return [4 /*yield*/, this.resolveClientForEnvironment(report.environment)];
+                    case 9:
+                        _a = (_d.sent());
+                        _d.label = 10;
+                    case 10: return [2 /*return*/, (_a)];
+                    case 11:
+                        err_2 = _d.sent();
+                        console.error('ErrorAutoFixManager resolveClientForReport error:', err_2);
+                        return [2 /*return*/, null];
+                    case 12: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.determineOpenAIEnvironment = function (client) {
+        var repoCandidate = ((client === null || client === void 0 ? void 0 : client.repo) || '').trim();
+        if (repoCandidate) {
+            return repoCandidate;
+        }
+        var configEnv = (this.config.openaiEnvironment || '').trim();
+        if (configEnv) {
+            return configEnv;
+        }
+        if ((this.config.githubOwner || '').trim() && (this.config.githubRepo || '').trim()) {
+            return "".concat(this.config.githubOwner, "/").concat(this.config.githubRepo).trim();
+        }
+        return '';
+    };
+    ErrorAutoFixManager.prototype.resolveEnvironmentForTask = function (email, log) {
+        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();
+    };
+    ErrorAutoFixManager.prototype.buildEmailFromReport = function (report) {
+        var timestamp = report.reportedAt instanceof Date && !Number.isNaN(report.reportedAt.getTime())
+            ? report.reportedAt
+            : new Date();
+        var safeMessage = (report.message || '').toString().trim() || 'Unknown error';
+        var subjectBase = "[AppError] ".concat(report.sourceApp || 'application').concat(report.environment ? " (".concat(report.environment, ")") : '');
+        var subject = "".concat(subjectBase, " - ").concat(safeMessage.slice(0, 120));
+        var lines = [
+            "Source App:\t".concat(report.sourceApp),
+            "Environment:\t".concat(report.environment || 'n/a'),
+            "Severity:\t".concat(report.severity || 'error'),
+            "Client Hint:\t".concat(report.clientName || report.clientSlug || report.clientRepo || report.clientId || 'n/a'),
+            "Reported By:\t".concat(report.reportedBy || report.clientEmail || 'n/a'),
+            "Reported At:\t".concat(timestamp.toISOString()),
+            "Message:\t".concat(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(function (att) {
+                var desc = [];
+                if (att.name) {
+                    desc.push(att.name);
+                }
+                if (att.contentType) {
+                    desc.push(att.contentType);
+                }
+                if (typeof att.size === 'number') {
+                    desc.push("".concat(att.size, "b"));
+                }
+                var summary = desc.length ? desc.join(' | ') : 'attachment';
+                lines.push("- ".concat(summary).concat(att.url ? " -> ".concat(att.url) : ''));
+            });
+        }
+        if (report.fingerprint) {
+            lines.push('', "Fingerprint:\t".concat(report.fingerprint));
+        }
+        if (report.idempotencyKey) {
+            lines.push("Idempotency Key:\t".concat(report.idempotencyKey));
+        }
+        var body = lines.join('\n');
+        return {
+            key: "report:".concat(timestamp.getTime().toString(36), ":").concat(Math.random().toString(36).slice(2, 10)),
+            subject: subject,
+            body: 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
+        };
+    };
+    ErrorAutoFixManager.prototype.classifyEmail = function (email) {
+        var subject = (email.subject || '').toLowerCase();
+        var body = email.body || '';
+        var 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 (subject.includes('[database]') || subject.includes('[server]')) {
+            return { source: 'infrastructure', skip: true, reason: 'Infrastructure alert (subject tag)' };
+        }
+        var infraKeyword = INFRA_SUBJECT_KEYWORDS.find(function (keyword) { return subject.includes(keyword); });
+        if (infraKeyword) {
+            return { source: 'infrastructure', skip: true, reason: "Infrastructure alert (".concat(infraKeyword, ")") };
+        }
+        if (!body.trim()) {
+            return { source: 'noise', skip: true, reason: 'Empty error payload' };
+        }
+        var 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 };
+    };
+    ErrorAutoFixManager.prototype.generateRawEmailHash = function (email) {
+        return (0, crypto_1.createHash)('sha256').update("".concat(email.subject || '', "\n").concat(email.body || ''), 'utf8').digest('hex');
+    };
+    ErrorAutoFixManager.prototype.generateIssueHash = function (email) {
+        var subject = this.normalizeTextForHash(email.subject || '');
+        var body = this.normalizeBodyForHash(email.body || '');
+        return (0, crypto_1.createHash)('sha256').update("".concat(subject, "\n").concat(body), 'utf8').digest('hex');
+    };
+    ErrorAutoFixManager.prototype.normalizeTextForHash = function (value) {
+        if (!value) {
+            return '';
+        }
+        var 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(function (line) { return line.trim(); })
+            .filter(Boolean)
+            .slice(0, 60)
+            .join('\n');
+        return normalized.length > 4000 ? normalized.slice(0, 4000) : normalized;
+    };
+    ErrorAutoFixManager.prototype.normalizeBodyForHash = function (body) {
+        if (!body) {
+            return '';
+        }
+        var 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);
+    };
+    ErrorAutoFixManager.prototype.parseRepoTarget = function (env) {
+        var trimmed = (env || '').trim();
+        if (!trimmed) {
+            return null;
+        }
+        var _a = __read(trimmed.split('/', 2), 2), owner = _a[0], repo = _a[1];
+        if (!owner || !repo) {
+            return null;
+        }
+        return {
+            owner: owner.trim(),
+            repo: repo.trim()
+        };
+    };
+    ErrorAutoFixManager.prototype.buildWorkBranch = function (hash) {
+        var shortHash = (hash || '').toLowerCase().replace(/[^a-z0-9]/g, '').slice(0, 12) || 'autofix';
+        var prefix = (this.config.branchPrefix || 'openai/auto').trim();
+        if (!prefix) {
+            return shortHash;
+        }
+        var segments = prefix.split('/').map(function (segment) { return segment.trim(); }).filter(Boolean);
+        var sanitized = segments.map(function (segment) { return segment.replace(/[^a-zA-Z0-9._-]/g, '-'); });
+        return "".concat(sanitized.join('/'), "/").concat(shortHash);
+    };
+    ErrorAutoFixManager.prototype.normalizeEmailText = function (value, limit) {
+        if (limit === void 0) { limit = 20000; }
+        if (!value) {
+            return '';
+        }
+        var cleaned = value.replace(/\r/g, '');
+        if (cleaned.length <= limit) {
+            return cleaned;
+        }
+        return "".concat(cleaned.slice(0, limit), "\n... (truncated)");
+    };
+    ErrorAutoFixManager.prototype.buildContextMarkdown = function (email, identifier, normalizedBody) {
+        var lines = [
+            "# OpenAI Error Context: ".concat(identifier),
+            '',
+            "**Subject**: ".concat(email.subject || '(no subject)'),
+            email.fromAddress ? "**From**: ".concat(email.fromAddress) : undefined,
+            email.client_name ? "**Client**: ".concat(email.client_name) : undefined,
+            email.source_type ? "**Classification**: ".concat(email.source_type).concat(email.classification_reason ? " (".concat(email.classification_reason, ")") : '') : undefined,
+            email.id_client ? "**Client Id**: ".concat(email.id_client) : undefined,
+            '',
+            '## Body',
+            '```',
+            normalizedBody || '(empty body)',
+            '```',
+            '',
+            '_Generated by ErrorAutoFixManager_'
+        ];
+        return lines.filter(function (line) { return typeof line !== 'undefined'; }).join('\n');
+    };
+    ErrorAutoFixManager.prototype.buildOpenAIComment = function (email, contextPath, normalizedBody) {
+        var lines = [
+            '@openai review',
+            '',
+            "**Email Subject**: ".concat(email.subject || '(no subject)'),
+            email.fromAddress ? "**From**: ".concat(email.fromAddress) : undefined,
+            email.client_name ? "**Client**: ".concat(email.client_name) : undefined,
+            contextPath ? "Context file: `".concat(contextPath, "`") : undefined,
+            '',
+            '```',
+            normalizedBody || '(empty body)',
+            '```',
+            '',
+            'Please investigate this error and propose a minimal, safe fix.'
+        ];
+        return lines.filter(function (line) { return typeof line !== 'undefined'; }).join('\n');
+    };
+    ErrorAutoFixManager.prototype.formatGithubError = function (error) {
+        var _a, _b, _c;
+        if (!error) {
+            return 'GitHub request failed.';
+        }
+        var status = (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.status;
+        var message = ((_c = (_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.message) || (error === null || error === void 0 ? void 0 : error.message) || 'GitHub request failed.';
+        if (status) {
+            return "GitHub API error (".concat(status, "): ").concat(message);
+        }
+        return "GitHub API error: ".concat(message);
+    };
+    ErrorAutoFixManager.prototype.buildGithubAuthHeader = function (token) {
+        var trimmed = (token || '').trim();
+        if (!trimmed) {
+            return '';
+        }
+        if (/^(token|Bearer)\s+/i.test(trimmed)) {
+            return trimmed;
+        }
+        if (trimmed.includes('.') && !trimmed.startsWith('gh')) {
+            return "Bearer ".concat(trimmed);
+        }
+        return "token ".concat(trimmed);
+    };
+    ErrorAutoFixManager.prototype.githubRequest = function (config_1) {
+        return __awaiter(this, arguments, void 0, function (config, allow404) {
+            var authHeader, headers, finalConfig, response, err_3, status_1;
+            var _a;
+            if (allow404 === void 0) { allow404 = false; }
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        authHeader = this.buildGithubAuthHeader(this.config.githubToken);
+                        headers = __assign(__assign({}, (authHeader ? { Authorization: authHeader } : {})), { Accept: 'application/vnd.github+json', 'User-Agent': 'ResolveIO-AutoFix', 'X-GitHub-Api-Version': '2022-11-28' });
+                        finalConfig = __assign(__assign({}, config), { baseURL: this.githubApiBase, headers: __assign(__assign({}, headers), (config.headers || {})), timeout: Math.min(Math.max(this.config.commandTimeoutMs || 600000, 1000), 120000) });
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, axios_1.default.request(finalConfig)];
+                    case 2:
+                        response = _b.sent();
+                        return [2 /*return*/, response.data];
+                    case 3:
+                        err_3 = _b.sent();
+                        status_1 = (_a = err_3 === null || err_3 === void 0 ? void 0 : err_3.response) === null || _a === void 0 ? void 0 : _a.status;
+                        if (allow404 && status_1 === 404) {
+                            return [2 /*return*/, null];
+                        }
+                        throw new Error(this.formatGithubError(err_3));
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.resolveBaseBranch = function (target) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fallback, repo, defaultBranch, err_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        fallback = (this.config.baseBranch || 'main').trim();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.githubRequest({ method: 'GET', url: "/repos/".concat(target.owner, "/").concat(target.repo) })];
+                    case 2:
+                        repo = _a.sent();
+                        defaultBranch = ((repo === null || repo === void 0 ? void 0 : repo.default_branch) || '').trim();
+                        return [2 /*return*/, defaultBranch || fallback];
+                    case 3:
+                        err_4 = _a.sent();
+                        this.debugLog('Failed to fetch default branch. Falling back to configured branch.', {
+                            target: target,
+                            error: err_4 === null || err_4 === void 0 ? void 0 : err_4.message
+                        });
+                        return [2 /*return*/, fallback];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.getBranchSha = function (target, branch) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ref, sha;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.githubRequest({ method: 'GET', url: "/repos/".concat(target.owner, "/").concat(target.repo, "/git/ref/heads/").concat(branch) })];
+                    case 1:
+                        ref = _b.sent();
+                        sha = (_a = ref === null || ref === void 0 ? void 0 : ref.object) === null || _a === void 0 ? void 0 : _a.sha;
+                        if (!sha) {
+                            throw new Error("Base branch ".concat(branch, " not found."));
+                        }
+                        return [2 /*return*/, sha];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.ensureBranch = function (target, newBranch, baseBranch, baseSha) {
+        return __awaiter(this, void 0, void 0, function () {
+            var existing;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.githubRequest({ method: 'GET', url: "/repos/".concat(target.owner, "/").concat(target.repo, "/git/ref/heads/").concat(newBranch) }, true)];
+                    case 1:
+                        existing = _a.sent();
+                        if (existing) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.githubRequest({
+                                method: 'POST',
+                                url: "/repos/".concat(target.owner, "/").concat(target.repo, "/git/refs"),
+                                data: {
+                                    ref: "refs/heads/".concat(newBranch),
+                                    sha: baseSha
+                                }
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.upsertContextFile = function (target, branch, contextPath, content) {
+        return __awaiter(this, void 0, void 0, function () {
+            var encodedPath, existing, sha, commitMessage;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        encodedPath = encodeURIComponent(contextPath).replace(/%2F/g, '/');
+                        return [4 /*yield*/, this.githubRequest({
+                                method: 'GET',
+                                url: "/repos/".concat(target.owner, "/").concat(target.repo, "/contents/").concat(encodedPath),
+                                params: { ref: branch }
+                            }, true)];
+                    case 1:
+                        existing = _a.sent();
+                        sha = existing && existing.sha ? existing.sha : undefined;
+                        commitMessage = "chore(openai): update error context ".concat(contextPath);
+                        return [4 /*yield*/, this.githubRequest({
+                                method: 'PUT',
+                                url: "/repos/".concat(target.owner, "/").concat(target.repo, "/contents/").concat(encodedPath),
+                                data: {
+                                    message: commitMessage.slice(0, 200),
+                                    content: Buffer.from(content, 'utf8').toString('base64'),
+                                    branch: branch,
+                                    sha: sha
+                                }
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.findOpenPullRequest = function (target, branch, base) {
+        return __awaiter(this, void 0, void 0, function () {
+            var prs;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.githubRequest({
+                            method: 'GET',
+                            url: "/repos/".concat(target.owner, "/").concat(target.repo, "/pulls"),
+                            params: {
+                                state: 'open',
+                                head: "".concat(target.owner, ":").concat(branch),
+                                base: base,
+                                per_page: 1
+                            }
+                        })];
+                    case 1:
+                        prs = _a.sent();
+                        if (prs && prs.length) {
+                            return [2 /*return*/, prs[0]];
+                        }
+                        return [2 /*return*/, null];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.createPullRequest = function (target, branch, base, title, body) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pr;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.githubRequest({
+                            method: 'POST',
+                            url: "/repos/".concat(target.owner, "/").concat(target.repo, "/pulls"),
+                            data: {
+                                title: title,
+                                head: branch,
+                                base: base,
+                                body: body
+                            }
+                        })];
+                    case 1:
+                        pr = _a.sent();
+                        return [2 /*return*/, pr];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.commentOnPullRequest = function (target, prNumber, body) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.githubRequest({
+                            method: 'POST',
+                            url: "/repos/".concat(target.owner, "/").concat(target.repo, "/issues/").concat(prNumber, "/comments"),
+                            data: {
+                                body: body
+                            }
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.reserveLog = function (email, client) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hash, rawHash, now, existing, updatedExisting, metaUpdate, reactivated, attemptsUsed, maxAttempts, reason, exhausted, resumed, counterValue, counterString, doc;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        hash = email.hash;
+                        rawHash = email.rawHash || hash;
+                        now = email.reportedAt || new Date();
+                        existing = null;
+                        if (!hash) return [3 /*break*/, 2];
+                        return [4 /*yield*/, ErrorAutoFixLogs.findOne({ issue_hash: hash })];
+                    case 1:
+                        existing = _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        if (!(!existing && rawHash)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, ErrorAutoFixLogs.findOne({ email_hash: rawHash })];
+                    case 3:
+                        existing = _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        if (!(!existing && hash && hash !== rawHash)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, ErrorAutoFixLogs.findOne({ email_hash: hash })];
+                    case 5:
+                        existing = _a.sent();
+                        _a.label = 6;
+                    case 6:
+                        if (!existing) return [3 /*break*/, 18];
+                        return [4 /*yield*/, this.markDuplicate(existing._id, now)];
+                    case 7:
+                        _a.sent();
+                        return [4 /*yield*/, ErrorAutoFixLogs.findOne({ _id: existing._id })];
+                    case 8:
+                        updatedExisting = (_a.sent()) || existing;
+                        metaUpdate = {};
+                        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) return [3 /*break*/, 10];
+                        return [4 /*yield*/, this.updateLog(updatedExisting._id, metaUpdate)];
+                    case 9:
+                        _a.sent();
+                        _a.label = 10;
+                    case 10:
+                        if (!(updatedExisting.status === 'completed')) return [3 /*break*/, 12];
+                        return [4 /*yield*/, ErrorAutoFixLogs.findOneAndUpdate({ _id: updatedExisting._id }, {
+                                $set: {
+                                    status: 'pending',
+                                    ignored: false,
+                                    last_error: '',
+                                    openai_task_id: '',
+                                    branch_name: '',
+                                    pr_url: ''
+                                }
+                            }, {
+                                returnDocument: 'after'
+                            })];
+                    case 11:
+                        reactivated = (_a.sent()) || updatedExisting;
+                        return [2 /*return*/, {
+                                proceed: true,
+                                log: reactivated
+                            }];
+                    case 12:
+                        if (updatedExisting.ignored) {
+                            return [2 /*return*/, {
+                                    proceed: false,
+                                    log: updatedExisting,
+                                    reason: 'ignored'
+                                }];
+                        }
+                        if (!(this.config.autoRunEnabled && (updatedExisting.status === 'failed' || updatedExisting.status === 'skipped') && !updatedExisting.ignored)) return [3 /*break*/, 17];
+                        attemptsUsed = Number.isFinite(Number(updatedExisting.attempt_count))
+                            ? Number(updatedExisting.attempt_count)
+                            : 0;
+                        maxAttempts = Number.isFinite(Number(this.config.maxAutoRunAttemptsPerIssue))
+                            ? Number(this.config.maxAutoRunAttemptsPerIssue)
+                            : 0;
+                        if (!(maxAttempts > 0 && attemptsUsed >= maxAttempts)) return [3 /*break*/, 15];
+                        reason = "Auto-fix attempt budget reached (".concat(attemptsUsed, "/").concat(maxAttempts, ").");
+                        return [4 /*yield*/, ErrorAutoFixLogs.findOneAndUpdate({ _id: updatedExisting._id }, {
+                                $set: {
+                                    status: 'skipped',
+                                    ignored: true,
+                                    last_error: "".concat(reason, " Marked ignored pending manual intervention."),
+                                    last_result_at: now,
+                                    updatedAt: now
+                                }
+                            }, {
+                                returnDocument: 'after'
+                            })];
+                    case 13:
+                        exhausted = (_a.sent()) || updatedExisting;
+                        return [4 /*yield*/, this.sendEscalationNotice(exhausted, reason)];
+                    case 14:
+                        _a.sent();
+                        return [2 /*return*/, {
+                                proceed: false,
+                                log: exhausted,
+                                reason: 'budget_exhausted'
+                            }];
+                    case 15: return [4 /*yield*/, 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'
+                        })];
+                    case 16:
+                        resumed = _a.sent();
+                        return [2 /*return*/, {
+                                proceed: true,
+                                log: resumed || updatedExisting
+                            }];
+                    case 17:
+                        if (updatedExisting.status === 'in_progress') {
+                            return [2 /*return*/, {
+                                    proceed: false,
+                                    log: updatedExisting,
+                                    reason: 'in_progress'
+                                }];
+                        }
+                        if (updatedExisting.status === 'success') {
+                            return [2 /*return*/, {
+                                    proceed: false,
+                                    log: updatedExisting,
+                                    reason: 'success'
+                                }];
+                        }
+                        return [2 /*return*/, {
+                                proceed: false,
+                                log: updatedExisting,
+                                reason: 'duplicate'
+                            }];
+                    case 18: return [4 /*yield*/, resolveio_server_app_1.ResolveIOServer.getMainServer().getMethodManager().callMethod('incCounter', 'autofix_error')];
+                    case 19:
+                        counterValue = _a.sent();
+                        counterString = (0, common_1.pad)(counterValue, 6);
+                        doc = {
+                            _id: (0, common_1.objectIdHexString)(),
+                            email_hash: rawHash,
+                            issue_hash: hash,
+                            subject: email.subject,
+                            message_id: email.messageId,
+                            body: email.body,
+                            status: this.config.autoRunEnabled ? 'in_progress' : 'pending',
+                            ignored: false,
+                            attempt_count: this.config.autoRunEnabled ? 1 : 0,
+                            duplicate_count: 0,
+                            autofix_error_count: counterValue,
+                            autofix_error_count_string: counterString,
+                            first_seen_at: now,
+                            last_attempt_at: this.config.autoRunEnabled ? now : undefined,
+                            from_email: email.fromAddress || '',
+                            id_client: client === null || client === void 0 ? void 0 : client._id,
+                            client_name: client === null || client === void 0 ? void 0 : 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
+                        };
+                        return [4 /*yield*/, ErrorAutoFixLogs.insertOne(doc)];
+                    case 20:
+                        _a.sent();
+                        return [2 /*return*/, {
+                                proceed: true,
+                                log: doc
+                            }];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.markDuplicate = function (logId, timestamp) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ErrorAutoFixLogs.updateOne({ _id: logId }, {
+                            $inc: {
+                                duplicate_count: 1
+                            },
+                            $set: {
+                                last_duplicate_at: timestamp,
+                                last_reported_at: timestamp,
+                                updatedAt: timestamp
+                            }
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.updateLog = function (logId, set, inc) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cleanedSet, rawSet, update, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        cleanedSet = {};
+                        rawSet = set ? __assign({}, set) : {};
+                        Object.keys(rawSet).forEach(function (key) {
+                            if (typeof rawSet[key] !== 'undefined') {
+                                cleanedSet[key] = rawSet[key];
+                            }
+                        });
+                        cleanedSet.updatedAt = new Date();
+                        update = {
+                            $set: cleanedSet
+                        };
+                        if (inc) {
+                            update.$inc = inc;
+                        }
+                        return [4 /*yield*/, ErrorAutoFixLogs.findOneAndUpdate({ _id: logId }, update, {
+                                returnDocument: 'after'
+                            })];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.getEscalationRecipients = function () {
+        var unique = new Set();
+        var add = function (value) {
+            var 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);
+    };
+    ErrorAutoFixManager.prototype.sendEscalationNotice = function (log, reason) {
+        return __awaiter(this, void 0, void 0, function () {
+            var recipients, identifier, subject, body, methodManager, recipients_1, recipients_1_1, recipient, error_1, e_1_1;
+            var e_1, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        recipients = this.getEscalationRecipients();
+                        if (!recipients.length || !(log === null || log === void 0 ? void 0 : log._id)) {
+                            return [2 /*return*/];
+                        }
+                        identifier = log.autofix_error_count_string || log._id;
+                        subject = "ResolveIO AutoFix Escalation: ".concat(identifier);
+                        body = [
+                            'Auto-fix retry budget was exhausted for this recurring issue and further autonomous attempts were stopped.',
+                            '',
+                            "Reason: ".concat(reason),
+                            "Issue Log ID: ".concat(log._id),
+                            "Issue Counter: ".concat(log.autofix_error_count_string || 'n/a'),
+                            "Client: ".concat(log.client_name || log.id_client || 'unknown'),
+                            "Source App: ".concat(log.source_app || 'unknown'),
+                            "Environment: ".concat(log.source_environment || log.openai_environment || 'unknown'),
+                            "Attempts: ".concat(log.attempt_count || 0, "/").concat(this.config.maxAutoRunAttemptsPerIssue),
+                            "Issue Hash: ".concat(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');
+                        methodManager = resolveio_server_app_1.ResolveIOServer.getMainServer().getMethodManager();
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 8, 9, 10]);
+                        recipients_1 = __values(recipients), recipients_1_1 = recipients_1.next();
+                        _b.label = 2;
+                    case 2:
+                        if (!!recipients_1_1.done) return [3 /*break*/, 7];
+                        recipient = recipients_1_1.value;
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, methodManager.sendEmail(recipient, subject, body)];
+                    case 4:
+                        _b.sent();
+                        return [3 /*break*/, 6];
+                    case 5:
+                        error_1 = _b.sent();
+                        console.error('Failed sending auto-fix escalation email', { recipient: recipient, logId: log._id, error: error_1 });
+                        return [3 /*break*/, 6];
+                    case 6:
+                        recipients_1_1 = recipients_1.next();
+                        return [3 /*break*/, 2];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_1_1 = _b.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (recipients_1_1 && !recipients_1_1.done && (_a = recipients_1.return)) _a.call(recipients_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.collectLibraryIssueSignalText = function (email, log) {
+        var attachments = Array.isArray(log === null || log === void 0 ? void 0 : log.attachments) ? log.attachments : [];
+        var attachmentSignals = attachments.map(function (attachment) {
+            return [
+                (attachment === null || attachment === void 0 ? void 0 : attachment.name) || '',
+                (attachment === null || attachment === void 0 ? void 0 : attachment.url) || '',
+                (attachment === null || attachment === void 0 ? void 0 : attachment.contentType) || ''
+            ].filter(Boolean).join(' ');
+        });
+        var metadata = (log === null || log === void 0 ? void 0 : log.report_metadata) && Object.keys(log.report_metadata).length
+            ? JSON.stringify(log.report_metadata)
+            : '';
+        var context = (log === null || log === void 0 ? void 0 : log.report_context) && Object.keys(log.report_context).length
+            ? JSON.stringify(log.report_context)
+            : '';
+        return [
+            (email === null || email === void 0 ? void 0 : email.subject) || '',
+            (email === null || email === void 0 ? void 0 : email.body) || '',
+            (log === null || log === void 0 ? void 0 : log.body) || '',
+            metadata,
+            context,
+            attachmentSignals.join('\n')
+        ].filter(Boolean).join('\n');
+    };
+    ErrorAutoFixManager.prototype.evaluateLibraryIssueGate = function (email, log) {
+        var e_2, _a;
+        var signalText = this.collectLibraryIssueSignalText(email, log);
+        if (!signalText) {
+            return { blocked: false, evidence: [] };
+        }
+        var evidence = [];
+        var markerHits = 0;
+        try {
+            for (var LIBRARY_MARKER_PATTERNS_1 = __values(LIBRARY_MARKER_PATTERNS), LIBRARY_MARKER_PATTERNS_1_1 = LIBRARY_MARKER_PATTERNS_1.next(); !LIBRARY_MARKER_PATTERNS_1_1.done; LIBRARY_MARKER_PATTERNS_1_1 = LIBRARY_MARKER_PATTERNS_1.next()) {
+                var marker = LIBRARY_MARKER_PATTERNS_1_1.value;
+                if (!marker.pattern.test(signalText)) {
+                    continue;
+                }
+                markerHits += 1;
+                evidence.push(marker.label);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (LIBRARY_MARKER_PATTERNS_1_1 && !LIBRARY_MARKER_PATTERNS_1_1.done && (_a = LIBRARY_MARKER_PATTERNS_1.return)) _a.call(LIBRARY_MARKER_PATTERNS_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        var rawPaths = signalText.match(FILE_PATH_PATTERN) || [];
+        var normalizedPaths = rawPaths
+            .map(function (value) { return String(value || '').trim(); })
+            .filter(Boolean)
+            .map(function (value) { return value.replace(/\\/g, '/').toLowerCase(); });
+        var appOwnedPathCount = normalizedPaths.filter(function (value) { return APP_OWNED_PATH_PATTERN.test(value); }).length;
+        var libraryPathCount = normalizedPaths.filter(function (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;
+        var shouldBlock = (libraryPathCount > 0 && appOwnedPathCount === 0)
+            || (markerHits >= 2 && appOwnedPathCount === 0)
+            || (markerHits >= 1 && libraryPathCount >= 2);
+        if (!shouldBlock) {
+            return { blocked: false, evidence: evidence };
+        }
+        var compactEvidence = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray([], __read(evidence), false), __read((libraryPathCount ? ["library_paths=".concat(libraryPathCount)] : [])), false), __read((appOwnedPathCount ? ["app_paths=".concat(appOwnedPathCount)] : [])), false))).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
+        };
+    };
+    ErrorAutoFixManager.prototype.sendLibraryIssueNotice = function (log, reason, evidence) {
+        return __awaiter(this, void 0, void 0, function () {
+            var recipients, identifier, subject, body, methodManager, recipients_2, recipients_2_1, recipient, error_2, e_3_1;
+            var e_3, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        recipients = this.getEscalationRecipients();
+                        if (!recipients.length || !(log === null || log === void 0 ? void 0 : log._id)) {
+                            return [2 /*return*/];
+                        }
+                        identifier = log.autofix_error_count_string || log._id;
+                        subject = "ResolveIO AutoFix Blocked (Library): ".concat(identifier);
+                        body = [
+                            'Auto-fix was blocked because the issue appears library-owned, so no autonomous patch was attempted.',
+                            '',
+                            "Reason: ".concat(reason),
+                            evidence.length ? "Evidence: ".concat(evidence.join(', ')) : '',
+                            "Issue Log ID: ".concat(log._id),
+                            "Issue Counter: ".concat(log.autofix_error_count_string || 'n/a'),
+                            "Client: ".concat(log.client_name || log.id_client || 'unknown'),
+                            "Source App: ".concat(log.source_app || 'unknown'),
+                            "Environment: ".concat(log.source_environment || log.openai_environment || 'unknown'),
+                            "Issue Hash: ".concat(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');
+                        methodManager = resolveio_server_app_1.ResolveIOServer.getMainServer().getMethodManager();
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 8, 9, 10]);
+                        recipients_2 = __values(recipients), recipients_2_1 = recipients_2.next();
+                        _b.label = 2;
+                    case 2:
+                        if (!!recipients_2_1.done) return [3 /*break*/, 7];
+                        recipient = recipients_2_1.value;
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, methodManager.sendEmail(recipient, subject, body)];
+                    case 4:
+                        _b.sent();
+                        return [3 /*break*/, 6];
+                    case 5:
+                        error_2 = _b.sent();
+                        console.error('Failed sending library-issue auto-fix email', { recipient: recipient, logId: log._id, error: error_2 });
+                        return [3 /*break*/, 6];
+                    case 6:
+                        recipients_2_1 = recipients_2.next();
+                        return [3 /*break*/, 2];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_3_1 = _b.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (recipients_2_1 && !recipients_2_1.done && (_a = recipients_2.return)) _a.call(recipients_2);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                        return [7 /*endfinally*/];
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.blockLibraryOwnedIssue = function (email, log, gate) {
+        return __awaiter(this, void 0, void 0, function () {
+            var reason, details, message, updated;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        reason = gate.reason || 'Library-owned issue detected.';
+                        details = gate.evidence.length ? "Signals: ".concat(gate.evidence.join(', ')) : '';
+                        message = [reason, details].filter(Boolean).join(' ');
+                        return [4 /*yield*/, this.updateLog(log._id, {
+                                status: 'skipped',
+                                ignored: true,
+                                last_error: message,
+                                last_result_at: new Date()
+                            })];
+                    case 1:
+                        updated = (_a.sent()) || log;
+                        return [4 /*yield*/, this.notifyCustomerWorkflowStatus('blocked_library_issue', email, updated, {
+                                error: reason,
+                                notes: details
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.sendLibraryIssueNotice(updated, reason, gate.evidence)];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/, {
+                                status: 'skipped',
+                                email: email,
+                                error: message,
+                                log: updated,
+                                reason: 'library_issue_blocked',
+                                summary: updated.plan_summary || email.subject,
+                                notes: details
+                            }];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.shouldNotifySkip = function (reason) {
+        return ['in_progress', 'success', 'ignored', 'duplicate', 'pending'].indexOf(reason) === -1;
+    };
+    ErrorAutoFixManager.prototype.isGeneratedAICoderClient = function (idClient) {
+        return __awaiter(this, void 0, void 0, function () {
+            var normalizedClientId, match;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        normalizedClientId = String(idClient || '').trim();
+                        if (!normalizedClientId) {
+                            return [2 /*return*/, false];
+                        }
+                        return [4 /*yield*/, AICoderApps.findOne({
+                                client_id: normalizedClientId
+                            }, {
+                                projection: {
+                                    _id: 1
+                                }
+                            })];
+                    case 1:
+                        match = _a.sent();
+                        return [2 /*return*/, !!(match === null || match === void 0 ? void 0 : match._id)];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.buildAICoderWorkflowSummary = function (stage, email, log, extra) {
+        return (0, customer_notification_content_manager_1.buildGeneratedAppAutoFixSummary)(stage, {
+            source_app: String((log === null || log === void 0 ? void 0 : log.source_app) || (email === null || email === void 0 ? void 0 : email.sourceApp) || '').trim(),
+            environment: String((log === null || log === void 0 ? void 0 : log.source_environment) || (email === null || email === void 0 ? void 0 : email.sourceEnvironment) || '').trim(),
+            severity: String((log === null || log === void 0 ? void 0 : log.severity) || (email === null || email === void 0 ? void 0 : email.severity) || '').trim(),
+            error: extra === null || extra === void 0 ? void 0 : extra.error
+        }, extra);
+    };
+    ErrorAutoFixManager.prototype.buildResolveIOProjectWorkflowDetails = function (email, log, extra) {
+        return (0, customer_notification_content_manager_1.buildResolveIOProjectAutoFixDetails)({
+            client_name: (log === null || log === void 0 ? void 0 : log.client_name) || (email === null || email === void 0 ? void 0 : email.client_name) || '',
+            issue_counter: (log === null || log === void 0 ? void 0 : log.autofix_error_count_string) || '',
+            source_app: (log === null || log === void 0 ? void 0 : log.source_app) || (email === null || email === void 0 ? void 0 : email.sourceApp) || '',
+            environment: (log === null || log === void 0 ? void 0 : log.source_environment) || (email === null || email === void 0 ? void 0 : email.sourceEnvironment) || (log === null || log === void 0 ? void 0 : log.openai_environment) || '',
+            severity: (log === null || log === void 0 ? void 0 : log.severity) || (email === null || email === void 0 ? void 0 : email.severity) || '',
+            issue_hash: (log === null || log === void 0 ? void 0 : log.issue_hash) || (email === null || email === void 0 ? void 0 : email.issueHash) || (log === null || log === void 0 ? void 0 : log.email_hash) || '',
+            log_id: (log === null || log === void 0 ? void 0 : log._id) || '',
+            notes: extra === null || extra === void 0 ? void 0 : extra.notes,
+            error: extra === null || extra === void 0 ? void 0 : extra.error
+        });
+    };
+    ErrorAutoFixManager.prototype.buildLocalInternalUserCriteria = function () {
+        return {
+            $and: [
+                {
+                    is_customer: {
+                        $ne: true
+                    }
+                },
+                {
+                    $nor: [
+                        {
+                            'other.id_customer': {
+                                $exists: true,
+                                $nin: ['', null]
+                            }
+                        },
+                        {
+                            id_customer: {
+                                $exists: true,
+                                $nin: ['', null]
+                            }
+                        }
+                    ]
+                }
+            ]
+        };
+    };
+    ErrorAutoFixManager.prototype.buildLocalAdminUserCriteria = function () {
+        return {
+            $or: [
+                {
+                    'roles.super_admin': true
+                },
+                {
+                    'roles.groups.name': {
+                        $regex: 'admin',
+                        $options: 'i'
+                    }
+                },
+                {
+                    'roles.groups.views': {
+                        $regex: '^/manage'
+                    }
+                },
+                {
+                    'roles.groups.views': '/manage'
+                }
+            ]
+        };
+    };
+    ErrorAutoFixManager.prototype.resolveLocalNotificationUserIds = function (isGeneratedApp) {
+        return __awaiter(this, void 0, void 0, function () {
+            var andClauses, users, unique, users_1, users_1_1, user, idUser;
+            var e_4, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        andClauses = [
+                            {
+                                active: true
+                            },
+                            {
+                                username: {
+                                    $exists: true
+                                }
+                            }
+                        ];
+                        if (isGeneratedApp) {
+                            andClauses.push(this.buildLocalInternalUserCriteria());
+                        }
+                        else {
+                            andClauses.push(this.buildLocalAdminUserCriteria());
+                        }
+                        return [4 /*yield*/, user_collection_1.Users.find({
+                                $and: andClauses
+                            }, {
+                                projection: {
+                                    _id: 1
+                                },
+                                limit: MAX_LOCAL_NOTIFICATION_USERS
+                            })];
+                    case 1:
+                        users = _b.sent();
+                        if (!Array.isArray(users) || !users.length) {
+                            return [2 /*return*/, []];
+                        }
+                        unique = new Set();
+                        try {
+                            for (users_1 = __values(users), users_1_1 = users_1.next(); !users_1_1.done; users_1_1 = users_1.next()) {
+                                user = users_1_1.value;
+                                idUser = String((user === null || user === void 0 ? void 0 : user._id) || '').trim();
+                                if (idUser) {
+                                    unique.add(idUser);
+                                }
+                                if (unique.size >= MAX_LOCAL_NOTIFICATION_USERS) {
+                                    break;
+                                }
+                            }
+                        }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        finally {
+                            try {
+                                if (users_1_1 && !users_1_1.done && (_a = users_1.return)) _a.call(users_1);
+                            }
+                            finally { if (e_4) throw e_4.error; }
+                        }
+                        return [2 /*return*/, Array.from(unique)];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.notifyCustomerWorkflowStatus = function (stage, email, log, extra) {
+        return __awaiter(this, void 0, void 0, function () {
+            var idClient, isGeneratedApp, resolvedEnvironment, app, issueKey, clientName, targetPayload, idUsers, basePayload, payload, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        idClient = String((log === null || log === void 0 ? void 0 : log.id_client) || (email === null || email === void 0 ? void 0 : email.id_client) || '').trim();
+                        isGeneratedApp = false;
+                        if (!idClient) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.isGeneratedAICoderClient(idClient)];
+                    case 1:
+                        isGeneratedApp = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2:
+                        resolvedEnvironment = this.resolveEnvironmentForTask(email, log);
+                        return [4 /*yield*/, this.resolveAutoFixApp(email, log, resolvedEnvironment)];
+                    case 3:
+                        app = _a.sent();
+                        isGeneratedApp = !!app;
+                        _a.label = 4;
+                    case 4:
+                        if (!isGeneratedApp && stage !== 'completed_success') {
+                            return [2 /*return*/];
+                        }
+                        issueKey = String((log === null || log === void 0 ? void 0 : log.issue_hash) || (log === null || log === void 0 ? void 0 : log.email_hash) || (email === null || email === void 0 ? void 0 : email.issueHash) || (email === null || email === void 0 ? void 0 : email.hash) || (log === null || log === void 0 ? void 0 : log._id) || '').trim();
+                        clientName = String((log === null || log === void 0 ? void 0 : log.client_name) || (email === null || email === void 0 ? void 0 : email.client_name) || '').trim();
+                        targetPayload = {};
+                        if (!idClient) return [3 /*break*/, 5];
+                        targetPayload.target_type = isGeneratedApp ? 'client_internal' : 'client_admins';
+                        targetPayload.id_client = idClient;
+                        targetPayload.client_name = clientName || undefined;
+                        return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, this.resolveLocalNotificationUserIds(isGeneratedApp)];
+                    case 6:
+                        idUsers = _a.sent();
+                        if (!idUsers.length) {
+                            return [2 /*return*/];
+                        }
+                        targetPayload.target_type = 'users';
+                        targetPayload.id_users = idUsers;
+                        targetPayload.client_name = clientName || undefined;
+                        _a.label = 7;
+                    case 7:
+                        basePayload = __assign(__assign({}, targetPayload), { category: 'autofix', source: 'error-auto-fix', source_id: String((log === null || log === void 0 ? void 0 : log._id) || '').trim() || undefined, dedupe_key: issueKey ? "autofix:".concat(issueKey, ":").concat(stage) : "autofix:".concat(String((log === null || log === void 0 ? void 0 : log._id) || '').trim(), ":").concat(stage), metadata: {
+                                issue_hash: (log === null || log === void 0 ? void 0 : log.issue_hash) || (email === null || email === void 0 ? void 0 : email.issueHash) || '',
+                                log_id: (log === null || log === void 0 ? void 0 : log._id) || '',
+                                severity: (log === null || log === void 0 ? void 0 : log.severity) || (email === null || email === void 0 ? void 0 : email.severity) || '',
+                                source_app: (log === null || log === void 0 ? void 0 : log.source_app) || (email === null || email === void 0 ? void 0 : email.sourceApp) || '',
+                                source_environment: (log === null || log === void 0 ? void 0 : log.source_environment) || (email === null || email === void 0 ? void 0 : email.sourceEnvironment) || '',
+                                error: (extra === null || extra === void 0 ? void 0 : extra.error) || '',
+                                notes: (extra === null || extra === void 0 ? void 0 : extra.notes) || ''
+                            } });
+                        payload = {};
+                        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 ".concat(String((log === null || log === void 0 ? void 0 : log.source_app) || (email === null || email === void 0 ? void 0 : email.sourceApp) || 'the project').trim(), " completed successfully."),
+                                severity: 'success',
+                                details: this.buildResolveIOProjectWorkflowDetails(email, log, extra)
+                            };
+                        }
+                        _a.label = 8;
+                    case 8:
+                        _a.trys.push([8, 10, , 11]);
+                        return [4 /*yield*/, resolveio_server_app_1.ResolveIOServer.getMainServer().getMethodManager().callMethod('createCustomerNotification', __assign(__assign({}, basePayload), payload))];
+                    case 9:
+                        _a.sent();
+                        return [3 /*break*/, 11];
+                    case 10:
+                        error_3 = _a.sent();
+                        this.debugLog('Failed to create customer auto-fix notification', {
+                            logId: log === null || log === void 0 ? void 0 : log._id,
+                            stage: stage,
+                            error: (error_3 === null || error_3 === void 0 ? void 0 : error_3.message) || error_3
+                        });
+                        return [3 /*break*/, 11];
+                    case 11: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.delay = function (ms) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    // eslint-disable-next-line no-restricted-syntax
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, ms); })];
+                    case 1:
+                        // eslint-disable-next-line no-restricted-syntax
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.reportDevError = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var subject, body, sourceApp, environment, severity, fingerprint, metadata, err_5;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        subject = ((options === null || options === void 0 ? void 0 : options.subject) || '').trim() || 'ResolveIO alert';
+                        body = (options === null || options === void 0 ? void 0 : options.body) || '';
+                        sourceApp = (options === null || options === void 0 ? void 0 : options.sourceApp) || resolveio_server_app_1.ResolveIOServer.getClientName() || 'resolveio-server';
+                        environment = (options === null || options === void 0 ? void 0 : options.environment) || process.env.NODE_ENV || '';
+                        severity = (options === null || options === void 0 ? void 0 : options.severity) || 'infrastructure';
+                        fingerprint = ((options === null || options === void 0 ? void 0 : options.fingerprint) || (0, crypto_1.createHash)('sha256').update("".concat(sourceApp, ":").concat(environment || 'env', ":").concat(subject)).digest('hex')).trim();
+                        metadata = (options === null || options === void 0 ? void 0 : options.metadata) && Object.keys(options.metadata).length ? options.metadata : undefined;
+                        if (!this.isReady()) {
+                            console.warn('AutoFix manager not ready for dev alert', { subject: subject, environment: environment });
+                            return [2 /*return*/];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.ingestErrorReport({
+                                sourceApp: sourceApp,
+                                environment: environment,
+                                message: subject,
+                                stack: body,
+                                severity: severity,
+                                metadata: metadata,
+                                fingerprint: fingerprint,
+                                idempotencyKey: options === null || options === void 0 ? void 0 : options.idempotencyKey,
+                                clientId: options === null || options === void 0 ? void 0 : options.clientId,
+                                clientName: options === null || options === void 0 ? void 0 : options.clientName,
+                                clientSlug: options === null || options === void 0 ? void 0 : options.clientSlug,
+                                reportedBy: 'resolveio-server'
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_5 = _a.sent();
+                        console.error('Failed to log developer alert', subject, err_5);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.ingestErrorReport = function (report) {
+        return __awaiter(this, void 0, void 0, function () {
+            var normalizedReport, email, rawHash, fingerprint, client, reservation, classification, updated, queued, result, finalLog, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!this.isReady()) {
+                            throw new Error('ErrorAutoFixManager is not enabled.');
+                        }
+                        if (!report || !report.sourceApp || !report.message) {
+                            throw new Error('Invalid error report payload.');
+                        }
+                        normalizedReport = __assign(__assign({}, 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() });
+                        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 = "".concat(normalizedReport.clientSlug, "@errors.resolveio.com");
+                        }
+                        rawHash = normalizedReport.idempotencyKey ? normalizedReport.idempotencyKey.trim() : '';
+                        email.rawHash = rawHash || this.generateRawEmailHash(email);
+                        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;
+                        }
+                        return [4 /*yield*/, this.resolveClientForReport(normalizedReport)];
+                    case 1:
+                        client = _b.sent();
+                        return [4 /*yield*/, this.reserveLog(email, client)];
+                    case 2:
+                        reservation = _b.sent();
+                        if (!!reservation.proceed) return [3 /*break*/, 5];
+                        if (!(reservation.reason && this.shouldNotifySkip(reservation.reason))) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.notify({
+                                status: 'skipped',
+                                email: email,
+                                reason: reservation.reason,
+                                error: "Skipped auto-fix (".concat(reservation.reason, ")."),
+                                log: reservation.log
+                            })];
+                    case 3:
+                        _b.sent();
+                        _b.label = 4;
+                    case 4: return [2 /*return*/, {
+                            status: reservation.reason === 'duplicate' ? 'duplicate' : reservation.reason || 'skipped',
+                            reason: reservation.reason,
+                            log: reservation.log
+                        }];
+                    case 5:
+                        email.logId = reservation.log._id;
+                        classification = this.classifyEmail(email);
+                        return [4 /*yield*/, this.updateLog(email.logId, {
+                                id_client: client === null || client === void 0 ? void 0 : client._id,
+                                client_name: client === null || client === void 0 ? void 0 : 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()
+                            })];
+                    case 6:
+                        _b.sent();
+                        if (!classification.skip) return [3 /*break*/, 10];
+                        return [4 /*yield*/, this.updateLog(email.logId, {
+                                status: 'skipped',
+                                last_error: classification.reason || 'Ignored non-app alert',
+                                last_result_at: new Date()
+                            })];
+                    case 7:
+                        updated = _b.sent();
+                        if (!classification.notify) return [3 /*break*/, 9];
+                        return [4 /*yield*/, this.notify({
+                                status: 'skipped',
+                                email: email,
+                                error: classification.reason,
+                                log: updated,
+                                reason: 'classified'
+                            })];
+                    case 8:
+                        _b.sent();
+                        _b.label = 9;
+                    case 9: return [2 /*return*/, {
+                            status: 'skipped',
+                            reason: classification.reason,
+                            log: updated
+                        }];
+                    case 10:
+                        if (!!this.config.autoRunEnabled) return [3 /*break*/, 13];
+                        return [4 /*yield*/, this.updateLog(email.logId, {
+                                status: 'pending'
+                            })];
+                    case 11:
+                        queued = _b.sent();
+                        return [4 /*yield*/, this.notifyCustomerWorkflowStatus('detected_autofix_disabled', email, queued || reservation.log)];
+                    case 12:
+                        _b.sent();
+                        return [2 /*return*/, {
+                                status: 'queued',
+                                log: queued
+                            }];
+                    case 13: return [4 /*yield*/, this.notifyCustomerWorkflowStatus('detected_autofix_enabled', email, reservation.log)];
+                    case 14:
+                        _b.sent();
+                        return [4 /*yield*/, this.processEmail(email, reservation.log)];
+                    case 15:
+                        result = _b.sent();
+                        return [4 /*yield*/, this.notify(result)];
+                    case 16:
+                        _b.sent();
+                        _a = result.log;
+                        if (_a) return [3 /*break*/, 18];
+                        return [4 /*yield*/, ErrorAutoFixLogs.findOne({ _id: email.logId })];
+                    case 17:
+                        _a = (_b.sent());
+                        _b.label = 18;
+                    case 18:
+                        finalLog = _a;
+                        return [2 /*return*/, {
+                                status: result.status,
+                                reason: result.reason,
+                                log: finalLog || result.log
+                            }];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.runLog = function (logId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var log, now, email, inProgressLog, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.config.enabled) {
+                            throw new Error('Auto-fix manager disabled.');
+                        }
+                        return [4 /*yield*/, ErrorAutoFixLogs.findOne({ _id: logId })];
+                    case 1:
+                        log = _a.sent();
+                        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.');
+                        }
+                        now = new Date();
+                        email = this.buildEmailFromLog(log);
+                        return [4 /*yield*/, ErrorAutoFixLogs.findOneAndUpdate({ _id: logId }, {
+                                $inc: {
+                                    attempt_count: 1
+                                },
+                                $set: {
+                                    status: 'in_progress',
+                                    last_attempt_at: now,
+                                    last_error: '',
+                                    ignored: false
+                                }
+                            }, {
+                                returnDocument: 'after'
+                            })];
+                    case 2:
+                        inProgressLog = (_a.sent()) || log;
+                        return [4 /*yield*/, this.processEmail(email, inProgressLog)];
+                    case 3:
+                        result = _a.sent();
+                        return [4 /*yield*/, this.notify(result)];
+                    case 4:
+                        _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.buildEmailFromLog = function (log) {
+        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
+        };
+    };
+    ErrorAutoFixManager.prototype.processEmail = function (email, log) {
+        return __awaiter(this, void 0, void 0, function () {
+            var libraryIssueGate, dashboardResult;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        libraryIssueGate = this.evaluateLibraryIssueGate(email, log);
+                        if (!libraryIssueGate.blocked) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.blockLibraryOwnedIssue(email, log, libraryIssueGate)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        if (!this.config.dashboardWorkflowEnabled) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.dispatchDashboardWorkflow(email, log)];
+                    case 3:
+                        dashboardResult = _a.sent();
+                        if (dashboardResult.status === 'in_progress' || dashboardResult.status === 'success') {
+                            return [2 /*return*/, dashboardResult];
+                        }
+                        if (!this.config.dashboardFallbackToGithub) {
+                            return [2 /*return*/, dashboardResult];
+                        }
+                        this.debugLog('Dashboard workflow unavailable; falling back to GitHub workflow.', {
+                            logId: log === null || log === void 0 ? void 0 : log._id,
+                            reason: dashboardResult.reason,
+                            error: dashboardResult.error
+                        });
+                        _a.label = 4;
+                    case 4: return [4 /*yield*/, this.dispatchGithubWorkflow(email, log)];
+                    case 5: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.shouldFallbackDashboardMethod = function (error) {
+        var message = "".concat((error === null || error === void 0 ? void 0 : error.message) || '').toLowerCase();
+        return message.includes('not found')
+            || message.includes('worker dispatch unavailable')
+            || message.includes('no worker')
+            || message.includes('unavailable for aidashboard');
+    };
+    ErrorAutoFixManager.prototype.createDashboardJob = function (payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var methodManager, error_4, manager;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        methodManager = resolveio_server_app_1.ResolveIOServer.getMainServer().getMethodManager();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, methodManager.callMethod('aiDashboardCreateJob', payload)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                    case 3:
+                        error_4 = _a.sent();
+                        if (!this.shouldFallbackDashboardMethod(error_4)) {
+                            throw error_4;
+                        }
+                        return [3 /*break*/, 4];
+                    case 4:
+                        manager = resolveio_server_app_1.ResolveIOServer['AIDashboardManager'];
+                        if (!(manager && manager.isEnabled && manager.isEnabled())) return [3 /*break*/, 6];
+                        return [4 /*yield*/, manager.createJob(payload)];
+                    case 5: return [2 /*return*/, _a.sent()];
+                    case 6: throw new Error('AI Dashboard manager is not available.');
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.waitForDashboardJobStop = function (jobId, timeoutMs) {
+        return __awaiter(this, void 0, void 0, function () {
+            var methodManager, error_5, manager;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        methodManager = resolveio_server_app_1.ResolveIOServer.getMainServer().getMethodManager();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, methodManager.callMethod('aiDashboardWaitForJobStop', jobId, timeoutMs)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 3:
+                        error_5 = _a.sent();
+                        if (!this.shouldFallbackDashboardMethod(error_5)) {
+                            throw error_5;
+                        }
+                        return [3 /*break*/, 4];
+                    case 4:
+                        manager = resolveio_server_app_1.ResolveIOServer['AIDashboardManager'];
+                        if (!(manager && manager.isEnabled && manager.isEnabled())) return [3 /*break*/, 6];
+                        return [4 /*yield*/, manager.waitForJobStop(jobId, timeoutMs)];
+                    case 5:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 6: throw new Error('AI Dashboard manager is not available.');
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.isDashboardJobRunning = function (jobId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var methodManager, running, error_6, manager;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        methodManager = resolveio_server_app_1.ResolveIOServer.getMainServer().getMethodManager();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, methodManager.callMethod('aiDashboardIsJobRunning', jobId)];
+                    case 2:
+                        running = _a.sent();
+                        return [2 /*return*/, !!running];
+                    case 3:
+                        error_6 = _a.sent();
+                        if (!this.shouldFallbackDashboardMethod(error_6)) {
+                            throw error_6;
+                        }
+                        return [3 /*break*/, 4];
+                    case 4:
+                        manager = resolveio_server_app_1.ResolveIOServer['AIDashboardManager'];
+                        if (manager && manager.isEnabled && manager.isEnabled()) {
+                            return [2 /*return*/, !!manager.isJobRunning(jobId)];
+                        }
+                        throw new Error('AI Dashboard manager is not available.');
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.resolveAutoFixApp = function (email, log, resolvedEnvironment) {
+        return __awaiter(this, void 0, void 0, function () {
+            var clientId, byClientId, lookupClientCandidates, lookupClientCandidates_1, lookupClientCandidates_1_1, candidate, escaped, clientDoc, byClient, e_5_1, environmentRepo, escapedRepo, byRepo, appNameCandidates, appNameCandidates_1, appNameCandidates_1_1, candidate, escaped, bySlugOrName, e_6_1;
+            var e_5, _a, e_6, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        clientId = (email.id_client || log.id_client || '').trim();
+                        if (!clientId) return [3 /*break*/, 2];
+                        return [4 /*yield*/, AICoderApps.findOne({ client_id: clientId }, {
+                                sort: {
+                                    updatedAt: -1,
+                                    createdAt: -1
+                                }
+                            })];
+                    case 1:
+                        byClientId = _c.sent();
+                        if (byClientId) {
+                            return [2 /*return*/, byClientId];
+                        }
+                        _c.label = 2;
+                    case 2:
+                        lookupClientCandidates = [
+                            (email.client_name || '').trim(),
+                            (log.client_name || '').trim()
+                        ].filter(Boolean);
+                        _c.label = 3;
+                    case 3:
+                        _c.trys.push([3, 9, 10, 11]);
+                        lookupClientCandidates_1 = __values(lookupClientCandidates), lookupClientCandidates_1_1 = lookupClientCandidates_1.next();
+                        _c.label = 4;
+                    case 4:
+                        if (!!lookupClientCandidates_1_1.done) return [3 /*break*/, 8];
+                        candidate = lookupClientCandidates_1_1.value;
+                        escaped = this.escapeRegex(candidate);
+                        return [4 /*yield*/, Clients.findOne({
+                                $or: [
+                                    { name: { $regex: "^".concat(escaped, "$"), $options: 'i' } },
+                                    { demo_name: { $regex: "^".concat(escaped, "$"), $options: 'i' } },
+                                    { repo: { $regex: "^".concat(escaped, "$"), $options: 'i' } }
+                                ]
+                            })];
+                    case 5:
+                        clientDoc = _c.sent();
+                        if (!(clientDoc === null || clientDoc === void 0 ? void 0 : clientDoc._id)) {
+                            return [3 /*break*/, 7];
+                        }
+                        return [4 /*yield*/, AICoderApps.findOne({ client_id: clientDoc._id }, {
+                                sort: {
+                                    updatedAt: -1,
+                                    createdAt: -1
+                                }
+                            })];
+                    case 6:
+                        byClient = _c.sent();
+                        if (byClient) {
+                            return [2 /*return*/, byClient];
+                        }
+                        _c.label = 7;
+                    case 7:
+                        lookupClientCandidates_1_1 = lookupClientCandidates_1.next();
+                        return [3 /*break*/, 4];
+                    case 8: return [3 /*break*/, 11];
+                    case 9:
+                        e_5_1 = _c.sent();
+                        e_5 = { error: e_5_1 };
+                        return [3 /*break*/, 11];
+                    case 10:
+                        try {
+                            if (lookupClientCandidates_1_1 && !lookupClientCandidates_1_1.done && (_a = lookupClientCandidates_1.return)) _a.call(lookupClientCandidates_1);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                        return [7 /*endfinally*/];
+                    case 11:
+                        environmentRepo = (resolvedEnvironment || '').trim();
+                        if (!environmentRepo) return [3 /*break*/, 13];
+                        escapedRepo = this.escapeRegex(environmentRepo);
+                        return [4 /*yield*/, AICoderApps.findOne({
+                                repo: {
+                                    $regex: "^".concat(escapedRepo, "$"),
+                                    $options: 'i'
+                                }
+                            }, {
+                                sort: {
+                                    updatedAt: -1,
+                                    createdAt: -1
+                                }
+                            })];
+                    case 12:
+                        byRepo = _c.sent();
+                        if (byRepo) {
+                            return [2 /*return*/, byRepo];
+                        }
+                        _c.label = 13;
+                    case 13:
+                        appNameCandidates = [
+                            (email.sourceApp || '').trim(),
+                            (log.source_app || '').trim()
+                        ].filter(Boolean);
+                        _c.label = 14;
+                    case 14:
+                        _c.trys.push([14, 19, 20, 21]);
+                        appNameCandidates_1 = __values(appNameCandidates), appNameCandidates_1_1 = appNameCandidates_1.next();
+                        _c.label = 15;
+                    case 15:
+                        if (!!appNameCandidates_1_1.done) return [3 /*break*/, 18];
+                        candidate = appNameCandidates_1_1.value;
+                        escaped = this.escapeRegex(candidate);
+                        return [4 /*yield*/, AICoderApps.findOne({
+                                $or: [
+                                    { slug: { $regex: "^".concat(escaped, "$"), $options: 'i' } },
+                                    { name: { $regex: "^".concat(escaped, "$"), $options: 'i' } }
+                                ]
+                            }, {
+                                sort: {
+                                    updatedAt: -1,
+                                    createdAt: -1
+                                }
+                            })];
+                    case 16:
+                        bySlugOrName = _c.sent();
+                        if (bySlugOrName) {
+                            return [2 /*return*/, bySlugOrName];
+                        }
+                        _c.label = 17;
+                    case 17:
+                        appNameCandidates_1_1 = appNameCandidates_1.next();
+                        return [3 /*break*/, 15];
+                    case 18: return [3 /*break*/, 21];
+                    case 19:
+                        e_6_1 = _c.sent();
+                        e_6 = { error: e_6_1 };
+                        return [3 /*break*/, 21];
+                    case 20:
+                        try {
+                            if (appNameCandidates_1_1 && !appNameCandidates_1_1.done && (_b = appNameCandidates_1.return)) _b.call(appNameCandidates_1);
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                        return [7 /*endfinally*/];
+                    case 21: return [2 /*return*/, null];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.buildDashboardAutoFixTitle = function (email, log, app) {
+        var identifier = log.autofix_error_count_string || (log._id || '').slice(-6) || 'error';
+        var source = (email.sourceApp || log.source_app || (app === null || app === void 0 ? void 0 : app.name) || 'application').trim();
+        return "Auto-fix ".concat(identifier, ": ").concat(source);
+    };
+    ErrorAutoFixManager.prototype.buildDashboardAutoFixDescription = function (email, log, app) {
+        var normalizedBody = this.normalizeEmailText(email.body || log.body || '', 15000);
+        var metadata = log.report_metadata && Object.keys(log.report_metadata).length
+            ? JSON.stringify(log.report_metadata, null, 2)
+            : '';
+        var context = log.report_context && Object.keys(log.report_context).length
+            ? JSON.stringify(log.report_context, null, 2)
+            : '';
+        var attachments = Array.isArray(log.attachments) ? log.attachments : [];
+        var attachmentLines = attachments.length
+            ? attachments.map(function (att) { return "- ".concat(((att === null || att === void 0 ? void 0 : att.name) || 'attachment').trim(), " ").concat((att === null || att === void 0 ? void 0 : att.url) ? "(".concat(att.url, ")") : '').trim(); }).join('\n')
+            : '(none)';
+        var lines = [
+            '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: ".concat((app === null || app === void 0 ? void 0 : app.name) || (app === null || app === void 0 ? void 0 : app._id) || 'unknown'),
+            "Repo: ".concat((app === null || app === void 0 ? void 0 : app.repo) || 'unknown'),
+            "Environment: ".concat(email.sourceEnvironment || log.source_environment || 'unknown'),
+            "Severity: ".concat(email.severity || log.severity || 'error'),
+            "Fingerprint: ".concat(email.issueHash || log.issue_hash || log.email_hash || 'n/a'),
+            "Error Log Id: ".concat(String((log === null || log === void 0 ? void 0 : log._id) || '').trim() || 'n/a'),
+            "Previous Dashboard Job Id: ".concat(String((log === null || log === void 0 ? void 0 : 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');
+    };
+    ErrorAutoFixManager.prototype.evaluateDashboardPublishOutcome = function (job) {
+        var logEntries = Array.isArray(job === null || job === void 0 ? void 0 : job.log) ? job.log : [];
+        var lastMatch = function (predicate) {
+            for (var i = logEntries.length - 1; i >= 0; i -= 1) {
+                if (predicate(logEntries[i] || '')) {
+                    return logEntries[i];
+                }
+            }
+            return '';
+        };
+        var failureEntry = lastMatch(function (entry) { return /publish failed|artifact publish failed|deploy failed/i.test(entry || ''); });
+        if (failureEntry) {
+            return {
+                success: false,
+                message: failureEntry
+            };
+        }
+        var publishEntry = lastMatch(function (entry) { return /Published build to /i.test(entry || ''); });
+        if (publishEntry) {
+            var branchMatch = publishEntry.match(/\(([^()]+)\)\.?$/);
+            return {
+                success: true,
+                branchName: (branchMatch && branchMatch[1]) ? branchMatch[1].trim() : undefined,
+                message: publishEntry
+            };
+        }
+        var skippedEntry = lastMatch(function (entry) { return /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.'
+        };
+    };
+    ErrorAutoFixManager.prototype.queueDashboardMonitor = function (log, email, jobId, effectiveEnvironment) {
+        var _this = this;
+        var logId = ((log === null || log === void 0 ? void 0 : log._id) || '').trim();
+        var normalizedJobId = (jobId || '').trim();
+        if (!logId || !normalizedJobId) {
+            return;
+        }
+        if (this.dashboardMonitors.has(logId)) {
+            return;
+        }
+        var monitor = (function () { return __awaiter(_this, void 0, void 0, function () {
+            var error_7;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, 3, 4]);
+                        return [4 /*yield*/, this.monitorDashboardAutoFixJob(log, email, normalizedJobId, effectiveEnvironment)];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2:
+                        error_7 = _a.sent();
+                        console.error('Auto-fix dashboard monitor failed', { logId: logId, jobId: normalizedJobId, error: error_7 });
+                        return [3 /*break*/, 4];
+                    case 3:
+                        this.dashboardMonitors.delete(logId);
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); })();
+        this.dashboardMonitors.set(logId, monitor);
+    };
+    ErrorAutoFixManager.prototype.monitorDashboardAutoFixJob = function (log, email, jobId, effectiveEnvironment) {
+        return __awaiter(this, void 0, void 0, function () {
+            var logId, fail, error_8, message, isRunning, error_9, message, job, publishOutcome, fallbackBranch, branchName, successLog;
+            var _this = this;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        logId = ((log === null || log === void 0 ? void 0 : log._id) || '').trim();
+                        if (!logId) {
+                            return [2 /*return*/];
+                        }
+                        fail = function (message) { return __awaiter(_this, void 0, void 0, function () {
+                            var failedLog;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.updateLog(logId, {
+                                            status: 'failed',
+                                            last_error: message,
+                                            last_result_at: new Date(),
+                                            openai_task_id: jobId,
+                                            openai_environment: effectiveEnvironment
+                                        })];
+                                    case 1:
+                                        failedLog = (_a.sent()) || log;
+                                        return [4 /*yield*/, this.notifyCustomerWorkflowStatus('completed_failed', email, failedLog, { error: message })];
+                                    case 2:
+                                        _a.sent();
+                                        return [4 /*yield*/, this.notify({
+                                                status: 'failed',
+                                                email: email,
+                                                error: message,
+                                                log: failedLog,
+                                                summary: failedLog.plan_summary || email.subject
+                                            })];
+                                    case 3:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 5]);
+                        return [4 /*yield*/, this.waitForDashboardJobStop(jobId, this.config.dashboardWaitTimeoutMs)];
+                    case 2:
+                        _b.sent();
+                        return [3 /*break*/, 5];
+                    case 3:
+                        error_8 = _b.sent();
+                        message = (error_8 === null || error_8 === void 0 ? void 0 : error_8.message) || 'Failed while waiting for dashboard job completion.';
+                        return [4 /*yield*/, fail(message)];
+                    case 4:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 5:
+                        isRunning = false;
+                        _b.label = 6;
+                    case 6:
+                        _b.trys.push([6, 8, , 10]);
+                        return [4 /*yield*/, this.isDashboardJobRunning(jobId)];
+                    case 7:
+                        isRunning = _b.sent();
+                        return [3 /*break*/, 10];
+                    case 8:
+                        error_9 = _b.sent();
+                        message = (error_9 === null || error_9 === void 0 ? void 0 : error_9.message) || 'Unable to confirm dashboard job completion state.';
+                        return [4 /*yield*/, fail(message)];
+                    case 9:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 10:
+                        if (!isRunning) return [3 /*break*/, 12];
+                        return [4 /*yield*/, fail("Dashboard job ".concat(jobId, " timed out before completion."))];
+                    case 11:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 12: return [4 /*yield*/, AIDashboardJobs.findOne({ _id: jobId })];
+                    case 13:
+                        job = _b.sent();
+                        if (!!job) return [3 /*break*/, 15];
+                        return [4 /*yield*/, fail("Dashboard job ".concat(jobId, " not found."))];
+                    case 14:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 15:
+                        if (!(job.phase !== 'COMPLETE' || job.paused)) return [3 /*break*/, 17];
+                        return [4 /*yield*/, fail("Dashboard job ".concat(jobId, " ended in phase ").concat(job.phase || 'unknown').concat(job.paused ? ' (paused)' : '', "."))];
+                    case 16:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 17:
+                        publishOutcome = this.evaluateDashboardPublishOutcome(job);
+                        if (!!publishOutcome.success) return [3 /*break*/, 19];
+                        return [4 /*yield*/, fail(publishOutcome.message)];
+                    case 18:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 19:
+                        fallbackBranch = (String(((_a = this._serverConfig) === null || _a === void 0 ? void 0 : _a['GITHUB_DEFAULT_BRANCH']) || process.env.GITHUB_DEFAULT_BRANCH || 'main').trim() || 'main');
+                        branchName = publishOutcome.branchName || fallbackBranch;
+                        return [4 /*yield*/, this.updateLog(logId, {
+                                status: 'success',
+                                branch_name: branchName,
+                                pr_url: '',
+                                last_error: '',
+                                last_result_at: new Date(),
+                                openai_task_id: jobId,
+                                openai_environment: effectiveEnvironment
+                            })];
+                    case 20:
+                        successLog = (_b.sent()) || log;
+                        return [4 /*yield*/, this.notifyCustomerWorkflowStatus('completed_success', email, successLog, { notes: publishOutcome.message })];
+                    case 21:
+                        _b.sent();
+                        return [4 /*yield*/, this.notify({
+                                status: 'success',
+                                email: email,
+                                branchName: branchName,
+                                log: successLog,
+                                summary: successLog.plan_summary || email.subject,
+                                notes: publishOutcome.message
+                            })];
+                    case 22:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.dispatchDashboardWorkflow = function (email, log) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fail, openaiEnvironment, app, repo, effectiveEnvironment, emailHash, rawHash, title, description, job, error_10, message, jobId, queuedLog;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        fail = function (status, reason, message) { return __awaiter(_this, void 0, void 0, function () {
+                            var updated;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.updateLog(log._id, {
+                                            status: status,
+                                            last_error: message,
+                                            last_result_at: new Date()
+                                        })];
+                                    case 1:
+                                        updated = (_a.sent()) || log;
+                                        return [2 /*return*/, {
+                                                status: status,
+                                                email: email,
+                                                error: message,
+                                                log: updated,
+                                                reason: reason
+                                            }];
+                                }
+                            });
+                        }); };
+                        openaiEnvironment = this.resolveEnvironmentForTask(email, log);
+                        return [4 /*yield*/, this.resolveAutoFixApp(email, log, openaiEnvironment)];
+                    case 1:
+                        app = _a.sent();
+                        if (!!(app === null || app === void 0 ? void 0 : app._id)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, fail('skipped', 'dashboard_app_not_found', 'No AI Coder app found for this error log.')];
+                    case 2: return [2 /*return*/, _a.sent()];
+                    case 3:
+                        repo = (app.repo || '').trim();
+                        if (!!repo) return [3 /*break*/, 5];
+                        return [4 /*yield*/, fail('skipped', 'dashboard_repo_missing', 'Resolved AI Coder app is missing repo configuration.')];
+                    case 4: return [2 /*return*/, _a.sent()];
+                    case 5:
+                        effectiveEnvironment = repo;
+                        emailHash = email.issueHash || email.hash || this.generateIssueHash(email);
+                        rawHash = email.rawHash || this.generateRawEmailHash(email);
+                        title = this.buildDashboardAutoFixTitle(email, log, app);
+                        description = this.buildDashboardAutoFixDescription(email, log, app);
+                        _a.label = 6;
+                    case 6:
+                        _a.trys.push([6, 8, , 10]);
+                        return [4 /*yield*/, this.createDashboardJob({
+                                project: app._id,
+                                title: title,
+                                description: description,
+                                repo: repo,
+                                path: app.git_local_path || undefined,
+                                projectRoot: app.project_root || undefined
+                            })];
+                    case 7:
+                        job = _a.sent();
+                        return [3 /*break*/, 10];
+                    case 8:
+                        error_10 = _a.sent();
+                        message = (error_10 === null || error_10 === void 0 ? void 0 : error_10.message) || 'Unable to enqueue dashboard auto-fix job.';
+                        return [4 /*yield*/, fail('failed', 'dashboard_job_create_failed', message)];
+                    case 9: return [2 /*return*/, _a.sent()];
+                    case 10:
+                        jobId = ((job === null || job === void 0 ? void 0 : job._id) || '').trim();
+                        if (!!jobId) return [3 /*break*/, 12];
+                        return [4 /*yield*/, fail('failed', 'dashboard_job_missing_id', 'Dashboard job created without an id.')];
+                    case 11: return [2 /*return*/, _a.sent()];
+                    case 12: return [4 /*yield*/, 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
+                        })];
+                    case 13:
+                        queuedLog = (_a.sent()) || log;
+                        this.queueDashboardMonitor(queuedLog, email, jobId, effectiveEnvironment);
+                        return [2 /*return*/, {
+                                status: 'in_progress',
+                                email: email,
+                                log: queuedLog,
+                                reason: 'dashboard_job_queued',
+                                summary: title,
+                                notes: "Dashboard job ".concat(jobId, " queued for autonomous build/fix/publish/deploy.")
+                            }];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.dispatchGithubWorkflow = function (email, log) {
+        return __awaiter(this, void 0, void 0, function () {
+            var openaiEnvironment, fallbackEnv, resolvedEnvironment, repoTarget, updated, updated, effectiveEnv, emailHash, rawHash, workBranch, contextIdentifier, contextPath, normalizedBody, contextContent, commentBody, baseBranch, baseSha, pr, title, bodyLines, updated, err_6, message, updated;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        openaiEnvironment = this.resolveEnvironmentForTask(email, log);
+                        fallbackEnv = this.config.githubOwner && this.config.githubRepo ? "".concat(this.config.githubOwner, "/").concat(this.config.githubRepo) : '';
+                        resolvedEnvironment = (openaiEnvironment || fallbackEnv || '').trim();
+                        repoTarget = this.parseRepoTarget(resolvedEnvironment) || this.parseRepoTarget(fallbackEnv);
+                        this.debugLog('Starting GitHub PR workflow.', {
+                            emailKey: email.key,
+                            logId: log._id,
+                            openaiEnvironment: resolvedEnvironment,
+                            repoTarget: repoTarget
+                        });
+                        if (!!this.config.githubToken) return [3 /*break*/, 2];
+                        return [4 /*yield*/, 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
+                            })];
+                    case 1:
+                        updated = (_a.sent()) || log;
+                        return [2 /*return*/, {
+                                status: 'skipped',
+                                email: email,
+                                error: 'GitHub token not configured',
+                                log: updated,
+                                reason: 'missing_github_token'
+                            }];
+                    case 2:
+                        if (!!repoTarget) return [3 /*break*/, 4];
+                        return [4 /*yield*/, 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
+                            })];
+                    case 3:
+                        updated = (_a.sent()) || log;
+                        return [2 /*return*/, {
+                                status: 'skipped',
+                                email: email,
+                                error: 'GitHub repository not configured',
+                                log: updated,
+                                reason: 'missing_github_repo'
+                            }];
+                    case 4:
+                        effectiveEnv = "".concat(repoTarget.owner, "/").concat(repoTarget.repo);
+                        emailHash = email.issueHash || email.hash || this.generateIssueHash(email);
+                        rawHash = email.rawHash || this.generateRawEmailHash(email);
+                        workBranch = this.buildWorkBranch(emailHash);
+                        contextIdentifier = (emailHash || '').slice(0, 12) || 'autofix';
+                        contextPath = ".openai/error-context/".concat(contextIdentifier, ".md");
+                        normalizedBody = this.normalizeEmailText(email.body || '');
+                        contextContent = this.buildContextMarkdown(email, contextIdentifier, normalizedBody);
+                        commentBody = this.buildOpenAIComment(email, contextPath, normalizedBody);
+                        return [4 /*yield*/, 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
+                            })];
+                    case 5:
+                        _a.sent();
+                        _a.label = 6;
+                    case 6:
+                        _a.trys.push([6, 16, , 18]);
+                        return [4 /*yield*/, this.resolveBaseBranch(repoTarget)];
+                    case 7:
+                        baseBranch = _a.sent();
+                        return [4 /*yield*/, this.getBranchSha(repoTarget, baseBranch)];
+                    case 8:
+                        baseSha = _a.sent();
+                        return [4 /*yield*/, this.ensureBranch(repoTarget, workBranch, baseBranch, baseSha)];
+                    case 9:
+                        _a.sent();
+                        return [4 /*yield*/, this.upsertContextFile(repoTarget, workBranch, contextPath, contextContent)];
+                    case 10:
+                        _a.sent();
+                        return [4 /*yield*/, this.findOpenPullRequest(repoTarget, workBranch, baseBranch)];
+                    case 11:
+                        pr = _a.sent();
+                        if (!!pr) return [3 /*break*/, 13];
+                        title = "AI Autofix: ".concat((email.subject || 'ResolveIO Error').slice(0, 180));
+                        bodyLines = [
+                            'This PR was opened automatically to let AI investigate the reported failure.',
+                            '',
+                            "Context file: `".concat(contextPath, "`")
+                        ];
+                        return [4 /*yield*/, this.createPullRequest(repoTarget, workBranch, baseBranch, title, bodyLines.join('\n'))];
+                    case 12:
+                        pr = _a.sent();
+                        _a.label = 13;
+                    case 13: return [4 /*yield*/, this.commentOnPullRequest(repoTarget, pr.number, commentBody)];
+                    case 14:
+                        _a.sent();
+                        return [4 /*yield*/, 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
+                            })];
+                    case 15:
+                        updated = (_a.sent()) || log;
+                        return [2 /*return*/, {
+                                status: 'success',
+                                email: email,
+                                branchName: workBranch,
+                                prUrl: pr.html_url,
+                                log: updated,
+                                summary: email.subject,
+                                notes: "Context file: ".concat(contextPath)
+                            }];
+                    case 16:
+                        err_6 = _a.sent();
+                        message = (err_6 === null || err_6 === void 0 ? void 0 : err_6.message) || 'GitHub workflow failed.';
+                        return [4 /*yield*/, 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
+                            })];
+                    case 17:
+                        updated = (_a.sent()) || log;
+                        return [2 /*return*/, {
+                                status: 'failed',
+                                email: email,
+                                error: message,
+                                log: updated
+                            }];
+                    case 18: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ErrorAutoFixManager.prototype.notify = function (result) {
+        return __awaiter(this, void 0, void 0, function () {
+            var recipients, subject, bodyLines, logId, summary, reason, textBody, recipients_3, recipients_3_1, email, e_7_1;
+            var e_7, _a;
+            var _b, _c, _d, _e, _f, _g, _h, _j, _k;
+            return __generator(this, function (_l) {
+                switch (_l.label) {
+                    case 0:
+                        if (result.status === 'in_progress') {
+                            return [2 /*return*/];
+                        }
+                        if (result.status === 'skipped' && result.reason && !this.shouldNotifySkip(result.reason)) {
+                            return [2 /*return*/];
+                        }
+                        recipients = this.config.notifyEmails.length
+                            ? this.config.notifyEmails
+                            : (result.status === 'failed' ? [DEFAULT_ERROR_ALERT_EMAIL] : []);
+                        if (!recipients.length) {
+                            return [2 /*return*/];
+                        }
+                        subject = '';
+                        bodyLines = [];
+                        logId = ((_b = result.log) === null || _b === void 0 ? void 0 : _b._id) || '';
+                        summary = result.summary || ((_c = result.log) === null || _c === void 0 ? void 0 : _c.plan_summary) || result.email.subject;
+                        if (result.status === 'success') {
+                            subject = "ResolveIO AutoFix \u2714 ".concat(summary);
+                            bodyLines = [
+                                'Auto-fix workflow completed successfully.',
+                                "Client: ".concat(((_d = result.log) === null || _d === void 0 ? void 0 : _d.client_name) || result.email.client_name || 'Unknown'),
+                                "Source: ".concat(((_e = result.log) === null || _e === void 0 ? void 0 : _e.source_type) || result.email.source_type || 'app'),
+                                '',
+                                "Branch: ".concat(result.branchName || 'unknown'),
+                                "PR: ".concat(result.prUrl || 'pending'),
+                                '',
+                                'Summary:',
+                                summary || '(none)',
+                                ''
+                            ];
+                            if (result.notes) {
+                                bodyLines.push("Notes: ".concat(result.notes), '');
+                            }
+                            if (logId) {
+                                bodyLines.push("Log ID: ".concat(logId));
+                            }
+                        }
+                        else if (result.status === 'failed') {
+                            subject = "ResolveIO AutoFix \u2716 ".concat(summary);
+                            bodyLines = [
+                                'Auto-fix workflow failed.',
+                                "Reason: ".concat(result.error || ((_f = result.log) === null || _f === void 0 ? void 0 : _f.last_error) || 'Unknown error'),
+                                "Client: ".concat(((_g = result.log) === null || _g === void 0 ? void 0 : _g.client_name) || result.email.client_name || 'Unknown'),
+                                "Source: ".concat(((_h = result.log) === null || _h === void 0 ? void 0 : _h.source_type) || result.email.source_type || 'app'),
+                                '',
+                                'Email Subject:',
+                                result.email.subject
+                            ];
+                            if (logId) {
+                                bodyLines.push('', "Log ID: ".concat(logId));
+                            }
+                        }
+                        else {
+                            subject = "ResolveIO AutoFix \u26A0 ".concat(result.email.subject);
+                            reason = result.reason || 'skipped';
+                            bodyLines = [
+                                "Auto-fix skipped. Reason: ".concat(reason, "."),
+                                result.error && result.error !== reason ? "Details: ".concat(result.error) : '',
+                                "Client: ".concat(((_j = result.log) === null || _j === void 0 ? void 0 : _j.client_name) || result.email.client_name || 'Unknown'),
+                                "Source: ".concat(((_k = result.log) === null || _k === void 0 ? void 0 : _k.source_type) || result.email.source_type || 'app'),
+                                ''
+                            ];
+                            if (logId) {
+                                bodyLines.push("Log ID: ".concat(logId));
+                            }
+                            bodyLines.push('Update or remove the log entry to retry processing.');
+                        }
+                        textBody = bodyLines.filter(function (line) { return line !== undefined && line !== null && line !== ''; }).join('\n');
+                        _l.label = 1;
+                    case 1:
+                        _l.trys.push([1, 6, 7, 8]);
+                        recipients_3 = __values(recipients), recipients_3_1 = recipients_3.next();
+                        _l.label = 2;
+                    case 2:
+                        if (!!recipients_3_1.done) return [3 /*break*/, 5];
+                        email = recipients_3_1.value;
+                        return [4 /*yield*/, resolveio_server_app_1.ResolveIOServer.getMainServer().getMethodManager().sendEmail(email, subject, textBody)];
+                    case 3:
+                        _l.sent();
+                        _l.label = 4;
+                    case 4:
+                        recipients_3_1 = recipients_3.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_7_1 = _l.sent();
+                        e_7 = { error: e_7_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (recipients_3_1 && !recipients_3_1.done && (_a = recipients_3.return)) _a.call(recipients_3);
+                        }
+                        finally { if (e_7) throw e_7.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return ErrorAutoFixManager;
+}());
+exports.ErrorAutoFixManager = ErrorAutoFixManager;
+function ensureErrorAutoFixManager(serverConfig) {
+    var existing = resolveio_server_app_1.ResolveIOServer['AutoFixManager'];
+    if (existing) {
+        return existing;
+    }
+    if (!configuredErrorAutoFixDependencies) {
+        return null;
+    }
+    var resolvedServerConfig = serverConfig || resolveio_server_app_1.ResolveIOServer.getServerConfig();
+    if (!resolvedServerConfig) {
+        return null;
+    }
+    var manager = new ErrorAutoFixManager(resolvedServerConfig);
+    resolveio_server_app_1.ResolveIOServer['AutoFixManager'] = manager;
+    return manager;
+}
+function reportDevError(options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var manager;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    manager = ensureErrorAutoFixManager();
+                    if (!manager) {
+                        console.warn('AutoFix manager not initialized for dev alert', options === null || options === void 0 ? void 0 : options.subject);
+                        return [2 /*return*/];
+                    }
+                    return [4 /*yield*/, manager.reportDevError(options)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+
+//# sourceMappingURL=error-auto-fix.manager.js.map