@chatman-media/conversation-engine 1.2.0 → 1.3.0

package/dist/index.js

@@ -693,8 +693,8 @@ class StylesRepo {
   }
 }
 // src/dal/notifications.ts
-import { eq as eq10, and as and10, sql as sql7 } from "drizzle-orm";
-import { notificationRules, operatorSettings, notificationTemplates, notificationGroupTokens } from "@chatman-media/storage";
+import { and as and10, desc as desc3, eq as eq10, gte, inArray, isNull as isNull2, sql as sql7 } from "drizzle-orm";
+import { admins, adminNotifications, notificationRules, operatorSettings, notificationTemplates, notificationGroupTokens } from "@chatman-media/storage";
 
 class NotificationsRepo {
   db;
@@ -812,6 +812,54 @@ class NotificationsRepo {
   async deleteGroupLinkToken(token) {
     await this.db.delete(notificationGroupTokens).where(eq10(notificationGroupTokens.token, token));
   }
+  async resolveOwnerSettings(tenantId) {
+    const [owner] = await this.db.select({ adminId: admins.id, email: admins.email }).from(admins).where(and10(eq10(admins.tenantId, tenantId), eq10(admins.role, "superadmin"))).orderBy(admins.id).limit(1);
+    if (!owner)
+      return null;
+    const settings = await this.findOperatorSettings(owner.adminId);
+    return { adminId: owner.adminId, email: owner.email, settings };
+  }
+  async findOperatorSettingsByChatId(chatId) {
+    const rows = await this.db.select().from(operatorSettings).where(eq10(operatorSettings.telegramChatId, chatId)).limit(1);
+    return rows[0];
+  }
+  async updateInformerPrefs(adminId, prefs, tenantId) {
+    if (Object.keys(prefs).length === 0)
+      return;
+    const now = Math.floor(Date.now() / 1000);
+    if (tenantId !== undefined) {
+      await this.db.insert(operatorSettings).values({ adminId, tenantId, ...prefs }).onConflictDoUpdate({
+        target: [operatorSettings.adminId],
+        set: { ...prefs, updatedAt: now }
+      });
+      return;
+    }
+    await this.db.update(operatorSettings).set({ ...prefs, updatedAt: now }).where(eq10(operatorSettings.adminId, adminId));
+  }
+  async insertAdminNotification(row) {
+    const [ins] = await this.db.insert(adminNotifications).values(row).returning({ id: adminNotifications.id });
+    if (!ins)
+      throw new Error("admin_notifications insert returned no row");
+    return ins.id;
+  }
+  async markNotificationDelivered(id, deliveredAt) {
+    await this.db.update(adminNotifications).set({ deliveredAt }).where(eq10(adminNotifications.id, id));
+  }
+  async findRecentByDedup(tenantId, dedupKey, sinceEpoch) {
+    const rows = await this.db.select().from(adminNotifications).where(and10(eq10(adminNotifications.tenantId, tenantId), eq10(adminNotifications.dedupKey, dedupKey), gte(adminNotifications.createdAt, sinceEpoch))).orderBy(desc3(adminNotifications.createdAt)).limit(1);
+    return rows[0];
+  }
+  async listRecentNotifications(tenantId, adminId, limit = 10) {
+    return this.db.select().from(adminNotifications).where(and10(eq10(adminNotifications.tenantId, tenantId), eq10(adminNotifications.adminId, adminId))).orderBy(desc3(adminNotifications.createdAt)).limit(limit);
+  }
+  async listPendingDigest(tenantId, adminId) {
+    return this.db.select().from(adminNotifications).where(and10(eq10(adminNotifications.tenantId, tenantId), eq10(adminNotifications.adminId, adminId), isNull2(adminNotifications.deliveredAt), isNull2(adminNotifications.digestBatchId))).orderBy(adminNotifications.createdAt);
+  }
+  async markDigested(ids, batchId) {
+    if (ids.length === 0)
+      return;
+    await this.db.update(adminNotifications).set({ digestBatchId: batchId }).where(inArray(adminNotifications.id, ids));
+  }
 }
 // src/notifications.ts
 import { TelegramClient } from "@chatman-media/channel-telegram";
@@ -820,16 +868,22 @@ class NotificationService {
   repo;
   botToken;
   appUrl;
+  informer;
   client = null;
-  constructor(repo, botToken, appUrl) {
+  constructor(repo, botToken, appUrl, informer) {
     this.repo = repo;
     this.botToken = botToken;
     this.appUrl = appUrl;
+    this.informer = informer;
     if (botToken) {
       this.client = new TelegramClient({ token: botToken });
     }
   }
   async notify(event) {
+    const ownerAdminId = this.informer ? await this.informer.resolveOwnerAdminId(event.tenantId) : null;
+    if (this.informer) {
+      await this.informer.emitNotificationEvent(event);
+    }
     if (!this.client)
       return;
     const [rules, operatorSettingsList] = await Promise.all([
@@ -850,6 +904,8 @@ class NotificationService {
     for (const settings of operatorSettingsList) {
       if (!settings.telegramChatId)
         continue;
+      if (ownerAdminId !== null && settings.adminId === ownerAdminId)
+        continue;
       if (settings.notifyOnAssignedOnly && event.assignedAdminId !== undefined && event.assignedAdminId !== settings.adminId) {
         continue;
       }
@@ -979,8 +1035,439 @@ class NotificationService {
     return map[key] ?? key;
   }
 }
-// src/operator-bot-handler.ts
+// src/ops-alerts.ts
 import { TelegramClient as TelegramClient2 } from "@chatman-media/channel-telegram";
+import { admins as admins2, operatorSettings as operatorSettings2, tenants } from "@chatman-media/storage";
+import { and as and11, eq as eq11, isNotNull } from "drizzle-orm";
+
+// src/with-tenant.ts
+import { sql as sql8 } from "drizzle-orm";
+async function withTenant(db, tenantId, fn) {
+  return db.transaction(async (tx) => {
+    await tx.execute(sql8.raw(`SET LOCAL app.tenant_id = ${tenantId}`));
+    return fn(tx);
+  });
+}
+
+// src/ops-alerts.ts
+var SEVERITY_EMOJI = {
+  critical: "\uD83D\uDD34",
+  warning: "\uD83D\uDFE1",
+  info: "ℹ️"
+};
+function escapeHtml(v) {
+  return v.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+async function resolveOwnerContacts(db, tenantId) {
+  return withTenant(db, tenantId, async (tx) => {
+    const [owner] = await tx.select({ email: admins2.email, slug: tenants.slug }).from(admins2).innerJoin(tenants, eq11(tenants.id, admins2.tenantId)).where(and11(eq11(admins2.tenantId, tenantId), eq11(admins2.role, "superadmin"))).limit(1);
+    const chats = await tx.select({ chatId: operatorSettings2.telegramChatId }).from(operatorSettings2).where(and11(eq11(operatorSettings2.tenantId, tenantId), isNotNull(operatorSettings2.telegramChatId)));
+    return {
+      email: owner?.email ?? null,
+      slug: owner?.slug ?? null,
+      telegramChatIds: chats.map((c) => c.chatId).filter((x) => !!x)
+    };
+  });
+}
+
+class OpsAlertRouter {
+  deps;
+  telegram;
+  cooldownMs;
+  lastAt = new Map;
+  constructor(deps) {
+    this.deps = deps;
+    if (deps.telegram !== undefined) {
+      this.telegram = deps.telegram;
+    } else if (deps.botToken) {
+      const client = new TelegramClient2({ token: deps.botToken });
+      this.telegram = {
+        send: (chatId, htmlText) => client.sendMessage({ chatId, text: htmlText, parseMode: "HTML" }).then(() => {
+          return;
+        })
+      };
+    } else {
+      this.telegram = null;
+    }
+    this.cooldownMs = deps.cooldownMs ?? 30 * 60000;
+  }
+  suppressed(alert, nowMs) {
+    const key = `${alert.tenantId}:${alert.dedupKey}`;
+    const last = this.lastAt.get(key);
+    if (last !== undefined && nowMs - last < this.cooldownMs)
+      return true;
+    this.lastAt.set(key, nowMs);
+    return false;
+  }
+  async emit(alert) {
+    if (this.deps.informer) {
+      await this.deps.informer.emitOpsAlert(alert);
+      return;
+    }
+    if (this.suppressed(alert, Date.now()))
+      return;
+    const owner = await resolveOwnerContacts(this.deps.db, alert.tenantId).catch((err) => {
+      this.deps.log?.warn?.("[ops-alerts] owner resolve failed", { tenantId: alert.tenantId, err: String(err) });
+      return null;
+    });
+    if (!owner)
+      return;
+    let telegramDelivered = false;
+    if (this.telegram && owner.telegramChatIds.length > 0) {
+      const text = `${SEVERITY_EMOJI[alert.severity]} <b>${escapeHtml(alert.title)}</b>
+
+` + `${escapeHtml(alert.detail)}`;
+      for (const chatId of owner.telegramChatIds) {
+        try {
+          await this.telegram.send(chatId, text);
+          telegramDelivered = true;
+        } catch (err) {
+          this.deps.log?.warn?.("[ops-alerts] telegram send failed", { chatId, err: String(err) });
+        }
+      }
+    }
+    const emailNeeded = alert.severity === "critical" || !telegramDelivered && alert.severity !== "info";
+    let emailDelivered = false;
+    if (emailNeeded && this.deps.email && owner.email) {
+      try {
+        await this.deps.email.send({
+          to: owner.email,
+          subject: `[${alert.severity}] ${alert.title} — обменник`,
+          html: renderOpsEmailHtml(alert, this.deps.appUrl)
+        });
+        emailDelivered = true;
+      } catch (err) {
+        this.deps.log?.warn?.("[ops-alerts] email send failed", { to: owner.email, err: String(err) });
+      }
+    }
+    this.deps.log?.info?.("[ops-alerts] routed", {
+      tenantId: alert.tenantId,
+      kind: alert.kind,
+      severity: alert.severity,
+      telegramDelivered,
+      emailDelivered
+    });
+  }
+}
+function renderOpsEmailHtml(alert, appUrl) {
+  const color = alert.severity === "critical" ? "#dc2626" : alert.severity === "warning" ? "#d97706" : "#2563eb";
+  return `<!DOCTYPE html><html lang="ru"><body style="margin:0;background:#f4f4f5;font-family:-apple-system,Segoe UI,sans-serif">
+  <div style="max-width:560px;margin:32px auto;background:#fff;border-radius:12px;overflow:hidden;box-shadow:0 1px 3px rgba(0,0,0,.08)">
+    <div style="background:${color};padding:20px 28px;color:#fff;font-size:18px;font-weight:700">${SEVERITY_EMOJI[alert.severity]} ${escapeHtml(alert.title)}</div>
+    <div style="padding:24px 28px;color:#18181b;font-size:15px;line-height:1.6">
+      <p style="margin:0 0 16px">${escapeHtml(alert.detail)}</p>
+      <a href="${appUrl}" style="display:inline-block;padding:10px 20px;background:${color};color:#fff;border-radius:8px;font-weight:600;text-decoration:none">Открыть админку →</a>
+    </div>
+    <div style="padding:16px 28px;background:#fafafa;border-top:1px solid #e4e4e7;font-size:12px;color:#a1a1aa">
+      lead-engine · операционный алерт обменника · severity: ${alert.severity}
+    </div>
+  </div></body></html>`;
+}
+
+class ResendEmailSender {
+  apiKey;
+  from;
+  constructor(apiKey, from) {
+    this.apiKey = apiKey;
+    this.from = from;
+  }
+  async send(opts) {
+    if (!this.apiKey) {
+      console.log(`[resend] dry-run (no key) → to=${opts.to} subject="${opts.subject}"`);
+      return;
+    }
+    const res = await fetch("https://api.resend.com/emails", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.apiKey}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ from: this.from, to: [opts.to], subject: opts.subject, html: opts.html })
+    });
+    if (!res.ok) {
+      throw new Error(`Resend error ${res.status}: ${await res.text().catch(() => "")}`);
+    }
+  }
+}
+// src/admin-informer.ts
+import { TelegramClient as TelegramClient3 } from "@chatman-media/channel-telegram";
+var INFORMER_TOPICS = ["leads", "escalation", "orders", "system"];
+var SEV_RANK = { info: 1, important: 2, critical: 3 };
+var LEVEL_THRESHOLD = {
+  silent: 4,
+  critical: 3,
+  important: 2,
+  all: 1
+};
+function passesThreshold(severity, level) {
+  return SEV_RANK[severity] >= LEVEL_THRESHOLD[level];
+}
+function isMuted(settings, nowEpoch) {
+  const until = settings?.informerMutedUntil;
+  return typeof until === "number" && until > nowEpoch;
+}
+function topicEnabled(settings, topic) {
+  const raw = settings?.informerTopics;
+  if (!raw)
+    return true;
+  try {
+    const map = JSON.parse(raw);
+    return map[topic] !== false;
+  } catch {
+    return true;
+  }
+}
+var OPS_TOPIC = {
+  rate_anomaly: "system",
+  rate_feed_stale: "system",
+  channel_down: "system",
+  order_stuck: "orders",
+  volume_spike: "orders"
+};
+function mapOpsSeverity(s) {
+  return s === "warning" ? "important" : s;
+}
+function opsAlertToInformer(alert) {
+  return {
+    tenantId: alert.tenantId,
+    topic: OPS_TOPIC[alert.kind] ?? "system",
+    severity: mapOpsSeverity(alert.severity),
+    kind: alert.kind,
+    title: alert.title,
+    detail: alert.detail,
+    dedupKey: alert.dedupKey
+  };
+}
+var NOTIF_MAP = {
+  lead_intake_complete: { topic: "leads", severity: "info", title: "Новый лид" },
+  stage_changed: { topic: "leads", severity: "info", title: "Смена стадии" },
+  lead_stale: { topic: "leads", severity: "info", title: "Лид завис" },
+  human_takeover: { topic: "escalation", severity: "important", title: "Нужна помощь оператора" },
+  verification_requested: { topic: "escalation", severity: "important", title: "Видео-верификация" },
+  document_uploaded: { topic: "escalation", severity: "info", title: "Загружен документ" },
+  high_value_deal: { topic: "orders", severity: "important", title: "Крупная сделка" }
+};
+function notificationEventToInformer(event, appUrl) {
+  const meta = NOTIF_MAP[event.eventType];
+  if (!meta)
+    return null;
+  const parts = [];
+  const who = event.data.displayName;
+  if (typeof who === "string" && who)
+    parts.push(`Клиент: ${who}`);
+  if (event.data.fromStage && event.data.toStage) {
+    parts.push(`${event.data.fromStage} → ${event.data.toStage}`);
+  } else if (event.data.toStage) {
+    parts.push(`Стадия: ${event.data.toStage}`);
+  }
+  if (event.data.amount !== undefined && event.data.amount !== null) {
+    parts.push(`Сумма: ${event.data.amount}`);
+  }
+  const ref = event.leadId ?? event.conversationId ?? event.contactId ?? 0;
+  const url = event.leadId && appUrl ? `${appUrl}/leads/${event.leadId}` : event.conversationId && appUrl ? `${appUrl}/conversations/${event.conversationId}` : undefined;
+  return {
+    tenantId: event.tenantId,
+    topic: meta.topic,
+    severity: meta.severity,
+    kind: event.eventType,
+    title: meta.title,
+    detail: parts.join(" · "),
+    dedupKey: `${event.eventType}:${ref}`,
+    url
+  };
+}
+var SEV_EMOJI = {
+  critical: "\uD83D\uDD34",
+  important: "\uD83D\uDFE1",
+  info: "ℹ️"
+};
+var TOPIC_EMOJI = {
+  leads: "\uD83C\uDD95",
+  escalation: "\uD83C\uDD98",
+  orders: "\uD83D\uDCB1",
+  system: "\uD83D\uDEE0"
+};
+function escapeHtml2(v) {
+  return v.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+
+class AdminInformer {
+  deps;
+  telegram;
+  cooldownSec;
+  repo;
+  constructor(deps) {
+    this.deps = deps;
+    if (deps.telegram !== undefined) {
+      this.telegram = deps.telegram;
+    } else if (deps.botToken) {
+      const client = new TelegramClient3({ token: deps.botToken });
+      this.telegram = {
+        send: (chatId, htmlText) => client.sendMessage({ chatId, text: htmlText, parseMode: "HTML", disableWebPagePreview: true }).then(() => {
+          return;
+        })
+      };
+    } else {
+      this.telegram = null;
+    }
+    this.cooldownSec = deps.cooldownSec ?? 30 * 60;
+    this.repo = new NotificationsRepo(deps.db);
+  }
+  async resolveOwnerAdminId(tenantId) {
+    return withTenant(this.deps.db, tenantId, async (tx) => {
+      const repo = new NotificationsRepo(tx);
+      const owner = await repo.resolveOwnerSettings(tenantId);
+      return owner?.adminId ?? null;
+    }).catch(() => null);
+  }
+  async emitOpsAlert(alert) {
+    await this.emit(opsAlertToInformer(alert));
+  }
+  async emitNotificationEvent(event) {
+    const ev = notificationEventToInformer(event, this.deps.appUrl);
+    if (ev)
+      await this.emit(ev);
+  }
+  async emit(event) {
+    const now = Math.floor(Date.now() / 1000);
+    const plan = await withTenant(this.deps.db, event.tenantId, async (tx) => {
+      const repo = new NotificationsRepo(tx);
+      const owner = await repo.resolveOwnerSettings(event.tenantId);
+      if (!owner)
+        return null;
+      if (!topicEnabled(owner.settings, event.topic))
+        return null;
+      const chatId = owner.settings?.telegramChatId ?? null;
+      if (!chatId && event.severity !== "critical")
+        return null;
+      const recent = await repo.findRecentByDedup(event.tenantId, event.dedupKey, now - this.cooldownSec);
+      if (recent)
+        return null;
+      const level = owner.settings?.informerLevel ?? "important";
+      const realtime = !isMuted(owner.settings, now) && passesThreshold(event.severity, level);
+      const rowId = await repo.insertAdminNotification({
+        tenantId: event.tenantId,
+        adminId: owner.adminId,
+        topic: event.topic,
+        severity: event.severity,
+        kind: event.kind,
+        title: event.title,
+        body: event.detail,
+        dedupKey: event.dedupKey,
+        targetChatId: chatId
+      });
+      return { rowId, chatId, email: owner.email, realtime };
+    }).catch((err) => {
+      this.deps.log?.warn?.("[informer] resolve/insert failed", {
+        tenantId: event.tenantId,
+        err: String(err)
+      });
+      return null;
+    });
+    if (!plan)
+      return;
+    let delivered = false;
+    if (plan.realtime && this.telegram && plan.chatId) {
+      try {
+        await this.telegram.send(plan.chatId, this.renderHtml(event));
+        delivered = true;
+      } catch (err) {
+        this.deps.log?.warn?.("[informer] telegram send failed", {
+          chatId: plan.chatId,
+          err: String(err)
+        });
+      }
+    }
+    if (event.severity === "critical" && this.deps.email && plan.email) {
+      try {
+        await this.deps.email.send({
+          to: plan.email,
+          subject: `[critical] ${event.title}`,
+          html: this.renderEmailHtml(event)
+        });
+        delivered = true;
+      } catch (err) {
+        this.deps.log?.warn?.("[informer] email send failed", { to: plan.email, err: String(err) });
+      }
+    }
+    if (delivered) {
+      await this.repo.markNotificationDelivered(plan.rowId, now).catch((err) => this.deps.log?.warn?.("[informer] mark delivered failed", {
+        rowId: plan.rowId,
+        err: String(err)
+      }));
+    }
+    this.deps.log?.info?.("[informer] routed", {
+      tenantId: event.tenantId,
+      kind: event.kind,
+      topic: event.topic,
+      severity: event.severity,
+      realtime: plan.realtime,
+      delivered
+    });
+  }
+  renderHtml(event) {
+    let msg = `${SEV_EMOJI[event.severity]} ${TOPIC_EMOJI[event.topic]} <b>${escapeHtml2(event.title)}</b>`;
+    if (event.detail)
+      msg += `
+
+${escapeHtml2(event.detail)}`;
+    if (event.url)
+      msg += `
+
+<a href="${escapeHtml2(event.url)}">Открыть →</a>`;
+    return msg;
+  }
+  renderEmailHtml(event) {
+    const color = "#dc2626";
+    return `<!DOCTYPE html><html lang="ru"><body style="margin:0;background:#f4f4f5;font-family:-apple-system,Segoe UI,sans-serif">
+  <div style="max-width:560px;margin:32px auto;background:#fff;border-radius:12px;overflow:hidden;box-shadow:0 1px 3px rgba(0,0,0,.08)">
+    <div style="background:${color};padding:20px 28px;color:#fff;font-size:18px;font-weight:700">${SEV_EMOJI[event.severity]} ${escapeHtml2(event.title)}</div>
+    <div style="padding:24px 28px;color:#18181b;font-size:15px;line-height:1.6">
+      <p style="margin:0 0 16px">${escapeHtml2(event.detail)}</p>
+      <a href="${escapeHtml2(event.url ?? this.deps.appUrl)}" style="display:inline-block;padding:10px 20px;background:${color};color:#fff;border-radius:8px;font-weight:600;text-decoration:none">Открыть админку →</a>
+    </div>
+    <div style="padding:16px 28px;background:#fafafa;border-top:1px solid #e4e4e7;font-size:12px;color:#a1a1aa">
+      lead-engine · информер владельца · ${event.topic} / ${event.severity}
+    </div>
+  </div></body></html>`;
+  }
+}
+// src/operator-bot-handler.ts
+import {
+  TelegramClient as TelegramClient4
+} from "@chatman-media/channel-telegram";
+var LEVELS = ["silent", "critical", "important", "all"];
+var LEVEL_LABEL = {
+  silent: "\uD83D\uDD15 Тихо",
+  critical: "\uD83D\uDD34 Только критичное",
+  important: "\uD83D\uDFE1 Важное",
+  all: "\uD83D\uDCE2 Всё подряд"
+};
+var TOPICS = ["leads", "escalation", "orders", "system"];
+var TOPIC_LABEL = {
+  leads: "\uD83C\uDD95 Лиды",
+  escalation: "\uD83C\uDD98 Эскалации",
+  orders: "\uD83D\uDCB1 Заявки",
+  system: "\uD83D\uDEE0 Система"
+};
+var DIGESTS = ["off", "daily", "shift"];
+var DIGEST_LABEL = {
+  off: "Выкл",
+  daily: "Раз в день",
+  shift: "2×/день"
+};
+var SEV_EMOJI2 = { critical: "\uD83D\uDD34", important: "\uD83D\uDFE1", info: "ℹ️" };
+function escapeHtml3(v) {
+  return v.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function parseMuteSeconds(arg) {
+  const a = arg.trim().toLowerCase();
+  if (!a || a === "off" || a === "0")
+    return 0;
+  const m = /^(\d+)\s*(m|h|d)$/.exec(a);
+  if (!m)
+    return null;
+  const n = Number.parseInt(m[1], 10);
+  const unit = m[2];
+  return unit === "m" ? n * 60 : unit === "h" ? n * 3600 : n * 86400;
+}
 
 class OperatorBotHandler {
   repo;
@@ -990,11 +1477,17 @@ class OperatorBotHandler {
     this.repo = repo;
     this.botToken = botToken;
     if (botToken) {
-      this.client = new TelegramClient2({ token: botToken });
+      this.client = new TelegramClient4({ token: botToken });
     }
   }
   async handleUpdate(update) {
-    if (!this.client || !update.message)
+    if (!this.client)
+      return;
+    if (update.callback_query) {
+      await this.handleCallback(update.callback_query);
+      return;
+    }
+    if (!update.message)
       return;
     const { message } = update;
     const text = message.text || "";
@@ -1017,14 +1510,223 @@ class OperatorBotHandler {
       await this.handleSetupGroup(message.chat.id, message.chat.title || "эту группу");
       return;
     }
+    if (text === "/status")
+      return this.cmdStatus(chatId);
+    if (text === "/level")
+      return this.cmdLevel(chatId);
+    if (text === "/topics")
+      return this.cmdTopics(chatId);
+    if (text === "/digest")
+      return this.cmdDigest(chatId);
+    if (text === "/mute" || text.startsWith("/mute "))
+      return this.cmdMute(chatId, text);
+    if (text === "/last" || text.startsWith("/last "))
+      return this.cmdLast(chatId, text);
     if (text === "/start") {
       await this.client.sendMessage({
         chatId,
-        text: `\uD83D\uDC4B Привет! Я бот-уведомитель для Lead Engine.
+        parseMode: "HTML",
+        text: `\uD83D\uDC4B Привет! Я бот-информер Lead Engine.
+
+` + `Чтобы привязать аккаунт — Админка → Уведомления → «Подключить Telegram».
+
+` + `Когда привязан, настраивай прямо здесь:
+` + `• /status — текущие настройки
+` + `• /level — насколько громко информировать
+` + `• /topics — какие темы слать
+` + `• /digest — сводка (выкл/раз в день/2×)
+` + `• /mute 2h — заглушить на время
+` + "• /last — последние события"
+      });
+    }
+  }
+  async cmdStatus(chatId) {
+    const s = await this.repo.findOperatorSettingsByChatId(chatId);
+    if (!s)
+      return this.replyNotLinked(chatId);
+    const now = Math.floor(Date.now() / 1000);
+    const muted = s.informerMutedUntil && s.informerMutedUntil > now ? `вкл (ещё ${Math.ceil((s.informerMutedUntil - now) / 60)} мин)` : "выкл";
+    const map = this.topicMap(s.informerTopics);
+    const topicsLine = TOPICS.map((t) => `${map[t] ? "✅" : "⬜"} ${TOPIC_LABEL[t]}`).join(`
+`);
+    await this.client?.sendMessage({
+      chatId,
+      parseMode: "HTML",
+      text: `⚙️ <b>Информер</b>
+
+` + `Уровень: <b>${LEVEL_LABEL[s.informerLevel] ?? s.informerLevel}</b>
+` + `Дайджест: <b>${DIGEST_LABEL[s.informerDigest] ?? s.informerDigest}</b> ` + `(${s.informerDigestHour}:00 ${s.informerTz})
+` + `Мут: <b>${muted}</b>
+
+` + `Темы:
+${topicsLine}
+
+` + "Изменить: /level · /topics · /digest · /mute"
+    });
+  }
+  async cmdLevel(chatId) {
+    const s = await this.repo.findOperatorSettingsByChatId(chatId);
+    if (!s)
+      return this.replyNotLinked(chatId);
+    await this.client?.sendMessage({
+      chatId,
+      text: "Насколько громко информировать?",
+      replyMarkup: this.levelKeyboard(s.informerLevel)
+    });
+  }
+  async cmdTopics(chatId) {
+    const s = await this.repo.findOperatorSettingsByChatId(chatId);
+    if (!s)
+      return this.replyNotLinked(chatId);
+    await this.client?.sendMessage({
+      chatId,
+      text: "Темы (нажми, чтобы вкл/выкл):",
+      replyMarkup: this.topicsKeyboard(this.topicMap(s.informerTopics))
+    });
+  }
+  async cmdDigest(chatId) {
+    const s = await this.repo.findOperatorSettingsByChatId(chatId);
+    if (!s)
+      return this.replyNotLinked(chatId);
+    await this.client?.sendMessage({
+      chatId,
+      text: "Как часто слать сводку?",
+      replyMarkup: this.digestKeyboard(s.informerDigest)
+    });
+  }
+  async cmdMute(chatId, text) {
+    const arg = text.split(/\s+/)[1] ?? "";
+    const sec = parseMuteSeconds(arg);
+    if (sec === null) {
+      await this.client?.sendMessage({
+        chatId,
+        text: "Формат: /mute 30m · /mute 2h · /mute 1d · /mute off"
+      });
+      return;
+    }
+    const s = await this.repo.findOperatorSettingsByChatId(chatId);
+    if (!s)
+      return this.replyNotLinked(chatId);
+    const until = sec === 0 ? null : Math.floor(Date.now() / 1000) + sec;
+    await this.repo.updateInformerPrefs(s.adminId, { informerMutedUntil: until });
+    await this.client?.sendMessage({
+      chatId,
+      text: until ? `\uD83D\uDD07 Заглушено на ${Math.round(sec / 60)} мин. Реалтайм вернётся, события всё равно попадут в дайджест.` : "\uD83D\uDD14 Мут снят."
+    });
+  }
+  async cmdLast(chatId, text) {
+    const s = await this.repo.findOperatorSettingsByChatId(chatId);
+    if (!s)
+      return this.replyNotLinked(chatId);
+    const arg = Number.parseInt(text.split(/\s+/)[1] ?? "", 10);
+    const limit = Number.isFinite(arg) ? Math.min(Math.max(arg, 1), 20) : 10;
+    const rows = await this.repo.listRecentNotifications(s.tenantId, s.adminId, limit);
+    if (rows.length === 0) {
+      await this.client?.sendMessage({ chatId, text: "Пока пусто — событий ещё не было." });
+      return;
+    }
+    let msg = `\uD83D\uDDD2 <b>Последние ${rows.length}:</b>`;
+    for (const r of rows) {
+      const when = new Date(r.createdAt * 1000).toISOString().slice(5, 16).replace("T", " ");
+      msg += `
 
-Чтобы привязать свой аккаунт, перейдите в Админку -> Настройки уведомлений и нажмите 'Подключить Telegram'.`
+${SEV_EMOJI2[r.severity] ?? ""} <b>${escapeHtml3(r.title)}</b> · ${when}`;
+      if (r.body)
+        msg += `
+${escapeHtml3(r.body)}`;
+    }
+    await this.client?.sendMessage({ chatId, parseMode: "HTML", text: msg });
+  }
+  async handleCallback(cq) {
+    if (!this.client)
+      return;
+    const chatId = String(cq.message?.chat.id ?? cq.from.id);
+    const s = await this.repo.findOperatorSettingsByChatId(chatId);
+    if (!s) {
+      await this.client.answerCallbackQuery({ callbackQueryId: cq.id, text: "Аккаунт не привязан" });
+      return;
+    }
+    const [kind, val] = (cq.data ?? "").split(":");
+    if (kind === "lvl" && LEVELS.includes(val ?? "")) {
+      await this.repo.updateInformerPrefs(s.adminId, { informerLevel: val });
+      await this.editKeyboard(cq, "Насколько громко информировать?", this.levelKeyboard(val));
+      await this.client.answerCallbackQuery({ callbackQueryId: cq.id, text: LEVEL_LABEL[val] });
+      return;
+    }
+    if (kind === "dig" && DIGESTS.includes(val ?? "")) {
+      await this.repo.updateInformerPrefs(s.adminId, { informerDigest: val });
+      await this.editKeyboard(cq, "Как часто слать сводку?", this.digestKeyboard(val));
+      await this.client.answerCallbackQuery({ callbackQueryId: cq.id, text: DIGEST_LABEL[val] });
+      return;
+    }
+    if (kind === "tpc" && TOPICS.includes(val ?? "")) {
+      const map = this.topicMap(s.informerTopics);
+      map[val] = !map[val];
+      await this.repo.updateInformerPrefs(s.adminId, { informerTopics: JSON.stringify(map) });
+      await this.editKeyboard(cq, "Темы (нажми, чтобы вкл/выкл):", this.topicsKeyboard(map));
+      await this.client.answerCallbackQuery({
+        callbackQueryId: cq.id,
+        text: `${TOPIC_LABEL[val]}: ${map[val] ? "вкл" : "выкл"}`
       });
+      return;
     }
+    await this.client.answerCallbackQuery({ callbackQueryId: cq.id });
+  }
+  async editKeyboard(cq, text, markup) {
+    if (!this.client || !cq.message)
+      return;
+    await this.client.editMessageText({
+      chatId: cq.message.chat.id,
+      messageId: cq.message.message_id,
+      text,
+      replyMarkup: markup
+    }).catch(() => {});
+  }
+  levelKeyboard(current) {
+    return {
+      inline_keyboard: LEVELS.map((l) => [
+        { text: `${l === current ? "• " : ""}${LEVEL_LABEL[l]}`, callback_data: `lvl:${l}` }
+      ])
+    };
+  }
+  digestKeyboard(current) {
+    return {
+      inline_keyboard: DIGESTS.map((d) => [
+        { text: `${d === current ? "• " : ""}${DIGEST_LABEL[d]}`, callback_data: `dig:${d}` }
+      ])
+    };
+  }
+  topicsKeyboard(map) {
+    return {
+      inline_keyboard: TOPICS.map((t) => [
+        { text: `${map[t] ? "✅" : "⬜"} ${TOPIC_LABEL[t]}`, callback_data: `tpc:${t}` }
+      ])
+    };
+  }
+  topicMap(raw) {
+    const base = {
+      leads: true,
+      escalation: true,
+      orders: true,
+      system: true
+    };
+    if (!raw)
+      return base;
+    try {
+      const m = JSON.parse(raw);
+      for (const t of TOPICS)
+        if (m[t] === false)
+          base[t] = false;
+      return base;
+    } catch {
+      return base;
+    }
+  }
+  async replyNotLinked(chatId) {
+    await this.client?.sendMessage({
+      chatId,
+      text: "Сначала привяжите аккаунт: Админка → Уведомления → «Подключить Telegram»."
+    });
   }
   async handleLinkToken(token, chatId) {
     if (!this.client)
@@ -1040,7 +1742,7 @@ class OperatorBotHandler {
     await this.repo.linkChat(settings.adminId, chatId);
     await this.client.sendMessage({
       chatId,
-      text: "✅ Аккаунт успешно привязан! Теперь вы будете получать важные уведомления здесь."
+      text: "✅ Аккаунт привязан! Здесь будут важные уведомления. Настрой громкость: /level · /topics · /digest"
     });
   }
   async handleGroupLinkToken(token, chatId, title) {
@@ -1463,20 +2165,20 @@ async function runMemoryExtraction(opts) {
 }
 // src/stage-classifier.ts
 import { conversations as conversationsTable2 } from "@chatman-media/storage";
-import { and as and11, eq as eq11 } from "drizzle-orm";
+import { and as and12, eq as eq12 } from "drizzle-orm";
 async function applyClassifiedStage(opts) {
   if (!opts.newStage)
     return false;
-  const [row] = await opts.db.select({ stage: conversationsTable2.currentStage }).from(conversationsTable2).where(and11(eq11(conversationsTable2.id, opts.conversationId), eq11(conversationsTable2.tenantId, opts.tenantId)));
+  const [row] = await opts.db.select({ stage: conversationsTable2.currentStage }).from(conversationsTable2).where(and12(eq12(conversationsTable2.id, opts.conversationId), eq12(conversationsTable2.tenantId, opts.tenantId)));
   if (!row || row.stage === opts.newStage)
     return false;
-  await opts.db.update(conversationsTable2).set({ currentStage: opts.newStage }).where(and11(eq11(conversationsTable2.id, opts.conversationId), eq11(conversationsTable2.tenantId, opts.tenantId)));
+  await opts.db.update(conversationsTable2).set({ currentStage: opts.newStage }).where(and12(eq12(conversationsTable2.id, opts.conversationId), eq12(conversationsTable2.tenantId, opts.tenantId)));
   return true;
 }
 // src/secrets.ts
 import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
 import { tenantSecrets } from "@chatman-media/storage";
-import { and as and12, eq as eq12 } from "drizzle-orm";
+import { and as and13, eq as eq13 } from "drizzle-orm";
 var ALGORITHM = "aes-256-gcm";
 var IV_LEN = 12;
 var AUTH_TAG_LEN = 16;
@@ -1536,7 +2238,7 @@ function decryptSecret(masterKeyHex, ciphertext) {
   }
 }
 async function getDecryptedSecret(opts) {
-  const [row] = await opts.db.select().from(tenantSecrets).where(and12(eq12(tenantSecrets.tenantId, opts.tenantId), eq12(tenantSecrets.key, opts.key)));
+  const [row] = await opts.db.select().from(tenantSecrets).where(and13(eq13(tenantSecrets.tenantId, opts.tenantId), eq13(tenantSecrets.key, opts.key)));
   if (!row)
     return null;
   return decryptSecret(opts.masterKeyHex, row.encryptedValue);
@@ -1569,15 +2271,6 @@ var systemClock = {
   nowEpoch: () => Math.floor(Date.now() / 1000)
 };
 
-// src/with-tenant.ts
-import { sql as sql9 } from "drizzle-orm";
-async function withTenant(db, tenantId, fn) {
-  return db.transaction(async (tx) => {
-    await tx.execute(sql9.raw(`SET LOCAL app.tenant_id = ${tenantId}`));
-    return fn(tx);
-  });
-}
-
 // src/dispatch-reply.ts
 async function generateReplyAndEnqueue(deps) {
   const clock = deps.clock ?? systemClock;
@@ -1981,16 +2674,23 @@ export {
   withTenant,
   validateTransition,
   transitionLeadState,
+  topicEnabled,
   systemClock,
   setEncryptedSecret,
   runMemoryExtraction,
+  resolveOwnerContacts,
   resolveConversation,
   resolveContact,
+  renderOpsEmailHtml,
   processInbound,
+  passesThreshold,
   parseStyleConfig,
   parseAllocation,
+  opsAlertToInformer,
+  notificationEventToInformer,
   loadExperimentVariants,
   isTerminal,
+  isMuted,
   getInitialStage,
   getDecryptedSecret,
   generateReplyAndEnqueue,
@@ -2005,8 +2705,10 @@ export {
   StylesRepo,
   SkillOutcomesRepo,
   SecretCryptoError,
+  ResendEmailSender,
   RagReplyStrategy,
   OutboundQueueRepo,
+  OpsAlertRouter,
   OperatorBotHandler,
   NotificationsRepo,
   NotificationService,
@@ -2015,10 +2717,12 @@ export {
   LlmMemoryExtractor,
   LeadsRepo,
   KbSuggestionsRepo,
+  INFORMER_TOPICS,
   FunnelTransitionError,
   ExperimentsRepo,
   DrizzleKbStore,
   ConversationsRepo,
   ContactsRepo,
-  ChannelIdentitiesRepo
+  ChannelIdentitiesRepo,
+  AdminInformer
 };