abs-zalo-bot 0.2.0

package/src/ops_report.js

@@ -0,0 +1,135 @@
+// Executive Zalo report format for managers — not technical logs.
+// Never invent operational depth when message history is thin.
+
+function num(n) {
+  return Number(n || 0).toLocaleString("vi-VN");
+}
+
+function cleanLine(s, max = 100) {
+  return String(s || "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, max);
+}
+
+/**
+ * Build one professional ops message for the configured destination.
+ * @param {object} p
+ * @param {string} [p.title]
+ * @param {string} [p.windowLabel] e.g. "24 giờ"
+ * @param {object} p.stats { groups, users, member_links, messages_total, recent_source_msgs }
+ * @param {Array}  [p.recentEvents] source messages (not destination)
+ * @param {boolean} [p.autoReplyEnabled]
+ * @param {boolean} [p.listening]
+ * @param {string}  [p.note]
+ */
+export function buildOpsReport({
+  title = "Tổng hợp vận hành — destination đã cấu hình",
+  windowLabel = "24 giờ",
+  stats = {},
+  recentEvents = [],
+  autoReplyEnabled = false,
+  listening = true,
+  note = "",
+} = {}) {
+  const groups = stats.groups ?? stats.sources ?? 0;
+  const users = stats.users ?? 0;
+  const links = stats.member_links ?? 0;
+  const msgs = stats.messages_total ?? stats.messages ?? 0;
+  const recent = stats.recent_source_msgs ?? recentEvents.length;
+
+  const statusParts = [];
+  statusParts.push(
+    listening
+      ? "Hệ thống đang theo dõi bình thường"
+      : "Hệ thống chưa theo dõi tin mới"
+  );
+  statusParts.push(
+    autoReplyEnabled
+      ? "trả lời tự động đang bật"
+      : "chưa bật trả lời tự động"
+  );
+
+  const lines = [];
+  lines.push(title);
+  lines.push("");
+  lines.push("Trạng thái:");
+  lines.push(statusParts.join(", ") + ".");
+  lines.push("");
+  lines.push("Số liệu hiện có:");
+  lines.push(`${num(groups)} nhóm đã ghi nhận`);
+  lines.push(`${num(users)} người dùng`);
+  lines.push(`${num(links)} liên kết thành viên-nhóm`);
+  lines.push(`${num(msgs)} tin nhắn đã lưu`);
+  lines.push("");
+  lines.push("Hoạt động gần đây:");
+
+  if (recent > 0 && recentEvents.length) {
+    lines.push(`Có ${num(recent)} tin từ nhóm nguồn trong ${windowLabel}.`);
+    const bySource = new Map();
+    for (const e of recentEvents.slice(0, 40)) {
+      const name = e.source_name || e.source_id || "nhóm";
+      bySource.set(name, (bySource.get(name) || 0) + 1);
+    }
+    const top = [...bySource.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 5);
+    for (const [name, count] of top) {
+      lines.push(`• ${cleanLine(name, 60)}: ${count} tin`);
+    }
+    // Only surface issues when we actually have message text.
+    const samples = recentEvents
+      .map((e) => cleanLine(e.text, 90))
+      .filter(Boolean)
+      .slice(0, 3);
+    if (samples.length) {
+      lines.push("Ghi nhận gần đây:");
+      for (const s of samples) lines.push(`- ${s}`);
+    }
+  } else if (recent > 0) {
+    lines.push(`Có ${num(recent)} tin từ nhóm nguồn trong ${windowLabel}.`);
+  } else {
+    lines.push(`Chưa ghi nhận thêm tin mới trong ${windowLabel} qua.`);
+  }
+
+  lines.push("");
+  lines.push("Nhận xét:");
+  if (msgs < 10) {
+    lines.push(
+      "Dữ liệu nhóm và thành viên đã đủ để map vận hành ban đầu. Lịch sử tin nhắn cũ còn hạn chế, nên phần tổng hợp nội dung hiện chưa sâu."
+    );
+  } else if (recent === 0) {
+    lines.push(
+      "Đã có kho tin nhắn tích lũy, nhưng cửa sổ gần đây yên. Chưa đủ tín hiệu để đánh giá xu hướng vận hành."
+    );
+  } else {
+    lines.push(
+      "Đã có tín hiệu tin gần đây. Có thể theo dõi vấn đề nổi bật và việc cần follow-up khi số lượng tin đủ dày hơn."
+    );
+  }
+  if (note) lines.push(cleanLine(note, 220));
+
+  lines.push("");
+  lines.push("Việc tiếp theo:");
+  if (msgs < 10) {
+    lines.push(
+      "Tiếp tục theo dõi tin mới realtime. Khi dữ liệu đủ hơn, báo cáo sẽ đánh giá được xu hướng, vấn đề nổi bật và việc cần xử lý."
+    );
+  } else {
+    lines.push(
+      "Giữ theo dõi tin mới. Ưu tiên các nhóm có nhiều tin bất thường hoặc cần follow-up."
+    );
+  }
+
+  // Hard cap for Zalo single message readability.
+  return lines.join("\n").slice(0, 3200);
+}
+
+/** Strip leftover technical jargon if an upstream model returns it. */
+export function scrubTechJargon(text) {
+  return String(text || "")
+    .replace(/\b(corpus|digest|outbound|READ_ONLY(?:_SOURCE)?|bridge|ask_reply|event_id)\b/gi, "")
+    .replace(/[ \t]{2,}/g, " ")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}

package/src/policy.js

@@ -0,0 +1,320 @@
+// Policy Guard — hard READ_ONLY_SOURCE for shared personal Zalo.
+// Phase 1 inbound brain: destination + owner + "bot ..." prefix only.
+import { SOURCE_MODES, sha256 } from "./schema.js";
+import { containsSecretPattern } from "./privacy.js";
+import { isBotCommand } from "./inbound_router.js";
+
+const ROLE_ORDER = ["viewer", "operator", "admin", "owner"];
+
+const COMMAND_MIN_ROLE = {
+  status: "viewer",
+  help: "viewer",
+  whoami: "viewer",
+  digest: "operator",
+  pause: "admin",
+  resume: "admin",
+  set: "admin",
+  allow: "admin",
+  mode: "admin",
+  mute: "admin",
+  add: "owner",
+  remove: "owner",
+};
+
+// Bot/report fingerprints — never re-ingest as asks.
+const BOT_REPORT_HINT =
+  /^(Tổng hợp (?:hôm nay|vận hành)\s*[—\-–]|Cảnh báo —|Zalo Intelligence Digest|Zalo Bridge digest|Phản hồi on-demand|Tóm tắt \(|DRAFT —|account=|status=|paused=|global_kill=|Trạng thái:)/i
+
+export class PolicyGuard {
+  constructor({ config, store }) {
+    this.config = config;
+    this.store = store;
+    this.ingestPerHour = Number(config.rate_limit?.ingest_per_hour || 2000);
+    this.alertCooldownMinutes = Number(config.rate_limit?.alert_cooldown_minutes || 30);
+    this.destPerHour = Number(config.rate_limit?.destination_per_hour || 30);
+  }
+
+  get readOnlySource() {
+    if (this.config.read_only_source === false) return false;
+    return true;
+  }
+
+  roleOf(accountId, userId) {
+    return this.store.roleOf(accountId, userId) || null;
+  }
+
+  requireRole(accountId, userId, minRole) {
+    const role = this.roleOf(accountId, userId);
+    if (!role) return false;
+    return ROLE_ORDER.indexOf(role) >= ROLE_ORDER.indexOf(minRole);
+  }
+
+  getSourcePolicy(accountId, sourceId) {
+    const row = this.store.getSource(accountId, sourceId);
+    if (!row || !row.is_allowed || row.mode === "off") return null;
+    return {
+      account_id: row.account_id,
+      source_id: row.source_id,
+      source_type: row.source_type,
+      source_name: row.source_name,
+      mode: row.mode,
+      muted: Boolean(row.muted),
+    };
+  }
+
+  safetyFlags() {
+    const dest = this.store.getDestination(this.config.default_account_id);
+    return {
+      READ_ONLY_SOURCE: this.readOnlySource,
+      destination: dest,
+      auto_reply_disabled: true,
+      dm_reply_disabled: true,
+      mention_reply_disabled: true,
+      quote_reply_disabled: true,
+      global_inbound_action_disabled: true,
+      listener_only: this.config.listener_only !== false,
+      outbound_disabled: this.config.listener_only !== false,
+      bot_prefix_required: false,
+      auto_alert: false,
+      listen_all_groups: Boolean(this.config.listen_all_groups),
+      listen_dms: Boolean(this.config.listen_dms),
+      outbound_allowlist: dest.group_id
+        ? [dest.group_id]
+        : dest.group_name
+          ? [`name:${dest.group_name}`]
+          : [],
+    };
+  }
+
+  evaluateInbound(event) {
+    if (!event?.account_id || !event?.source_id) {
+      return { allow: false, reason: "missing_ids", policy: null, actions: [] };
+    }
+
+    const dest = this.store.getDestination(event.account_id);
+    const inDestination =
+      Boolean(dest.group_id) && String(event.source_id) === String(dest.group_id);
+    const text = String(event.text || "").trim();
+    const isSlash = text.startsWith("/");
+    const hasBotCmd = !isSlash && isBotCommand(text);
+
+    // Never re-ingest bot/report messages (loop prevention), including destination.
+    if (event.is_self) {
+      if (BOT_REPORT_HINT.test(text)) {
+        return { allow: false, reason: "self_bot_report", policy: null, actions: [] };
+      }
+      try {
+        const sha = sha256(text);
+        if (this.store.recentOutboundDuplicate(event.account_id, sha, 30)) {
+          return { allow: false, reason: "self_outbound_echo", policy: null, actions: [] };
+        }
+      } catch {
+        /* ignore */
+      }
+    }
+
+    // Outside destination: absolute silence on self messages.
+    if (event.is_self && !inDestination) {
+      return { allow: false, reason: "self_echo", policy: null, actions: [] };
+    }
+
+    // DM: store optional only if explicitly enabled; never reply / never brain.
+    if (event.source_type === "dm") {
+      if (!this.config.listen_dms) {
+        return { allow: false, reason: "dm_disabled", policy: null, actions: [] };
+      }
+      return {
+        allow: true,
+        reason: "dm_store_only",
+        policy: { mode: "listen_only", muted: true },
+        actions: ["store"],
+      };
+    }
+
+    // Listener-only is intentionally before every command/brain route.
+    // Untrusted text — including prompt-injection-looking "bot" messages and
+    // mentions — can only be stored. It cannot invoke skills, MCP, a model,
+    // or an outbound action.
+    if (this.config.listener_only !== false) {
+      return {
+        allow: true,
+        reason: "listener_only_store",
+        policy: { mode: "listen_only", muted: true },
+        actions: ["store"],
+      };
+    }
+
+    // Slash commands: ONLY valid inside destination group.
+    if (isSlash) {
+      if (!inDestination) {
+        return { allow: false, reason: "command_outside_destination", policy: null, actions: [] };
+      }
+      if (event.is_self || this.roleOf(event.account_id, event.sender_id)) {
+        return {
+          allow: true,
+          reason: "destination_command",
+          policy: null,
+          actions: ["command"],
+        };
+      }
+      return { allow: false, reason: "unauthorized_silent", policy: null, actions: [] };
+    }
+
+    // Destination group: Phase 1 brain path = "bot ..." prefix only.
+    if (inDestination) {
+      if (!hasBotCmd) {
+        return {
+          allow: true,
+          reason: "destination_store_only",
+          policy: null,
+          actions: ["store"],
+        };
+      }
+      // Auth check deferred to router for silent unauthorized.
+      return {
+        allow: true,
+        reason: "destination_bot_cmd",
+        policy: null,
+        actions: ["destination_ask"],
+      };
+    }
+
+    // Source groups: READ_ONLY — store only, never reply even if tagged/quoted.
+    if (this.config.listen_all_groups && event.source_type === "group") {
+      const ingestCount = this.store.countInboundRecent(event.account_id, 60);
+      if (ingestCount >= this.ingestPerHour) {
+        return { allow: false, reason: "ingest_rate", policy: null, actions: [] };
+      }
+      return {
+        allow: true,
+        reason: "read_only_source",
+        policy: {
+          account_id: event.account_id,
+          source_id: event.source_id,
+          source_type: "group",
+          source_name: event.source_name || "",
+          mode: "listen_only",
+          muted: true,
+        },
+        actions: ["store"],
+      };
+    }
+
+    const policy = this.getSourcePolicy(event.account_id, event.source_id);
+    if (!policy) return { allow: false, reason: "not_allowlisted", policy: null, actions: [] };
+
+    const ingestCount = this.store.countInboundRecent(event.account_id, 60);
+    if (ingestCount >= this.ingestPerHour) {
+      return { allow: false, reason: "ingest_rate", policy, actions: [] };
+    }
+
+    const actions = ["store"];
+    if (
+      !this.readOnlySource &&
+      ["digest_only", "alert_only", "mention_only", "reply_enabled"].includes(policy.mode)
+    ) {
+      actions.push("digest_candidate");
+    }
+    if (!this.readOnlySource && this.config.auto_alert) {
+      if (["alert_only", "mention_only", "reply_enabled"].includes(policy.mode)) {
+        actions.push("alert_candidate");
+      }
+    }
+    return { allow: true, reason: "ok_store_only", policy: { ...policy, mode: "listen_only" }, actions };
+  }
+
+  evaluateCommand({ accountId, senderId, command, sourceId = null }) {
+    if (!senderId) return { allow: false, reason: "missing_sender", silent: true };
+    const dest = this.store.getDestination(accountId);
+    if (!dest.group_id) return { allow: false, reason: "destination_unset", silent: true };
+    if (sourceId && String(sourceId) !== String(dest.group_id)) {
+      return { allow: false, reason: "command_outside_destination", silent: true };
+    }
+    const minRole = COMMAND_MIN_ROLE[command] || "owner";
+    const account = this.store.getAccount(accountId);
+    const isSelfOwner =
+      account?.zalo_user_id && String(account.zalo_user_id) === String(senderId);
+    if (isSelfOwner) return { allow: true, reason: "self_owner", minRole };
+    if (!this.requireRole(accountId, senderId, minRole)) {
+      return { allow: false, reason: "unauthorized_silent", silent: true };
+    }
+    return { allow: true, reason: "ok", minRole };
+  }
+
+  evaluateOutbound({ accountId, targetId, text, kind = "digest", alertKey = null }) {
+    // Master hard gate. Future RBAC must replace this only together with an
+    // explicit owner approval, numeric-identity checks, scoped capabilities,
+    // a quota budget, and its own regression suite.
+    if (this.config.listener_only !== false) return { allow: false, reason: "outbound_disabled" };
+    if (this.store.isGlobalPaused()) return { allow: false, reason: "bridge_paused" };
+
+    const account = this.store.getAccount(accountId);
+    if (!account) return { allow: false, reason: "unknown_account" };
+    if (account.status === "paused" || account.paused) return { allow: false, reason: "account_paused" };
+    if (account.status !== "connected" && process.env.POLICY_REQUIRE_CONNECTED !== "false") {
+      if (process.env.NODE_ENV !== "test" && process.env.POLICY_REQUIRE_CONNECTED !== "false") {
+        return { allow: false, reason: "account_not_connected" };
+      }
+    }
+
+    if (!targetId) return { allow: false, reason: "missing_target" };
+    if (!text || !String(text).trim()) return { allow: false, reason: "empty_text" };
+
+    const dest = this.store.getDestination(accountId);
+    if (!dest.group_id) return { allow: false, reason: "destination_unset" };
+
+    // HARD: only the configured destination. No source replies, no DM replies.
+    if (String(targetId) !== String(dest.group_id)) {
+      return { allow: false, reason: "target_not_destination" };
+    }
+    if (String(dest.account_id) && String(dest.account_id) !== String(accountId)) {
+      return { allow: false, reason: "destination_account_mismatch" };
+    }
+
+    if (this.readOnlySource && (kind === "reply" || kind === "mention" || kind === "quote")) {
+      return { allow: false, reason: "read_only_source_blocks_reply" };
+    }
+
+    if (!["digest", "alert", "ask_reply", "command_reply", "report"].includes(String(kind))) {
+      if (kind !== "digest") return { allow: false, reason: "kind_blocked" };
+    }
+
+    const hourCount = this.store.countOutbound(accountId, 60);
+    const dayCount = this.store.countOutbound(accountId, 60 * 24);
+    const destHour = this.store.countOutbound(accountId, 60, targetId);
+    if (hourCount >= (this.config.rate_limit?.messages_per_hour || 20)) {
+      return { allow: false, reason: "rate_hour" };
+    }
+    if (dayCount >= (this.config.rate_limit?.messages_per_day || 120)) {
+      return { allow: false, reason: "rate_day" };
+    }
+    if (destHour >= this.destPerHour) return { allow: false, reason: "rate_destination_hour" };
+
+    const body = String(text);
+    if (body.length > 3500) return { allow: false, reason: "too_long" };
+    if (containsSecretPattern(body)) return { allow: false, reason: "secret_leak_pattern" };
+
+    if (kind === "alert" && alertKey) {
+      const cd = this.store.getCooldown(accountId, alertKey);
+      if (cd?.last_sent_at) {
+        const ageMin = (Date.now() - Date.parse(cd.last_sent_at)) / 60000;
+        if (ageMin < this.alertCooldownMinutes) {
+          return { allow: false, reason: "alert_cooldown" };
+        }
+      }
+    }
+
+    const textSha = sha256(body);
+    if (this.store.recentOutboundDuplicate(accountId, textSha, 120)) {
+      return { allow: false, reason: "duplicate_recent" };
+    }
+
+    return { allow: true, reason: "ok", textSha };
+  }
+}
+
+export function isValidMode(mode) {
+  return SOURCE_MODES.includes(String(mode || ""));
+}
+
+export { COMMAND_MIN_ROLE, ROLE_ORDER, BOT_REPORT_HINT };

package/src/privacy.js

@@ -0,0 +1,38 @@
+// Privacy helpers: redaction before Hermes/report; raw retention optional.
+const PHONE_RE = /(?:\+?84|0)\d{8,10}\b/g;
+const EMAIL_RE = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi;
+const SECRET_RE = /(cookie|imei|password|api[_-]?key|authorization\s*:\s*bearer|session[_-]?token)/i;
+
+export function hashSender(senderId, salt = process.env.HERMES_ZALO_PSEUDONYM_SALT || "local-only") {
+  // lazy import-free hash via WebCrypto-less sha256 from schema
+  return null; // filled by callers using sha256 from schema to keep one hash util
+}
+
+export function redactPII(text, { phones = true, emails = true } = {}) {
+  let out = String(text ?? "");
+  if (phones) out = out.replace(PHONE_RE, "[phone]");
+  if (emails) out = out.replace(EMAIL_RE, "[email]");
+  return out;
+}
+
+export function containsSecretPattern(text) {
+  return SECRET_RE.test(String(text ?? ""));
+}
+
+export function sanitizeForHermes(text, opts = {}) {
+  const redacted = redactPII(text, opts);
+  if (containsSecretPattern(redacted)) {
+    return { ok: false, text: "", reason: "secret_pattern" };
+  }
+  return { ok: true, text: redacted.slice(0, 2000) };
+}
+
+export function stripSensitiveMetadata(meta = {}) {
+  const out = { ...meta };
+  for (const k of Object.keys(out)) {
+    if (/cookie|imei|token|password|session|secret|authorization/i.test(k)) {
+      delete out[k];
+    }
+  }
+  return out;
+}

package/src/schema.js

@@ -0,0 +1,163 @@
+// Shared constants + pure helpers. No secrets. No network.
+import crypto from "node:crypto";
+
+export const ACCOUNT_STATUSES = Object.freeze([
+  "disconnected",
+  "need_scan",
+  "reconnecting",
+  "connected",
+  "paused",
+]);
+
+export const SOURCE_MODES = Object.freeze([
+  "off",
+  "listen_only",
+  "digest_only",
+  "alert_only",
+  "mention_only",
+  "reply_enabled",
+]);
+
+export const ROLES = Object.freeze(["owner", "admin", "operator", "viewer"]);
+
+export const MESSAGE_TYPES = Object.freeze([
+  "text",
+  "image",
+  "file",
+  "audio",
+  "video",
+  "sticker",
+  "unknown",
+]);
+
+export function utcNow() {
+  return new Date().toISOString();
+}
+
+export function sha256(text) {
+  return crypto.createHash("sha256").update(String(text ?? ""), "utf8").digest("hex");
+}
+
+export function stableEventId(parts) {
+  return sha256(parts.filter((p) => p != null && p !== "").join("|")).slice(0, 32);
+}
+
+export function safeJsonParse(raw, fallback = null) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+
+const SECRET_KEY =
+  /^(cookie|cookies|imei|password|secret|authorization|access_token|refresh_token|dashboard_token|user_agent)$/i;
+// "session" alone is too broad (has_session, sessions_dir). Only raw session blobs.
+const SECRET_SESSION_KEY = /^(session|session_data|session_blob|credentials)$/i;
+
+export function redactSecrets(value) {
+  if (value == null) return value;
+  if (typeof value === "string") {
+    // Avoid redacting ordinary short labels; only long secret-looking payloads.
+    if (/(eyJ|cookie=|imei=)/i.test(value) && value.length > 40) return "[redacted]";
+    return value;
+  }
+  if (Array.isArray(value)) return value.map(redactSecrets);
+  if (typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (SECRET_KEY.test(k) || SECRET_SESSION_KEY.test(k)) {
+        out[k] = "[redacted]";
+        continue;
+      }
+      out[k] = redactSecrets(v);
+    }
+    return out;
+  }
+  return value;
+}
+
+export function normalizeMode(mode) {
+  const m = String(mode || "off").trim().toLowerCase();
+  return SOURCE_MODES.includes(m) ? m : "off";
+}
+
+export function classifyMessageType(content) {
+  if (typeof content === "string") return "text";
+  if (!content || typeof content !== "object") return "unknown";
+  if (content.href || content.thumb || content.title) return "image";
+  if (content.fileUrl || content.fileName) return "file";
+  if (content.voiceUrl || content.duration != null && content.fileSize) return "audio";
+  if (content.videoUrl) return "video";
+  if (content.id && content.cateId != null) return "sticker";
+  return "unknown";
+}
+
+export function extractText(content) {
+  if (typeof content === "string") return content;
+  if (!content || typeof content !== "object") return "";
+  if (typeof content.title === "string") return content.title;
+  if (typeof content.description === "string") return content.description;
+  if (typeof content.fileName === "string") return content.fileName;
+  return "";
+}
+
+/**
+ * Normalize a zca-js style message into the internal event schema.
+ * account_id is required so multi-session never collides.
+ */
+export function normalizeInboundMessage({ accountId, message, sourceName = "" }) {
+  if (!accountId) throw new Error("account_id required");
+  if (!message) throw new Error("message required");
+
+  const isGroup = Number(message.type) === 1 || message.type === "group";
+  const sourceType = isGroup ? "group" : "dm";
+  const sourceId = String(message.threadId ?? message.thread_id ?? "");
+  const data = message.data || {};
+  const messageId = String(data.msgId ?? data.messageId ?? data.cliMsgId ?? message.messageId ?? "");
+  const senderId = String(data.uidFrom ?? data.senderId ?? message.senderId ?? "");
+  const senderName = String(data.dName ?? data.displayName ?? data.senderName ?? "");
+  const content = data.content;
+  const messageType = classifyMessageType(content);
+  const text = extractText(content);
+  const createdAt = data.ts
+    ? new Date(Number(data.ts) || data.ts).toISOString()
+    : utcNow();
+  const isSelf = Boolean(message.isSelf);
+  const isMention =
+    Boolean(data.mentions?.length) ||
+    Boolean(data.quote) ||
+    /@/.test(text);
+
+  const eventId = stableEventId([
+    accountId,
+    sourceType,
+    sourceId,
+    messageId,
+    senderId,
+    createdAt,
+    text.slice(0, 80),
+  ]);
+
+  return {
+    event_id: eventId,
+    account_id: String(accountId),
+    source_type: sourceType,
+    source_id: sourceId,
+    source_name: sourceName || String(data.threadName || ""),
+    sender_id: senderId,
+    sender_name: senderName,
+    message_id: messageId || eventId,
+    message_type: messageType,
+    text,
+    is_self: isSelf,
+    is_mention: isMention,
+    raw_metadata: {
+      thread_type: message.type,
+      cli_msg_id: data.cliMsgId ?? null,
+      has_quote: Boolean(data.quote),
+      mention_count: Array.isArray(data.mentions) ? data.mentions.length : 0,
+    },
+    created_at: createdAt,
+  };
+}