@chatman-media/conversation-engine 1.2.0

package/dist/index.js

@@ -0,0 +1,2024 @@
+// src/contact-resolver.ts
+async function resolveContact(opts) {
+  const existingIdentity = await opts.identities.find(opts.channelDbId, opts.inbound.externalUserId);
+  if (existingIdentity) {
+    const contact2 = await opts.contacts.byId(existingIdentity.contactId);
+    if (!contact2) {
+      throw new Error(`resolveContact: identity ${existingIdentity.id} points to missing contact ${existingIdentity.contactId}`);
+    }
+    return contact2;
+  }
+  const contact = await opts.contacts.create({
+    ...opts.inbound.externalUsername ? { displayName: opts.inbound.externalUsername } : {}
+  });
+  await opts.identities.create({
+    contactId: contact.id,
+    channelId: opts.channelDbId,
+    externalUserId: opts.inbound.externalUserId
+  });
+  return contact;
+}
+// src/conversation-resolver.ts
+function channelKindToSource(kind) {
+  switch (kind) {
+    case "telegram_bot":
+      return "bot";
+    case "telegram_userbot":
+      return "userbot";
+    default:
+      return "bot";
+  }
+}
+async function resolveConversation(opts) {
+  const source = channelKindToSource(opts.channelKind);
+  const existing = await opts.conversations.findByContactAndSource(opts.contactId, source);
+  if (existing) {
+    return { conversation: existing, created: false };
+  }
+  const created = await opts.conversations.create({
+    contactId: opts.contactId,
+    source,
+    mode: "ai",
+    nowEpoch: opts.nowEpoch
+  });
+  return { conversation: created, created: true };
+}
+// src/dal/channel-identities.ts
+import { channelIdentities } from "@chatman-media/storage";
+import { and, eq } from "drizzle-orm";
+
+class ChannelIdentitiesRepo {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async find(channelId, externalUserId) {
+    const [row] = await this.ctx.db.select().from(channelIdentities).where(and(eq(channelIdentities.channelId, channelId), eq(channelIdentities.externalUserId, externalUserId)));
+    return row ?? null;
+  }
+  async create(opts) {
+    const [row] = await this.ctx.db.insert(channelIdentities).values({
+      contactId: opts.contactId,
+      channelId: opts.channelId,
+      externalUserId: opts.externalUserId
+    }).returning();
+    if (!row)
+      throw new Error("channel_identities.create: insert returned no row");
+    return row;
+  }
+}
+// src/dal/kb-suggestions.ts
+import { kbSuggestions } from "@chatman-media/storage";
+
+class KbSuggestionsRepo {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async log(opts) {
+    await this.ctx.db.insert(kbSuggestions).values({
+      tenantId: this.ctx.tenantId,
+      questionText: opts.questionText,
+      status: "pending",
+      ...opts.sourceConversationId !== undefined ? { sourceConversationId: opts.sourceConversationId } : {},
+      ...opts.sourceMessageId !== undefined ? { sourceMessageId: opts.sourceMessageId } : {},
+      createdAt: opts.nowEpoch,
+      updatedAt: opts.nowEpoch
+    });
+  }
+}
+// src/dal/contacts.ts
+import { contacts as contactsTable } from "@chatman-media/storage";
+import { and as and2, eq as eq2 } from "drizzle-orm";
+
+class ContactsRepo {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async byId(id) {
+    const [row] = await this.ctx.db.select().from(contactsTable).where(and2(eq2(contactsTable.id, id), eq2(contactsTable.tenantId, this.ctx.tenantId)));
+    return row ?? null;
+  }
+  async create(opts) {
+    const [row] = await this.ctx.db.insert(contactsTable).values({
+      tenantId: this.ctx.tenantId,
+      ...opts.displayName !== undefined ? { displayName: opts.displayName } : {},
+      ...opts.attributesJson !== undefined ? { attributesJson: opts.attributesJson } : {}
+    }).returning();
+    if (!row)
+      throw new Error("contacts.create: insert returned no row");
+    return row;
+  }
+  async mergeAttributes(contactId, partial, nowEpoch) {
+    if (Object.keys(partial).length === 0) {
+      return this.byId(contactId);
+    }
+    const existing = await this.byId(contactId);
+    if (!existing)
+      return null;
+    const merged = existing.attributesJson ? { ...JSON.parse(existing.attributesJson) } : {};
+    for (const [k, v] of Object.entries(partial)) {
+      merged[k] = v;
+    }
+    const [row] = await this.ctx.db.update(contactsTable).set({ attributesJson: JSON.stringify(merged), updatedAt: nowEpoch }).where(and2(eq2(contactsTable.id, contactId), eq2(contactsTable.tenantId, this.ctx.tenantId))).returning();
+    return row ?? null;
+  }
+}
+// src/dal/conversations.ts
+import { conversations as conversationsTable } from "@chatman-media/storage";
+import { and as and3, eq as eq3, sql } from "drizzle-orm";
+
+class ConversationsRepo {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async findByContactAndSource(contactId, source) {
+    const [row] = await this.ctx.db.select().from(conversationsTable).where(and3(eq3(conversationsTable.tenantId, this.ctx.tenantId), eq3(conversationsTable.userId, contactId), eq3(conversationsTable.source, source)));
+    return row ?? null;
+  }
+  async create(opts) {
+    const [row] = await this.ctx.db.insert(conversationsTable).values({
+      tenantId: this.ctx.tenantId,
+      userId: opts.contactId,
+      source: opts.source,
+      ...opts.mode ? { mode: opts.mode } : {},
+      ...opts.styleId !== undefined ? { styleId: opts.styleId } : {},
+      ...opts.experimentId !== undefined ? { experimentId: opts.experimentId } : {},
+      lastMessageAt: opts.nowEpoch
+    }).returning();
+    if (!row)
+      throw new Error("conversations.create: insert returned no row");
+    return row;
+  }
+  async recent(limit) {
+    const rows = await this.ctx.db.select().from(conversationsTable).where(eq3(conversationsTable.tenantId, this.ctx.tenantId)).orderBy(sql`last_message_at DESC NULLS LAST`).limit(limit);
+    return rows;
+  }
+  async touchLastMessageAt(conversationId, nowEpoch) {
+    await this.ctx.db.update(conversationsTable).set({ lastMessageAt: nowEpoch }).where(and3(eq3(conversationsTable.id, conversationId), eq3(conversationsTable.tenantId, this.ctx.tenantId)));
+  }
+  async updateInboxMetadata(conversationId, opts) {
+    const updates = {};
+    if (opts.lastMessageText !== undefined)
+      updates.lastMessageText = opts.lastMessageText;
+    if (opts.lastMessageAt !== undefined)
+      updates.lastMessageAt = opts.lastMessageAt;
+    if (opts.status !== undefined)
+      updates.status = opts.status;
+    await this.ctx.db.update(conversationsTable).set({
+      ...updates,
+      ...opts.incrementUnread ? { unreadCount: sql`${conversationsTable.unreadCount} + 1` } : {}
+    }).where(and3(eq3(conversationsTable.id, conversationId), eq3(conversationsTable.tenantId, this.ctx.tenantId)));
+  }
+  async markAsRead(conversationId) {
+    await this.ctx.db.update(conversationsTable).set({ unreadCount: 0 }).where(and3(eq3(conversationsTable.id, conversationId), eq3(conversationsTable.tenantId, this.ctx.tenantId)));
+  }
+  async setAssignee(conversationId, adminId) {
+    await this.ctx.db.update(conversationsTable).set({ assignedAdminId: adminId }).where(and3(eq3(conversationsTable.id, conversationId), eq3(conversationsTable.tenantId, this.ctx.tenantId)));
+  }
+  async setSummaryJson(conversationId, summaryJson) {
+    await this.ctx.db.update(conversationsTable).set({ summaryJson }).where(and3(eq3(conversationsTable.id, conversationId), eq3(conversationsTable.tenantId, this.ctx.tenantId)));
+  }
+  async findById(conversationId) {
+    const [row] = await this.ctx.db.select().from(conversationsTable).where(and3(eq3(conversationsTable.id, conversationId), eq3(conversationsTable.tenantId, this.ctx.tenantId)));
+    return row ?? null;
+  }
+}
+// src/dal/kb-store.ts
+import {
+  reciprocalRankFusion,
+  sanitizeFtsQuery
+} from "@chatman-media/kb";
+import { sql as sql2 } from "drizzle-orm";
+
+class DrizzleKbStore {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  vec(embedding) {
+    return `[${embedding.join(",")}]`;
+  }
+  async search(embedding, k, topic) {
+    const e = this.vec(embedding);
+    const t = this.ctx.tenantId;
+    if (topic == null) {
+      const rows = await this.ctx.db.execute(sql2`
+        SELECT c.id AS chunk_id,
+               (c.embedding <=> ${e}::vector) AS distance,
+               c.text, c.document_id, d.source, d.title
+        FROM kb_chunks c
+        JOIN kb_documents d ON d.id = c.document_id
+        WHERE c.embedding IS NOT NULL
+          AND c.tenant_id = ${t}
+          AND d.tenant_id = ${t}
+        ORDER BY c.embedding <=> ${e}::vector ASC
+        LIMIT ${k}
+      `);
+      return rows;
+    }
+    const overFetched = await this.ctx.db.execute(sql2`
+      SELECT c.id AS chunk_id,
+             (c.embedding <=> ${e}::vector) AS distance,
+             c.text, c.document_id, d.source, d.title, d.topic
+      FROM kb_chunks c
+      JOIN kb_documents d ON d.id = c.document_id
+      WHERE c.embedding IS NOT NULL
+        AND c.tenant_id = ${t}
+        AND d.tenant_id = ${t}
+      ORDER BY c.embedding <=> ${e}::vector ASC
+      LIMIT ${k * 3}
+    `);
+    return overFetched.filter((h) => h.topic === topic || h.topic === null).slice(0, k).map(({ topic: _t, ...rest }) => rest);
+  }
+  async searchBm25(query, k, topic) {
+    const ftsQuery = sanitizeFtsQuery(query);
+    if (!ftsQuery)
+      return [];
+    const t = this.ctx.tenantId;
+    try {
+      if (topic == null) {
+        const rows2 = await this.ctx.db.execute(sql2`
+          SELECT c.id AS chunk_id,
+                 -ts_rank(c.fts, to_tsquery('russian', ${ftsQuery})) AS distance,
+                 c.text, c.document_id, d.source, d.title
+          FROM kb_chunks c
+          JOIN kb_documents d ON d.id = c.document_id
+          WHERE c.fts @@ to_tsquery('russian', ${ftsQuery})
+            AND c.tenant_id = ${t}
+            AND d.tenant_id = ${t}
+          ORDER BY ts_rank(c.fts, to_tsquery('russian', ${ftsQuery})) DESC
+          LIMIT ${k}
+        `);
+        return rows2;
+      }
+      const rows = await this.ctx.db.execute(sql2`
+        SELECT c.id AS chunk_id,
+               -ts_rank(c.fts, to_tsquery('russian', ${ftsQuery})) AS distance,
+               c.text, c.document_id, d.source, d.title
+        FROM kb_chunks c
+        JOIN kb_documents d ON d.id = c.document_id
+        WHERE c.fts @@ to_tsquery('russian', ${ftsQuery})
+          AND c.tenant_id = ${t}
+          AND d.tenant_id = ${t}
+          AND (d.topic = ${topic} OR d.topic IS NULL)
+        ORDER BY ts_rank(c.fts, to_tsquery('russian', ${ftsQuery})) DESC
+        LIMIT ${k}
+      `);
+      return rows;
+    } catch (err) {
+      console.warn(`[kb] BM25 query failed for "${query}":`, err.message);
+      return [];
+    }
+  }
+  async textSearch(query, k = 5, topic) {
+    return this.searchBm25(query, k, topic);
+  }
+  async hybridSearch(input) {
+    const k = input.k ?? 5;
+    const cands = k * 2;
+    const topic = input.topic ?? null;
+    const vectorHits = await this.search(input.embedding, cands, topic);
+    const bm25Hits = await this.searchBm25(input.query, cands, topic);
+    if (bm25Hits.length === 0)
+      return vectorHits.slice(0, k);
+    if (vectorHits.length === 0)
+      return bm25Hits.slice(0, k);
+    return reciprocalRankFusion(vectorHits, bm25Hits, k, 60);
+  }
+  async prioritySearch(input) {
+    const k = input.k ?? 5;
+    const booksHits = await this.search(input.embedding, k, "books");
+    if (booksHits.length > 0)
+      return booksHits;
+    if (input.vectorOnly)
+      return this.search(input.embedding, k);
+    return this.hybridSearch({ embedding: input.embedding, query: input.query, k });
+  }
+  async getDocumentBySource(source) {
+    const t = this.ctx.tenantId;
+    const rows = await this.ctx.db.execute(sql2`
+      SELECT id, content_hash
+      FROM kb_documents
+      WHERE source = ${source} AND tenant_id = ${t}
+      LIMIT 1
+    `);
+    return rows[0] ?? null;
+  }
+  async countChunksForDocument(documentId) {
+    const t = this.ctx.tenantId;
+    const rows = await this.ctx.db.execute(sql2`
+      SELECT COUNT(*)::INTEGER AS n
+      FROM kb_chunks
+      WHERE document_id = ${documentId} AND tenant_id = ${t}
+    `);
+    return rows[0]?.n ?? 0;
+  }
+  async deleteDocument(id) {
+    const t = this.ctx.tenantId;
+    await this.ctx.db.execute(sql2`
+      DELETE FROM kb_chunks
+      WHERE document_id = ${id} AND tenant_id = ${t}
+    `);
+    const result = await this.ctx.db.execute(sql2`
+      DELETE FROM kb_documents
+      WHERE id = ${id} AND tenant_id = ${t}
+    `);
+    const check = await this.ctx.db.execute(sql2`
+      SELECT 1 AS exists FROM kb_documents WHERE id = ${id} AND tenant_id = ${t}
+    `);
+    return check.length === 0;
+  }
+  async upsertDocument(input) {
+    const t = this.ctx.tenantId;
+    const topic = input.topic ?? null;
+    const rows = await this.ctx.db.execute(sql2`
+      INSERT INTO kb_documents (tenant_id, source, title, content_hash, topic)
+      VALUES (${t}, ${input.source}, ${input.title}, ${input.contentHash}, ${topic})
+      ON CONFLICT (source, content_hash) DO UPDATE SET source = EXCLUDED.source
+      RETURNING id
+    `);
+    if (!rows[0])
+      throw new Error("kb_documents upsert returned no row");
+    return rows[0];
+  }
+  async insertChunkWithEmbedding(input) {
+    const t = this.ctx.tenantId;
+    const e = this.vec(input.embedding);
+    await this.ctx.db.execute(sql2`
+      INSERT INTO kb_chunks (tenant_id, document_id, chunk_index, text, token_count, embedding)
+      VALUES (${t}, ${input.documentId}, ${input.chunkIndex}, ${input.text}, ${input.tokenCount}, ${e}::vector)
+    `);
+  }
+}
+// src/dal/experiments.ts
+import { experiments as experimentsTable } from "@chatman-media/storage";
+import { and as and4, desc, eq as eq4 } from "drizzle-orm";
+
+class ExperimentsRepo {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async byId(id) {
+    const [row] = await this.ctx.db.select().from(experimentsTable).where(and4(eq4(experimentsTable.id, id), eq4(experimentsTable.tenantId, this.ctx.tenantId)));
+    return row ?? null;
+  }
+  async findRunningBySlug(slug) {
+    const [row] = await this.ctx.db.select().from(experimentsTable).where(and4(eq4(experimentsTable.tenantId, this.ctx.tenantId), eq4(experimentsTable.slug, slug), eq4(experimentsTable.status, "running")));
+    return row ?? null;
+  }
+  async listAll() {
+    const rows = await this.ctx.db.select().from(experimentsTable).where(eq4(experimentsTable.tenantId, this.ctx.tenantId)).orderBy(desc(experimentsTable.createdAt));
+    return rows;
+  }
+  async create(data) {
+    const nowEpoch = Math.floor(Date.now() / 1000);
+    const [row] = await this.ctx.db.insert(experimentsTable).values({
+      tenantId: this.ctx.tenantId,
+      slug: data.slug,
+      status: "draft",
+      allocationJson: data.allocationJson,
+      successMetric: data.successMetric,
+      createdAt: nowEpoch
+    }).returning();
+    return row;
+  }
+  async update(id, data) {
+    const [row] = await this.ctx.db.update(experimentsTable).set(data).where(and4(eq4(experimentsTable.id, id), eq4(experimentsTable.tenantId, this.ctx.tenantId))).returning();
+    return row ?? null;
+  }
+  async setStatus(id, status) {
+    const nowEpoch = Math.floor(Date.now() / 1000);
+    const extra = {};
+    if (status === "running")
+      extra.startedAt = nowEpoch;
+    if (status === "done")
+      extra.endedAt = nowEpoch;
+    const [row] = await this.ctx.db.update(experimentsTable).set({ status, ...extra }).where(and4(eq4(experimentsTable.id, id), eq4(experimentsTable.tenantId, this.ctx.tenantId))).returning();
+    return row ?? null;
+  }
+}
+function parseAllocation(allocationJson) {
+  let raw;
+  try {
+    raw = JSON.parse(allocationJson);
+  } catch {
+    throw new Error(`experiments.allocation_json invalid: not JSON`);
+  }
+  if (!Array.isArray(raw)) {
+    throw new Error("experiments.allocation_json must be array");
+  }
+  const out = [];
+  for (const item of raw) {
+    if (typeof item !== "object" || item === null)
+      continue;
+    const obj = item;
+    const slug = obj.style_slug ?? obj.styleSlug;
+    if (typeof slug !== "string")
+      continue;
+    const weight = typeof obj.weight === "number" && obj.weight > 0 ? obj.weight : 1;
+    out.push({ styleSlug: slug, weight });
+  }
+  if (out.length === 0) {
+    throw new Error("experiments.allocation_json contains no valid entries");
+  }
+  return out;
+}
+// src/dal/leads.ts
+import { leads as leadsTable } from "@chatman-media/storage";
+import { and as and5, eq as eq5 } from "drizzle-orm";
+
+class LeadsRepo {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async byId(id) {
+    const [row] = await this.ctx.db.select().from(leadsTable).where(and5(eq5(leadsTable.id, id), eq5(leadsTable.tenantId, this.ctx.tenantId)));
+    return row ?? null;
+  }
+  async findByContactId(contactId) {
+    const [row] = await this.ctx.db.select().from(leadsTable).where(and5(eq5(leadsTable.tenantId, this.ctx.tenantId), eq5(leadsTable.userId, contactId)));
+    return row ?? null;
+  }
+  async create(opts) {
+    const [row] = await this.ctx.db.insert(leadsTable).values({
+      tenantId: this.ctx.tenantId,
+      userId: opts.contactId,
+      state: opts.state,
+      createdAt: opts.nowEpoch,
+      updatedAt: opts.nowEpoch
+    }).returning();
+    if (!row)
+      throw new Error("leads.create: insert returned no row");
+    return row;
+  }
+  async updateState(leadId, newState, nowEpoch) {
+    await this.ctx.db.update(leadsTable).set({ state: newState, updatedAt: nowEpoch }).where(and5(eq5(leadsTable.id, leadId), eq5(leadsTable.tenantId, this.ctx.tenantId)));
+  }
+}
+// src/dal/messages.ts
+import { messages as messagesTable } from "@chatman-media/storage";
+import { and as and6, desc as desc2, eq as eq6, isNull, sql as sql3 } from "drizzle-orm";
+
+class MessagesRepo {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async insert(opts) {
+    const externalId = opts.externalMessageId !== undefined ? Number(opts.externalMessageId) : null;
+    const [row] = await this.ctx.db.insert(messagesTable).values({
+      tenantId: this.ctx.tenantId,
+      conversationId: opts.conversationId,
+      role: opts.role,
+      text: opts.text,
+      ...externalId !== null && !Number.isNaN(externalId) ? { tgMessageId: externalId } : {},
+      ...opts.metaJson !== undefined ? { metaJson: opts.metaJson } : {},
+      ...opts.stage !== undefined ? { stage: opts.stage } : {},
+      createdAt: opts.nowEpoch
+    }).returning();
+    if (!row)
+      throw new Error("messages.insert: insert returned no row");
+    return row;
+  }
+  async findUserByExternalId(conversationId, externalMessageId) {
+    const num = Number(externalMessageId);
+    if (Number.isNaN(num))
+      return null;
+    const [row] = await this.ctx.db.select().from(messagesTable).where(and6(eq6(messagesTable.tenantId, this.ctx.tenantId), eq6(messagesTable.conversationId, conversationId), eq6(messagesTable.tgMessageId, num), sql3`role = 'user'`));
+    return row ?? null;
+  }
+  async recent(conversationId, limit) {
+    const rows = await this.ctx.db.select().from(messagesTable).where(and6(eq6(messagesTable.tenantId, this.ctx.tenantId), eq6(messagesTable.conversationId, conversationId), isNull(messagesTable.deletedAt), sql3`role <> 'system'`)).orderBy(desc2(messagesTable.createdAt)).limit(limit);
+    return rows.reverse();
+  }
+  async countByConversation(conversationId) {
+    const [row] = await this.ctx.db.select({ count: sql3`COUNT(*)::int` }).from(messagesTable).where(and6(eq6(messagesTable.tenantId, this.ctx.tenantId), eq6(messagesTable.conversationId, conversationId), isNull(messagesTable.deletedAt), sql3`role <> 'system'`));
+    return row?.count ?? 0;
+  }
+}
+// src/dal/outbound.ts
+import { channels, outboundQueue } from "@chatman-media/storage";
+import { and as and7, eq as eq7, sql as sql4 } from "drizzle-orm";
+
+class OutboundQueueRepo {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async enqueue(opts) {
+    const payload = JSON.stringify(opts.envelope);
+    const key = opts.envelope.idempotencyKey ?? null;
+    if (key !== null) {
+      const [existing] = await this.ctx.db.select().from(outboundQueue).where(and7(eq7(outboundQueue.tenantId, this.ctx.tenantId), eq7(outboundQueue.idempotencyKey, key)));
+      if (existing)
+        return existing;
+    }
+    const [row] = await this.ctx.db.insert(outboundQueue).values({
+      tenantId: this.ctx.tenantId,
+      channelId: opts.channelId,
+      ...opts.conversationId !== undefined && opts.conversationId !== null ? { conversationId: opts.conversationId } : {},
+      payloadJson: payload,
+      ...key ? { idempotencyKey: key } : {},
+      scheduledAt: opts.scheduledAt ?? opts.nowEpoch,
+      createdAt: opts.nowEpoch
+    }).returning();
+    if (!row)
+      throw new Error("outbound_queue.enqueue: insert returned no row");
+    return row;
+  }
+  async claimPending(opts) {
+    const kindFilter = opts.kinds && opts.kinds.length > 0 ? sql4`AND ${outboundQueue.channelId} IN (
+            SELECT id FROM ${channels} WHERE ${channels.kind} IN (${sql4.join(opts.kinds.map((k) => sql4`${k}`), sql4`, `)})
+          )` : sql4``;
+    const raw = await this.ctx.db.execute(sql4`
+      UPDATE ${outboundQueue}
+      SET status = 'processing'
+      WHERE id IN (
+        SELECT id FROM ${outboundQueue}
+        WHERE tenant_id = ${this.ctx.tenantId}
+          AND status = 'pending'
+          AND scheduled_at <= ${opts.nowEpoch}
+          ${kindFilter}
+        ORDER BY scheduled_at ASC
+        LIMIT ${opts.limit}
+        FOR UPDATE SKIP LOCKED
+      )
+      RETURNING *
+    `);
+    return raw.map((r) => ({
+      id: r.id,
+      tenantId: r.tenant_id,
+      channelId: r.channel_id,
+      conversationId: r.conversation_id ?? null,
+      payloadJson: r.payload_json,
+      idempotencyKey: r.idempotency_key ?? null,
+      scheduledAt: r.scheduled_at,
+      status: r.status,
+      attempt: r.attempt,
+      lastError: r.last_error ?? null,
+      externalMessageId: r.external_message_id ?? null,
+      sentAt: r.sent_at ?? null,
+      createdAt: r.created_at
+    }));
+  }
+  async releaseStuckProcessing(opts) {
+    const cutoff = opts.nowEpoch - opts.stuckSec;
+    const rows = await this.ctx.db.execute(sql4`
+      UPDATE ${outboundQueue}
+      SET status = 'pending'
+      WHERE tenant_id = ${this.ctx.tenantId}
+        AND status = 'processing'
+        AND scheduled_at < ${cutoff}
+      RETURNING id
+    `);
+    return Array.isArray(rows) ? rows.length : 0;
+  }
+  async markSent(id, externalMessageId, nowEpoch) {
+    await this.ctx.db.update(outboundQueue).set({
+      status: "sent",
+      externalMessageId,
+      sentAt: nowEpoch,
+      attempt: sql4`${outboundQueue.attempt} + 1`
+    }).where(and7(eq7(outboundQueue.id, id), eq7(outboundQueue.tenantId, this.ctx.tenantId)));
+  }
+  async markFailed(id, error) {
+    await this.ctx.db.update(outboundQueue).set({
+      status: "failed",
+      lastError: error,
+      attempt: sql4`${outboundQueue.attempt} + 1`
+    }).where(and7(eq7(outboundQueue.id, id), eq7(outboundQueue.tenantId, this.ctx.tenantId)));
+  }
+}
+// src/dal/skill-outcomes.ts
+import { skillOutcomes as skillOutcomesTable } from "@chatman-media/storage";
+import { and as and8, eq as eq8, sql as sql5 } from "drizzle-orm";
+
+class SkillOutcomesRepo {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async record(opts) {
+    const result = await this.ctx.db.execute(sql5`
+      INSERT INTO skill_outcomes
+        (tenant_id, lead_id, conversation_id, message_id, style_slug,
+         skill_slug, outcome, source, created_at)
+      VALUES
+        (${this.ctx.tenantId}, ${opts.leadId},
+         ${opts.conversationId ?? null}, ${opts.messageId ?? null},
+         ${opts.styleSlug ?? null}, ${opts.skillSlug}, ${opts.outcome},
+         ${opts.source}, ${opts.nowEpoch})
+      ON CONFLICT (lead_id, skill_slug, source) DO NOTHING
+      RETURNING id
+    `);
+    return result.length > 0;
+  }
+  async byLeadId(leadId) {
+    const rows = await this.ctx.db.select().from(skillOutcomesTable).where(and8(eq8(skillOutcomesTable.tenantId, this.ctx.tenantId), eq8(skillOutcomesTable.leadId, leadId)));
+    return rows;
+  }
+  async aggregates() {
+    const rows = await this.ctx.db.execute(sql5`
+      SELECT
+        skill_slug,
+        SUM(CASE WHEN outcome='won' THEN 1 ELSE 0 END)::INTEGER  AS wins,
+        SUM(CASE WHEN outcome='lost' THEN 1 ELSE 0 END)::INTEGER AS losses,
+        SUM(CASE WHEN outcome='draw' THEN 1 ELSE 0 END)::INTEGER AS draws,
+        COUNT(*)::INTEGER AS total
+      FROM skill_outcomes
+      WHERE tenant_id = ${this.ctx.tenantId}
+      GROUP BY skill_slug
+      ORDER BY total DESC
+    `);
+    return rows.map((r) => ({
+      skillSlug: r.skill_slug,
+      wins: r.wins,
+      losses: r.losses,
+      draws: r.draws,
+      total: r.total
+    }));
+  }
+}
+// src/dal/styles.ts
+import { styles as stylesTable } from "@chatman-media/storage";
+import { and as and9, eq as eq9, sql as sql6 } from "drizzle-orm";
+
+class StylesRepo {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async byId(id) {
+    const [row] = await this.ctx.db.select().from(stylesTable).where(and9(eq9(stylesTable.id, id), eq9(stylesTable.tenantId, this.ctx.tenantId)));
+    return row ?? null;
+  }
+  async findActiveBySlug(slug) {
+    const [row] = await this.ctx.db.select().from(stylesTable).where(and9(eq9(stylesTable.tenantId, this.ctx.tenantId), eq9(stylesTable.slug, slug), eq9(stylesTable.isActive, true), sql6`deleted_at IS NULL`));
+    return row ?? null;
+  }
+  async listActive() {
+    const rows = await this.ctx.db.select().from(stylesTable).where(and9(eq9(stylesTable.tenantId, this.ctx.tenantId), eq9(stylesTable.isActive, true), sql6`deleted_at IS NULL`));
+    return rows;
+  }
+  async listAll() {
+    const rows = await this.ctx.db.select().from(stylesTable).where(and9(eq9(stylesTable.tenantId, this.ctx.tenantId), sql6`deleted_at IS NULL`));
+    return rows;
+  }
+  async create(data) {
+    const nowEpoch = Math.floor(Date.now() / 1000);
+    const [row] = await this.ctx.db.insert(stylesTable).values({
+      tenantId: this.ctx.tenantId,
+      slug: data.slug,
+      displayName: data.displayName,
+      configJson: data.configJson,
+      isActive: data.isActive,
+      version: 1,
+      createdAt: nowEpoch
+    }).returning();
+    return row;
+  }
+  async update(id, data) {
+    const [row] = await this.ctx.db.update(stylesTable).set(data).where(and9(eq9(stylesTable.id, id), eq9(stylesTable.tenantId, this.ctx.tenantId), sql6`deleted_at IS NULL`)).returning();
+    return row ?? null;
+  }
+  async softDelete(id) {
+    const nowEpoch = Math.floor(Date.now() / 1000);
+    const rows = await this.ctx.db.update(stylesTable).set({ deletedAt: nowEpoch, isActive: false }).where(and9(eq9(stylesTable.id, id), eq9(stylesTable.tenantId, this.ctx.tenantId), sql6`deleted_at IS NULL`)).returning({ id: stylesTable.id });
+    return rows.length > 0;
+  }
+}
+// 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";
+
+class NotificationsRepo {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async findRulesByEvent(tenantId, eventType) {
+    return this.db.select().from(notificationRules).where(and10(eq10(notificationRules.tenantId, tenantId), eq10(notificationRules.eventType, eventType), eq10(notificationRules.isActive, true)));
+  }
+  async findOperatorSettings(adminId) {
+    const rows = await this.db.select().from(operatorSettings).where(eq10(operatorSettings.adminId, adminId)).limit(1);
+    return rows[0];
+  }
+  async findByLinkToken(token) {
+    const now = Math.floor(Date.now() / 1000);
+    const rows = await this.db.select().from(operatorSettings).where(and10(eq10(operatorSettings.linkToken, token), sql7`${operatorSettings.linkTokenExpiresAt} > ${now}`)).limit(1);
+    return rows[0];
+  }
+  async generateLinkToken(adminId, tenantId) {
+    const token = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+    const expiresAt = Math.floor(Date.now() / 1000) + 3600;
+    await this.db.insert(operatorSettings).values({
+      adminId,
+      tenantId,
+      linkToken: token,
+      linkTokenExpiresAt: expiresAt
+    }).onConflictDoUpdate({
+      target: [operatorSettings.adminId],
+      set: {
+        linkToken: token,
+        linkTokenExpiresAt: expiresAt,
+        updatedAt: Math.floor(Date.now() / 1000)
+      }
+    });
+    return token;
+  }
+  async linkChat(adminId, telegramChatId) {
+    await this.db.update(operatorSettings).set({
+      telegramChatId,
+      linkToken: null,
+      linkTokenExpiresAt: null,
+      updatedAt: Math.floor(Date.now() / 1000)
+    }).where(eq10(operatorSettings.adminId, adminId));
+  }
+  async findOperatorSettingsByTenant(tenantId) {
+    return this.db.select().from(operatorSettings).where(eq10(operatorSettings.tenantId, tenantId));
+  }
+  async partialUpdateSettings(adminId, tenantId, fields) {
+    if (Object.keys(fields).length === 0)
+      return;
+    await this.db.insert(operatorSettings).values({ adminId, tenantId, ...fields }).onConflictDoUpdate({
+      target: [operatorSettings.adminId],
+      set: { ...fields, updatedAt: Math.floor(Date.now() / 1000) }
+    });
+  }
+  async upsertOperatorSettings(settings) {
+    await this.db.insert(operatorSettings).values(settings).onConflictDoUpdate({
+      target: [operatorSettings.adminId],
+      set: {
+        telegramChatId: settings.telegramChatId,
+        notifyOnAssignedOnly: settings.notifyOnAssignedOnly,
+        updatedAt: Math.floor(Date.now() / 1000)
+      }
+    });
+  }
+  async createRule(rule) {
+    const [inserted] = await this.db.insert(notificationRules).values(rule).returning();
+    if (!inserted)
+      throw new Error("notification rule insert returned no row");
+    return inserted;
+  }
+  async listRules(tenantId) {
+    return this.db.select().from(notificationRules).where(eq10(notificationRules.tenantId, tenantId));
+  }
+  async deleteRule(tenantId, id) {
+    await this.db.delete(notificationRules).where(and10(eq10(notificationRules.tenantId, tenantId), eq10(notificationRules.id, id)));
+  }
+  async findTemplate(tenantId, slug) {
+    const rows = await this.db.select().from(notificationTemplates).where(and10(eq10(notificationTemplates.tenantId, tenantId), eq10(notificationTemplates.slug, slug))).limit(1);
+    return rows[0];
+  }
+  async upsertTemplate(tpl) {
+    await this.db.insert(notificationTemplates).values(tpl).onConflictDoUpdate({
+      target: [notificationTemplates.tenantId, notificationTemplates.slug],
+      set: {
+        body: tpl.body,
+        updatedAt: Math.floor(Date.now() / 1000)
+      }
+    });
+  }
+  async listTemplates(tenantId) {
+    return this.db.select().from(notificationTemplates).where(eq10(notificationTemplates.tenantId, tenantId));
+  }
+  async deleteTemplate(tenantId, slug) {
+    await this.db.delete(notificationTemplates).where(and10(eq10(notificationTemplates.tenantId, tenantId), eq10(notificationTemplates.slug, slug)));
+  }
+  async generateGroupLinkToken(tenantId, adminId, eventType) {
+    const token = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+    const expiresAt = Math.floor(Date.now() / 1000) + 3600;
+    await this.db.insert(notificationGroupTokens).values({
+      token,
+      tenantId,
+      adminId,
+      eventType,
+      expiresAt,
+      createdAt: Math.floor(Date.now() / 1000)
+    });
+    return token;
+  }
+  async findGroupLinkToken(token) {
+    const now = Math.floor(Date.now() / 1000);
+    const rows = await this.db.select().from(notificationGroupTokens).where(and10(eq10(notificationGroupTokens.token, token), sql7`${notificationGroupTokens.expiresAt} > ${now}`)).limit(1);
+    return rows[0];
+  }
+  async deleteGroupLinkToken(token) {
+    await this.db.delete(notificationGroupTokens).where(eq10(notificationGroupTokens.token, token));
+  }
+}
+// src/notifications.ts
+import { TelegramClient } from "@chatman-media/channel-telegram";
+
+class NotificationService {
+  repo;
+  botToken;
+  appUrl;
+  client = null;
+  constructor(repo, botToken, appUrl) {
+    this.repo = repo;
+    this.botToken = botToken;
+    this.appUrl = appUrl;
+    if (botToken) {
+      this.client = new TelegramClient({ token: botToken });
+    }
+  }
+  async notify(event) {
+    if (!this.client)
+      return;
+    const [rules, operatorSettingsList] = await Promise.all([
+      this.repo.findRulesByEvent(event.tenantId, event.eventType),
+      this.repo.findOperatorSettingsByTenant(event.tenantId)
+    ]);
+    const template = await this.repo.findTemplate(event.tenantId, event.eventType);
+    const text = template ? this.renderTemplate(template.body, event) : this.formatMessage(event);
+    const buttons = this.formatButtons(event);
+    const matchedRules = rules.filter((rule) => this.matchesCondition(rule, event));
+    for (const rule of matchedRules) {
+      try {
+        await this.sendMessage(rule.targetId, text, buttons);
+      } catch (err) {
+        console.error(`[NotificationService] rule ${rule.id} send failed:`, err);
+      }
+    }
+    for (const settings of operatorSettingsList) {
+      if (!settings.telegramChatId)
+        continue;
+      if (settings.notifyOnAssignedOnly && event.assignedAdminId !== undefined && event.assignedAdminId !== settings.adminId) {
+        continue;
+      }
+      try {
+        await this.sendMessage(settings.telegramChatId, text, buttons);
+      } catch (err) {
+        console.error(`[NotificationService] personal send to admin ${settings.adminId} failed:`, err);
+      }
+    }
+  }
+  async sendTestMessage(chatId) {
+    if (!this.client)
+      return { ok: false, error: "Бот не настроен (нет токена)" };
+    try {
+      await this.client.sendMessage({
+        chatId,
+        text: `\uD83E\uDDEA <b>Тестовое уведомление</b>
+
+Правило активно — сообщения доходят корректно.`,
+        parseMode: "HTML"
+      });
+      return { ok: true };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async sendMessage(chatId, text, buttons) {
+    await this.client.sendMessage({
+      chatId,
+      text,
+      parseMode: "HTML",
+      replyMarkup: buttons ? { inline_keyboard: [buttons] } : undefined
+    });
+  }
+  matchesCondition(rule, event) {
+    if (!rule.conditionJson || rule.conditionJson === "{}")
+      return true;
+    try {
+      const condition = JSON.parse(rule.conditionJson);
+      for (const [key, value] of Object.entries(condition)) {
+        if (event.data[key] !== value)
+          return false;
+      }
+      return true;
+    } catch {
+      return true;
+    }
+  }
+  renderTemplate(body, event) {
+    const vars = {
+      ...event.data,
+      leadId: event.leadId,
+      conversationId: event.conversationId,
+      tenantId: event.tenantId
+    };
+    let result = body;
+    for (const [key, value] of Object.entries(vars)) {
+      result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), String(value ?? ""));
+    }
+    return result.replace(/\{\{.*?\}\}/g, "");
+  }
+  formatMessage(event) {
+    const emoji = this.getEventEmoji(event.eventType);
+    let msg = `${emoji} <b>${this.getEventTitle(event.eventType)}</b>
+
+`;
+    if (event.data.displayName) {
+      msg += `\uD83D\uDC64 <b>Клиент:</b> ${event.data.displayName}
+`;
+    }
+    for (const [key, value] of Object.entries(event.data)) {
+      if (["displayName", "toStage", "fromStage"].includes(key))
+        continue;
+      msg += `\uD83D\uDD39 <b>${this.formatKey(key)}:</b> ${value}
+`;
+    }
+    if (event.data.fromStage && event.data.toStage) {
+      msg += `
+\uD83D\uDD04 <b>Стадия:</b> ${event.data.fromStage} ➡️ ${event.data.toStage}
+`;
+    } else if (event.data.toStage) {
+      msg += `
+\uD83D\uDCCD <b>Стадия:</b> ${event.data.toStage}
+`;
+    }
+    return msg;
+  }
+  formatButtons(event) {
+    if (event.leadId) {
+      return [{ text: "\uD83D\uDC41 Посмотреть", url: `${this.appUrl}/leads/${event.leadId}` }];
+    }
+    if (event.conversationId) {
+      return [{ text: "\uD83D\uDC41 Чат", url: `${this.appUrl}/conversations/${event.conversationId}` }];
+    }
+    return null;
+  }
+  getEventEmoji(type) {
+    const map = {
+      lead_intake_complete: "\uD83C\uDD95",
+      stage_changed: "\uD83D\uDD04",
+      human_takeover: "\uD83C\uDD98",
+      document_uploaded: "\uD83D\uDCF8",
+      high_value_deal: "\uD83D\uDC8E",
+      lead_stale: "⏰"
+    };
+    return map[type] ?? "\uD83D\uDD14";
+  }
+  getEventTitle(type) {
+    const map = {
+      lead_intake_complete: "Новый лид",
+      stage_changed: "Смена стадии",
+      human_takeover: "Нужна помощь оператора",
+      document_uploaded: "Загружен документ",
+      high_value_deal: "Крупная сделка",
+      lead_stale: "Лид завис"
+    };
+    return map[type] ?? "Уведомление";
+  }
+  formatKey(key) {
+    const map = {
+      amount: "Сумма",
+      asset: "Актив",
+      network: "Сеть",
+      phone: "Телефон",
+      email: "Email"
+    };
+    return map[key] ?? key;
+  }
+}
+// src/operator-bot-handler.ts
+import { TelegramClient as TelegramClient2 } from "@chatman-media/channel-telegram";
+
+class OperatorBotHandler {
+  repo;
+  botToken;
+  client = null;
+  constructor(repo, botToken) {
+    this.repo = repo;
+    this.botToken = botToken;
+    if (botToken) {
+      this.client = new TelegramClient2({ token: botToken });
+    }
+  }
+  async handleUpdate(update) {
+    if (!this.client || !update.message)
+      return;
+    const { message } = update;
+    const text = message.text || "";
+    const chatId = String(message.chat.id);
+    if (text.startsWith("/start ")) {
+      const token = text.split(" ")[1];
+      if (token) {
+        await this.handleLinkToken(token, chatId);
+        return;
+      }
+    }
+    if (text.startsWith("/setup ")) {
+      const token = text.split(" ")[1];
+      if (token) {
+        await this.handleGroupLinkToken(token, message.chat.id, message.chat.title || "группа");
+        return;
+      }
+    }
+    if (text === "/setup" || text.startsWith("/setup@")) {
+      await this.handleSetupGroup(message.chat.id, message.chat.title || "эту группу");
+      return;
+    }
+    if (text === "/start") {
+      await this.client.sendMessage({
+        chatId,
+        text: `\uD83D\uDC4B Привет! Я бот-уведомитель для Lead Engine.
+
+Чтобы привязать свой аккаунт, перейдите в Админку -> Настройки уведомлений и нажмите 'Подключить Telegram'.`
+      });
+    }
+  }
+  async handleLinkToken(token, chatId) {
+    if (!this.client)
+      return;
+    const settings = await this.repo.findByLinkToken(token);
+    if (!settings) {
+      await this.client.sendMessage({
+        chatId,
+        text: "❌ Ссылка недействительна или истекла. Пожалуйста, сгенерируйте новую в Админке."
+      });
+      return;
+    }
+    await this.repo.linkChat(settings.adminId, chatId);
+    await this.client.sendMessage({
+      chatId,
+      text: "✅ Аккаунт успешно привязан! Теперь вы будете получать важные уведомления здесь."
+    });
+  }
+  async handleGroupLinkToken(token, chatId, title) {
+    if (!this.client)
+      return;
+    const isGroup = chatId < 0;
+    if (!isGroup) {
+      await this.client.sendMessage({
+        chatId: String(chatId),
+        text: "❌ /setup с токеном работает только в группах. Добавьте бота в группу и отправьте там эту команду."
+      });
+      return;
+    }
+    const groupToken = await this.repo.findGroupLinkToken(token);
+    if (!groupToken) {
+      await this.client.sendMessage({
+        chatId: String(chatId),
+        text: "❌ Токен недействителен или истёк. Сгенерируйте новый в Админке → Уведомления."
+      });
+      return;
+    }
+    await this.repo.createRule({
+      tenantId: groupToken.tenantId,
+      eventType: groupToken.eventType,
+      conditionJson: "{}",
+      channelType: "telegram_group",
+      targetId: String(chatId),
+      priority: "normal",
+      isActive: true
+    });
+    await this.repo.deleteGroupLinkToken(token);
+    await this.client.sendMessage({
+      chatId: String(chatId),
+      text: `✅ Группа <b>${title}</b> подключена к Lead Engine!
+
+Отсюда вы будете получать уведомления о событиях: <b>${groupToken.eventType}</b>.`,
+      parseMode: "HTML"
+    });
+  }
+  async handleSetupGroup(chatId, title) {
+    if (!this.client)
+      return;
+    const isGroup = chatId < 0;
+    if (!isGroup) {
+      await this.client.sendMessage({
+        chatId: String(chatId),
+        text: "команда /setup работает только в группах. Добавьте меня в группу и напишите там /setup."
+      });
+      return;
+    }
+    await this.client.sendMessage({
+      chatId: String(chatId),
+      text: `\uD83C\uDFD7 <b>Настройка группы "${title}"</b>
+
+ID этой группы: <code>${chatId}</code>
+
+Скопируйте этот ID и вставьте его в настройки уведомлений в Админке, чтобы бот мог присылать сюда алерты.`,
+      parseMode: "HTML"
+    });
+  }
+}
+// src/funnel-machine.ts
+class FunnelTransitionError extends Error {
+  fromState;
+  toState;
+  templateSlug;
+  constructor(fromState, toState, templateSlug, reason) {
+    super(`funnel transition rejected: ${fromState} → ${toState} ` + `(template=${templateSlug}, ${reason})`);
+    this.fromState = fromState;
+    this.toState = toState;
+    this.templateSlug = templateSlug;
+    this.name = "FunnelTransitionError";
+  }
+}
+function findStage(template, slug) {
+  return template.funnelStages.find((s) => s.slug === slug);
+}
+function getInitialStage(template) {
+  const first = template.funnelStages[0];
+  if (!first) {
+    throw new Error(`funnel-machine: template "${template.slug}" has no funnelStages`);
+  }
+  return first;
+}
+function validateTransition(template, fromState, toState) {
+  if (fromState === toState)
+    return;
+  const from = findStage(template, fromState);
+  if (!from) {
+    throw new FunnelTransitionError(fromState, toState, template.slug, `from-state not in template`);
+  }
+  const to = findStage(template, toState);
+  if (!to) {
+    throw new FunnelTransitionError(fromState, toState, template.slug, `to-state not in template`);
+  }
+  if (from.kind === "terminal") {
+    throw new FunnelTransitionError(fromState, toState, template.slug, `terminal stage cannot transition`);
+  }
+  if (!from.next || !from.next.includes(toState)) {
+    throw new FunnelTransitionError(fromState, toState, template.slug, `not in from.next [${(from.next ?? []).join(", ")}]`);
+  }
+}
+function allowedTransitions(template, fromState) {
+  const from = findStage(template, fromState);
+  if (!from || from.kind === "terminal")
+    return [];
+  return [...from.next ?? []];
+}
+function isTerminal(template, state) {
+  return findStage(template, state)?.kind === "terminal";
+}
+// src/lead-lifecycle.ts
+async function ensureLead(opts) {
+  const existing = await opts.leads.findByContactId(opts.contactId);
+  if (existing)
+    return { lead: existing, created: false };
+  const created = await opts.leads.create({
+    contactId: opts.contactId,
+    state: getInitialStage(opts.template).slug,
+    nowEpoch: opts.nowEpoch
+  });
+  return { lead: created, created: true };
+}
+async function transitionLeadState(opts) {
+  validateTransition(opts.template, opts.lead.state, opts.toState);
+  if (opts.lead.state === opts.toState) {
+    return opts.lead;
+  }
+  const fromState = opts.lead.state;
+  await opts.leads.updateState(opts.lead.id, opts.toState, opts.nowEpoch);
+  const updated = { ...opts.lead, state: opts.toState, updatedAt: opts.nowEpoch };
+  if (opts.notifications) {
+    await opts.notifications.notify({
+      tenantId: opts.lead.tenantId,
+      eventType: "stage_changed",
+      leadId: opts.lead.id,
+      contactId: opts.lead.userId,
+      assignedAdminId: opts.lead.assignedAdminId ?? undefined,
+      data: {
+        fromStage: fromState,
+        toStage: opts.toState
+      }
+    });
+  }
+  const hook = opts.template.hooks?.onLeadStageChange;
+  if (hook) {
+    const ctx = {
+      tenantId: opts.lead.tenantId,
+      contactId: opts.lead.userId,
+      leadId: opts.lead.id,
+      template: opts.template,
+      ...opts.hookContext
+    };
+    await hook(ctx, fromState, opts.toState);
+  }
+  return updated;
+}
+// src/reply-strategy/rag-reply.ts
+import {
+  answerWithRag,
+  DEFAULT_PERSONA,
+  generateSoftFallback,
+  NO_CONTEXT_MARKER,
+  StyleSchema
+} from "@chatman-media/kb";
+
+// src/compact-conversation.ts
+async function compactConversation(messages, chat) {
+  if (messages.length === 0)
+    return null;
+  const transcript = messages.map((m) => {
+    const role = m.role === "user" ? "Кандидат" : "Бот";
+    return `${role}: ${String(m.content ?? "").trim()}`;
+  }).join(`
+`);
+  const systemPrompt = [
+    "Ты — суммаризатор диалогов продаж.",
+    "Тебе дан фрагмент переписки между ботом и кандидатом.",
+    "Напиши КРАТКОЕ резюме на русском языке — 3-7 пунктов:",
+    "  • Что узнал кандидат (вопросы, интересы).",
+    "  • Что уже выяснено (бюджет, сроки, параметры).",
+    "  • На каком этапе находится диалог.",
+    "  • Любые особые договорённости или отказы.",
+    "",
+    "Формат — маркированный список. Без вводных фраз. Только факты."
+  ].join(`
+`);
+  const raw = await chat.complete([
+    { role: "system", content: systemPrompt },
+    { role: "user", content: `Диалог:
+${transcript}` }
+  ], { temperature: 0, numPredict: 400 });
+  return raw.trim() || null;
+}
+
+// src/reply-strategy/rag-reply.ts
+function messagesToChatHistory(history) {
+  const out = [];
+  for (const m of history) {
+    if (m.role === "user")
+      out.push({ role: "user", content: m.text });
+    else if (m.role === "assistant" || m.role === "human")
+      out.push({ role: "assistant", content: m.text });
+  }
+  return out;
+}
+function parseStyleConfig(configJson) {
+  try {
+    const raw = JSON.parse(configJson);
+    return StyleSchema.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+class RagReplyStrategy {
+  opts;
+  messagesRepoFor;
+  constructor(opts, messagesRepoFor) {
+    this.opts = opts;
+    this.messagesRepoFor = messagesRepoFor;
+  }
+  async generate(input) {
+    if (input.userMessageText.length === 0)
+      return null;
+    const tenantId = input.tenant.tenantId;
+    if (this.opts.resolveIsSupport) {
+      const isSupport = await this.opts.resolveIsSupport({ tenantId, contactId: input.contactId });
+      if (isSupport)
+        return null;
+    }
+    const messagesRepo = this.messagesRepoFor(tenantId);
+    const chat = this.opts.resolveChat(tenantId);
+    const compactThreshold = this.opts.compactAfterMessages ?? 20;
+    let conversationSummary;
+    const [allRecent, totalCount] = await Promise.all([
+      messagesRepo.recent(input.conversationId, (this.opts.historyLimit ?? 12) + 1),
+      compactThreshold > 0 ? messagesRepo.countByConversation(input.conversationId) : Promise.resolve(0)
+    ]);
+    if (compactThreshold > 0 && totalCount >= compactThreshold) {
+      const convsRepo = this.opts.resolveConversations?.(tenantId);
+      const convo = convsRepo ? await convsRepo.findById(input.conversationId) : null;
+      if (convo?.summaryJson) {
+        try {
+          conversationSummary = JSON.parse(convo.summaryJson);
+        } catch {
+          conversationSummary = convo.summaryJson;
+        }
+      }
+      const shouldRecompact = !conversationSummary || totalCount % compactThreshold === 0;
+      if (shouldRecompact) {
+        const chatHistory = messagesToChatHistory(allRecent);
+        const freshSummary = await compactConversation(chatHistory, chat).catch((err) => {
+          console.warn("[rag-reply] compaction failed:", err);
+          return null;
+        });
+        if (freshSummary) {
+          conversationSummary = freshSummary;
+          convsRepo?.setSummaryJson(input.conversationId, JSON.stringify(freshSummary)).catch((err) => console.warn("[rag-reply] failed to save summary:", err));
+        }
+      }
+    }
+    const historyWithoutCurrent = allRecent.filter((m) => m.text !== input.userMessageText);
+    const history = messagesToChatHistory(historyWithoutCurrent);
+    const embedder = this.opts.resolveEmbed(tenantId);
+    const kb = this.opts.resolveKb(tenantId);
+    const style = this.opts.resolveStyle ? await this.opts.resolveStyle({
+      tenantId,
+      conversationId: input.conversationId,
+      contactId: input.contactId
+    }) : null;
+    const [skills, directorHooks, tools, reranker] = await Promise.all([
+      this.opts.resolveSkills ? this.opts.resolveSkills({ tenantId }) : Promise.resolve([]),
+      this.opts.resolveDirectorHooks ? this.opts.resolveDirectorHooks({ tenantId }) : Promise.resolve([]),
+      this.opts.resolveTools ? this.opts.resolveTools({ tenantId, conversationId: input.conversationId }) : Promise.resolve([]),
+      this.opts.resolveReranker ? this.opts.resolveReranker({ tenantId }) : Promise.resolve(null)
+    ]);
+    const result = await answerWithRag({
+      question: input.userMessageText,
+      kb,
+      embedder,
+      chat,
+      history,
+      topK: this.opts.topK ?? 5,
+      hybridSearch: this.opts.hybridSearch ?? true,
+      rewriteQueryBeforeRetrieval: this.opts.rewriteQueryBeforeRetrieval ?? true,
+      reflect: this.opts.reflect ?? false,
+      numPredict: this.opts.maxOutputTokens ?? 600,
+      ...style ? { style } : {},
+      ...skills.length > 0 ? { skills } : {},
+      ...directorHooks.length > 0 ? { directorHooks } : {},
+      ...tools.length > 0 ? { tools } : {},
+      ...reranker ? { reranker } : {},
+      ...conversationSummary ? { conversationSummary } : {}
+    });
+    if (result.text === NO_CONTEXT_MARKER || !result.text || result.text.trim().length === 0) {
+      if (this.opts.resolveSuggestions) {
+        const suggestionsRepo = this.opts.resolveSuggestions(tenantId);
+        const nowEpoch = Math.floor(Date.now() / 1000);
+        suggestionsRepo.log({
+          questionText: input.userMessageText,
+          sourceConversationId: input.conversationId,
+          nowEpoch
+        }).catch((err) => {
+          console.warn("[rag-reply] failed to log kb_suggestion:", err);
+        });
+      }
+      if (!this.opts.softFallback)
+        return null;
+      const persona = style ? {
+        name: style.persona.name,
+        role: style.persona.role,
+        ...style.persona.company?.trim() ? { company: style.persona.company.trim() } : {}
+      } : DEFAULT_PERSONA;
+      const fallbackText = await generateSoftFallback({
+        question: input.userMessageText,
+        chat,
+        persona,
+        history
+      });
+      if (!fallbackText || fallbackText.trim().length === 0)
+        return null;
+      return [
+        {
+          channelId: String(input.channel.channelId),
+          externalUserId: input.inbound.externalUserId,
+          parts: [{ kind: "text", text: fallbackText }]
+        }
+      ];
+    }
+    return [
+      {
+        channelId: String(input.channel.channelId),
+        externalUserId: input.inbound.externalUserId,
+        parts: [{ kind: "text", text: result.text }]
+      }
+    ];
+  }
+}
+
+// src/experiment-router.ts
+async function loadExperimentVariants(experiment, stylesRepo) {
+  const entries = parseAllocation(experiment.allocationJson);
+  const variants = [];
+  for (const entry of entries) {
+    const row = await stylesRepo.findActiveBySlug(entry.styleSlug);
+    if (!row) {
+      console.warn(`[experiment-router] experiment=${experiment.slug}: style=${entry.styleSlug} not found, skipping`);
+      continue;
+    }
+    const style = parseStyleConfig(row.configJson);
+    if (!style) {
+      console.warn(`[experiment-router] experiment=${experiment.slug}: style=${entry.styleSlug} invalid config_json, skipping`);
+      continue;
+    }
+    variants.push({ style, weight: entry.weight });
+  }
+  if (variants.length === 0)
+    return null;
+  return variants;
+}
+// src/memory-extractor.ts
+import { extractUserFacts } from "@chatman-media/kb";
+
+class LlmMemoryExtractor {
+  opts;
+  messagesRepoFor;
+  constructor(opts, messagesRepoFor) {
+    this.opts = opts;
+    this.messagesRepoFor = messagesRepoFor;
+  }
+  async extract(input) {
+    const messagesRepo = this.messagesRepoFor(input.tenantId);
+    const history = await messagesRepo.recent(input.conversationId, this.opts.historyLimit ?? 10);
+    if (history.length === 0)
+      return {};
+    const llmMessages = mapToRagMessages(history);
+    if (llmMessages.length === 0)
+      return {};
+    const chat = this.opts.resolveChat(input.tenantId);
+    return extractUserFacts({
+      messages: llmMessages,
+      chat,
+      existingFacts: input.existingFacts
+    });
+  }
+}
+function mapToRagMessages(history) {
+  const out = [];
+  for (const m of history) {
+    if (m.role === "user")
+      out.push({ role: "user", content: m.text });
+    else if (m.role === "assistant" || m.role === "human")
+      out.push({ role: "assistant", content: m.text });
+  }
+  return out;
+}
+async function runMemoryExtraction(opts) {
+  const contact = await opts.contacts.byId(opts.contactId);
+  if (!contact)
+    return {};
+  const existing = {};
+  if (contact.attributesJson) {
+    const parsed = JSON.parse(contact.attributesJson);
+    for (const [k, v] of Object.entries(parsed)) {
+      if (typeof v === "string")
+        existing[k] = v;
+    }
+  }
+  const newFacts = await opts.extractor.extract({
+    tenantId: opts.tenantId,
+    conversationId: opts.conversationId,
+    contactId: opts.contactId,
+    existingFacts: existing
+  });
+  if (Object.keys(newFacts).length > 0) {
+    await opts.contacts.mergeAttributes(opts.contactId, newFacts, opts.nowEpoch);
+  }
+  return newFacts;
+}
+// src/stage-classifier.ts
+import { conversations as conversationsTable2 } from "@chatman-media/storage";
+import { and as and11, eq as eq11 } 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)));
+  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)));
+  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";
+var ALGORITHM = "aes-256-gcm";
+var IV_LEN = 12;
+var AUTH_TAG_LEN = 16;
+
+class SecretCryptoError extends Error {
+  constructor(reason) {
+    super(`SecretCrypto: ${reason}`);
+    this.name = "SecretCryptoError";
+  }
+}
+function masterKeyBytes(masterKeyHex) {
+  if (!/^[0-9a-fA-F]+$/.test(masterKeyHex)) {
+    throw new SecretCryptoError("master key must be hex");
+  }
+  const buf = Buffer.from(masterKeyHex, "hex");
+  if (buf.length !== 32) {
+    throw new SecretCryptoError(`master key must be 32 bytes (64 hex chars), got ${buf.length}`);
+  }
+  return buf;
+}
+function encryptSecret(masterKeyHex, plaintext) {
+  const key = masterKeyBytes(masterKeyHex);
+  const iv = randomBytes(IV_LEN);
+  const cipher = createCipheriv(ALGORITHM, key, iv);
+  const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+  if (authTag.length !== AUTH_TAG_LEN) {
+    throw new SecretCryptoError(`unexpected auth tag length ${authTag.length}`);
+  }
+  return [
+    iv.toString("base64"),
+    authTag.toString("base64"),
+    encrypted.toString("base64")
+  ].join(":");
+}
+function decryptSecret(masterKeyHex, ciphertext) {
+  const key = masterKeyBytes(masterKeyHex);
+  const parts = ciphertext.split(":");
+  if (parts.length !== 3) {
+    throw new SecretCryptoError("ciphertext format must be iv:tag:payload");
+  }
+  const [ivB64, tagB64, payloadB64] = parts;
+  const iv = Buffer.from(ivB64, "base64");
+  const authTag = Buffer.from(tagB64, "base64");
+  const payload = Buffer.from(payloadB64, "base64");
+  if (iv.length !== IV_LEN)
+    throw new SecretCryptoError("bad iv length");
+  if (authTag.length !== AUTH_TAG_LEN)
+    throw new SecretCryptoError("bad auth tag length");
+  const decipher = createDecipheriv(ALGORITHM, key, iv);
+  decipher.setAuthTag(authTag);
+  try {
+    const decrypted = Buffer.concat([decipher.update(payload), decipher.final()]);
+    return decrypted.toString("utf8");
+  } catch {
+    throw new SecretCryptoError("auth tag mismatch or corrupted 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)));
+  if (!row)
+    return null;
+  return decryptSecret(opts.masterKeyHex, row.encryptedValue);
+}
+async function setEncryptedSecret(opts) {
+  const enc = encryptSecret(opts.masterKeyHex, opts.value);
+  await opts.db.insert(tenantSecrets).values({
+    tenantId: opts.tenantId,
+    key: opts.key,
+    encryptedValue: enc,
+    createdAt: opts.nowEpoch,
+    updatedAt: opts.nowEpoch
+  }).onConflictDoUpdate({
+    target: [tenantSecrets.tenantId, tenantSecrets.key],
+    set: { encryptedValue: enc, updatedAt: opts.nowEpoch }
+  });
+}
+// src/outbound-dispatch.ts
+async function dispatchOutbound(opts) {
+  return opts.outbound.enqueue({
+    channelId: opts.channelDbId,
+    conversationId: opts.conversationId,
+    envelope: opts.envelope,
+    nowEpoch: opts.nowEpoch
+  });
+}
+
+// src/types.ts
+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;
+  const { result, replyStrategy, inbound, tenant, channel, channelDbId } = deps;
+  if (result.mediaOnly) {
+    return { outboundEnqueued: 0 };
+  }
+  const text = result.userMessageText ?? "";
+  if (text.length === 0)
+    return { outboundEnqueued: 0 };
+  const envelopes = await replyStrategy.generate({
+    tenant,
+    channel,
+    conversationId: result.conversationId,
+    contactId: result.contactId,
+    inbound,
+    userMessageText: text
+  });
+  if (!envelopes || envelopes.length === 0) {
+    return { outboundEnqueued: 0 };
+  }
+  const now = clock.nowEpoch();
+  let count = 0;
+  await withTenant(deps.db, tenant.tenantId, async (tx) => {
+    const outbound = new OutboundQueueRepo({ db: tx, tenantId: tenant.tenantId });
+    for (const env of envelopes) {
+      const queued = await dispatchOutbound({
+        channelDbId,
+        conversationId: result.conversationId,
+        envelope: env,
+        outbound,
+        nowEpoch: now
+      });
+      count += 1;
+      deps.sink?.emit?.({
+        type: "outbound-enqueued",
+        tenantId: tenant.tenantId,
+        conversationId: result.conversationId,
+        queueItemId: queued.id,
+        envelope: env
+      });
+    }
+  });
+  return { outboundEnqueued: count };
+}
+// src/process-inbound.ts
+function inboundText(inbound) {
+  const textParts = [];
+  let hasMedia = false;
+  for (const part of inbound.parts) {
+    if (part.kind === "text")
+      textParts.push(part.text);
+    else if ("caption" in part && part.caption)
+      textParts.push(part.caption);
+    if (part.kind !== "text" && part.kind !== "callback_query")
+      hasMedia = true;
+  }
+  const text = textParts.join(`
+`).trim();
+  return { text, mediaOnly: hasMedia && text.length === 0 };
+}
+async function processInbound(inbound, deps) {
+  const clock = deps.clock ?? systemClock;
+  const now = clock.nowEpoch();
+  deps.sink?.log?.("info", "inbound received", {
+    tenantId: deps.tenant.tenantId,
+    channelId: deps.channel.channelId,
+    externalUserId: inbound.externalUserId,
+    parts: inbound.parts.length
+  });
+  const contact = await resolveContact({
+    inbound,
+    channelDbId: deps.channelDbId,
+    contacts: deps.contacts,
+    identities: deps.identities
+  });
+  const { conversation, created: conversationCreated } = await resolveConversation({
+    contactId: contact.id,
+    channelKind: deps.channel.kind,
+    conversations: deps.conversations,
+    nowEpoch: now
+  });
+  deps.sink?.emit?.({
+    type: "inbound-received",
+    tenantId: deps.tenant.tenantId,
+    conversationId: conversation.id,
+    inbound
+  });
+  if (deps.transcriber && deps.downloadVoice) {
+    for (const part of inbound.parts) {
+      if (part.kind === "voice") {
+        try {
+          const res = await deps.downloadVoice(part.mediaRef, inbound.externalUserId);
+          if (res.ok) {
+            const buf = await res.arrayBuffer();
+            const transcript = await deps.transcriber.transcribe(new Uint8Array(buf), "voice.ogg");
+            if (transcript) {
+              const idx = inbound.parts.indexOf(part);
+              inbound.parts[idx] = {
+                kind: "text",
+                text: transcript
+              };
+            }
+          }
+        } catch (err) {
+          deps.sink?.log?.("warn", "voice transcription failed", {
+            tenantId: deps.tenant.tenantId,
+            error: err.message
+          });
+        }
+      }
+    }
+  }
+  const { text, mediaOnly } = inboundText(inbound);
+  const isCallback = inbound.parts.some((p) => p.kind === "callback_query");
+  if (isCallback) {
+    return {
+      contactId: contact.id,
+      conversationId: conversation.id,
+      persisted: false,
+      outboundEnqueued: 0
+    };
+  }
+  const existingMsg = await deps.messages.findUserByExternalId(conversation.id, inbound.externalMessageId);
+  let messageId;
+  if (existingMsg) {
+    deps.sink?.log?.("debug", "inbound dedup hit", {
+      conversationId: conversation.id,
+      externalMessageId: inbound.externalMessageId
+    });
+    messageId = existingMsg.id;
+  } else {
+    const inserted = await deps.messages.insert({
+      conversationId: conversation.id,
+      role: "user",
+      text,
+      externalMessageId: inbound.externalMessageId,
+      ...inbound.parts.some((p) => p.kind !== "text") ? { metaJson: JSON.stringify({ parts: inbound.parts }) } : {},
+      nowEpoch: now
+    });
+    messageId = inserted.id;
+    deps.sink?.emit?.({
+      type: "message-persisted",
+      tenantId: deps.tenant.tenantId,
+      conversationId: conversation.id,
+      messageId: inserted.id,
+      role: "user"
+    });
+  }
+  if (!existingMsg) {
+    await deps.conversations.updateInboxMetadata(conversation.id, {
+      lastMessageAt: now,
+      lastMessageText: text.slice(0, 200) || "(Медиа)",
+      incrementUnread: true,
+      ...conversation.status === "resolved" ? { status: "open" } : {}
+    });
+  }
+  const hasMedia = inbound.parts.some((p) => p.kind !== "text" && p.kind !== "callback_query");
+  const hasVideoNote = inbound.parts.some((p) => p.kind === "video_note");
+  if (deps.notifications && !existingMsg) {
+    if (conversation.mode === "human" || conversation.mode === "queued") {
+      await deps.notifications.notify({
+        tenantId: deps.tenant.tenantId,
+        eventType: "human_takeover",
+        conversationId: conversation.id,
+        contactId: contact.id,
+        data: {
+          displayName: contact.displayName || "Без имени",
+          text: text || "(Медиа)"
+        }
+      });
+    } else if (hasVideoNote) {
+      await deps.notifications.notify({
+        tenantId: deps.tenant.tenantId,
+        eventType: "verification_requested",
+        conversationId: conversation.id,
+        contactId: contact.id,
+        data: {
+          displayName: contact.displayName || "Без имени",
+          text: text || "(Видео-кружок для верификации)"
+        }
+      });
+    } else if (hasMedia) {
+      await deps.notifications.notify({
+        tenantId: deps.tenant.tenantId,
+        eventType: "document_uploaded",
+        conversationId: conversation.id,
+        contactId: contact.id,
+        data: {
+          displayName: contact.displayName || "Без имени"
+        }
+      });
+    }
+  }
+  if (deps.template?.hooks?.extractFields && !existingMsg && text.length > 0) {
+    try {
+      const extracted = await deps.template.hooks.extractFields({ tenantId: deps.tenant.tenantId, contactId: contact.id, conversationId: conversation.id }, text);
+      if (extracted && Object.keys(extracted).length > 0) {
+        await deps.contacts.mergeAttributes(contact.id, extracted, now);
+      }
+    } catch (err) {
+      deps.sink?.log?.("warn", "extractFields hook failed", {
+        tenantId: deps.tenant.tenantId,
+        conversationId: conversation.id,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  if (deps.stageClassifier && deps.db && !existingMsg && text.length > 0) {
+    try {
+      const newStage = await deps.stageClassifier.classify({
+        tenantId: deps.tenant.tenantId,
+        userMessageText: text,
+        previousStage: conversation.currentStage,
+        isFirstUserMessage: conversationCreated
+      });
+      const changed = await applyClassifiedStage({
+        db: deps.db,
+        tenantId: deps.tenant.tenantId,
+        conversationId: conversation.id,
+        newStage
+      });
+      if (changed) {
+        deps.sink?.log?.("debug", "conversation stage classified", {
+          tenantId: deps.tenant.tenantId,
+          conversationId: conversation.id,
+          from: conversation.currentStage,
+          to: newStage
+        });
+      }
+    } catch (err) {
+      deps.sink?.log?.("warn", "stage classifier failed", {
+        tenantId: deps.tenant.tenantId,
+        conversationId: conversation.id,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  if (deps.memoryExtractor && !existingMsg && text.length > 0) {
+    try {
+      const extracted = await runMemoryExtraction({
+        extractor: deps.memoryExtractor,
+        tenantId: deps.tenant.tenantId,
+        conversationId: conversation.id,
+        contactId: contact.id,
+        contacts: deps.contacts,
+        nowEpoch: now
+      });
+      if (Object.keys(extracted).length > 0) {
+        deps.sink?.log?.("debug", "memory facts extracted", {
+          tenantId: deps.tenant.tenantId,
+          conversationId: conversation.id,
+          keys: Object.keys(extracted)
+        });
+      }
+    } catch (err) {
+      deps.sink?.log?.("warn", "memory extractor failed", {
+        tenantId: deps.tenant.tenantId,
+        conversationId: conversation.id,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  if (deps.deferReply) {
+    return {
+      contactId: contact.id,
+      conversationId: conversation.id,
+      persisted: !existingMsg,
+      outboundEnqueued: 0,
+      userMessageText: text,
+      mediaOnly,
+      replyDeferred: true
+    };
+  }
+  let outboundCount = 0;
+  if (conversation.mode === "ai" && deps.reply && !mediaOnly) {
+    const envelopes = await deps.reply.generate({
+      tenant: deps.tenant,
+      channel: deps.channel,
+      conversationId: conversation.id,
+      contactId: contact.id,
+      inbound,
+      userMessageText: text
+    });
+    if (envelopes && envelopes.length > 0) {
+      const lastEnv = envelopes[envelopes.length - 1];
+      if (lastEnv) {
+        const aiText = lastEnv.parts.find((p) => p.kind === "text")?.text;
+        if (aiText) {
+          await deps.conversations.updateInboxMetadata(conversation.id, {
+            lastMessageText: aiText.slice(0, 200)
+          });
+        }
+      }
+      for (const env of envelopes) {
+        const queued = await dispatchOutbound({
+          channelDbId: deps.channelDbId,
+          conversationId: conversation.id,
+          envelope: env,
+          outbound: deps.outbound,
+          nowEpoch: now
+        });
+        outboundCount += 1;
+        deps.sink?.emit?.({
+          type: "outbound-enqueued",
+          tenantId: deps.tenant.tenantId,
+          conversationId: conversation.id,
+          queueItemId: queued.id,
+          envelope: env
+        });
+      }
+    }
+  }
+  return {
+    contactId: contact.id,
+    conversationId: conversation.id,
+    persisted: !existingMsg,
+    outboundEnqueued: outboundCount
+  };
+}
+// src/reply-strategy/llm-reply.ts
+var BASE_SYSTEM_PROMPT = "Ты — операционный бот платформы lead-engine. Отвечай кратко, " + "уважительно, по делу. Никогда не выдумывай факты которых нет в " + "контексте — лучше скажи «уточню у партнёра» и поставь сообщение в очередь оператора.";
+function messagesToChatHistory2(history) {
+  const out = [];
+  for (const m of history) {
+    if (m.role === "user")
+      out.push({ role: "user", content: m.text });
+    else if (m.role === "assistant" || m.role === "human")
+      out.push({ role: "assistant", content: m.text });
+  }
+  return out;
+}
+
+class LlmReplyStrategy {
+  opts;
+  messagesRepoFor;
+  constructor(opts, messagesRepoFor) {
+    this.opts = opts;
+    this.messagesRepoFor = messagesRepoFor;
+  }
+  async generate(input) {
+    if (input.userMessageText.length === 0)
+      return null;
+    if (this.opts.resolveIsSupport) {
+      const isSupport = await this.opts.resolveIsSupport({
+        tenantId: input.tenant.tenantId,
+        contactId: input.contactId
+      });
+      if (isSupport)
+        return null;
+    }
+    const messages = this.messagesRepoFor(input.tenant.tenantId);
+    const history = await messages.recent(input.conversationId, this.opts.historyLimit ?? 20);
+    const historyMessages = messagesToChatHistory2(history);
+    const systemPrompt = [BASE_SYSTEM_PROMPT, this.opts.template.systemPromptFragment].filter(Boolean).join(`
+
+`);
+    const chat = this.opts.resolveChat(input.tenant.tenantId);
+    const reply = await chat.complete([{ role: "system", content: systemPrompt }, ...historyMessages], {
+      temperature: this.opts.temperature ?? 0.7,
+      numPredict: this.opts.maxOutputTokens ?? 600
+    });
+    if (reply.trim().length === 0)
+      return null;
+    return [
+      {
+        channelId: String(input.channel.channelId),
+        externalUserId: input.inbound.externalUserId,
+        parts: [{ kind: "text", text: reply }]
+      }
+    ];
+  }
+}
+// src/rls-guard.ts
+import { sql as sql10 } from "drizzle-orm";
+async function checkRlsEnforcement(db) {
+  const rows = await db.execute(sql10`
+    SELECT current_user::text AS role,
+           rolsuper            AS issuper,
+           rolbypassrls        AS hasbypassrls
+    FROM pg_roles
+    WHERE rolname = current_user
+  `);
+  const r = rows[0];
+  if (!r) {
+    return {
+      role: "<unknown>",
+      isSuperuser: false,
+      hasBypassRls: false,
+      isEnforced: false
+    };
+  }
+  return {
+    role: r.role,
+    isSuperuser: Boolean(r.issuper),
+    hasBypassRls: Boolean(r.hasbypassrls),
+    isEnforced: !r.issuper && !r.hasbypassrls
+  };
+}
+export {
+  withTenant,
+  validateTransition,
+  transitionLeadState,
+  systemClock,
+  setEncryptedSecret,
+  runMemoryExtraction,
+  resolveConversation,
+  resolveContact,
+  processInbound,
+  parseStyleConfig,
+  parseAllocation,
+  loadExperimentVariants,
+  isTerminal,
+  getInitialStage,
+  getDecryptedSecret,
+  generateReplyAndEnqueue,
+  ensureLead,
+  encryptSecret,
+  dispatchOutbound,
+  decryptSecret,
+  compactConversation,
+  checkRlsEnforcement,
+  applyClassifiedStage,
+  allowedTransitions,
+  StylesRepo,
+  SkillOutcomesRepo,
+  SecretCryptoError,
+  RagReplyStrategy,
+  OutboundQueueRepo,
+  OperatorBotHandler,
+  NotificationsRepo,
+  NotificationService,
+  MessagesRepo,
+  LlmReplyStrategy,
+  LlmMemoryExtractor,
+  LeadsRepo,
+  KbSuggestionsRepo,
+  FunnelTransitionError,
+  ExperimentsRepo,
+  DrizzleKbStore,
+  ConversationsRepo,
+  ContactsRepo,
+  ChannelIdentitiesRepo
+};