openzca 0.1.48 → 0.1.50

package/dist/cli.js

@@ -4,10 +4,11 @@
 import { createRequire } from "module";
 import { spawn as spawn2 } from "child_process";
 import fsSync from "fs";
-import fs5 from "fs/promises";
+import fs6 from "fs/promises";
 import net from "net";
 import os4 from "os";
-import path5 from "path";
+import path6 from "path";
+import readline from "readline/promises";
 import util from "util";
 import { Command } from "commander";
 import {
@@ -15,7 +16,7 @@ import {
   Gender,
   Reactions,
   ReviewPendingMemberRequestStatus,
-  ThreadType as ThreadType2
+  ThreadType as ThreadType3
 } from "zca-js";
 
 // src/lib/store.ts
@@ -210,10 +211,1232 @@ async function clearCache(profileName) {
   await fs.rm(getCacheMetaPath(profileName), { force: true });
 }
 
-// src/lib/client.ts
+// src/lib/db.ts
+import crypto from "crypto";
 import fs2 from "fs/promises";
-import { spawn } from "child_process";
 import path2 from "path";
+import { open } from "sqlite";
+import sqlite3 from "sqlite3";
+var DB_CONFIG_FILE = "db.json";
+var DB_FILENAME = "messages.sqlite";
+var connections = /* @__PURE__ */ new Map();
+var writeQueues = /* @__PURE__ */ new Map();
+function nowIso2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function normalizeId(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(Math.trunc(value));
+  }
+  if (typeof value !== "string") {
+    return "";
+  }
+  return value.trim();
+}
+function normalizeOptionalText(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function normalizeSearchText(value) {
+  return value.normalize("NFD").replace(new RegExp("\\p{Diacritic}", "gu"), "").toLowerCase().trim();
+}
+function globToRegex(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const regexSource = escaped.replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${regexSource}$`);
+}
+function matchesSearchPattern(value, query) {
+  const normalizedValue = normalizeSearchText(value);
+  if (query.includes("*") || query.includes("?")) {
+    return globToRegex(query).test(normalizedValue);
+  }
+  return normalizedValue.includes(query);
+}
+function safeJsonStringify(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return JSON.stringify(value);
+}
+function defaultDbPath(profile) {
+  return path2.join(getProfileDir(profile), DB_FILENAME);
+}
+function getDbConfigPath(profile) {
+  return path2.join(getProfileDir(profile), DB_CONFIG_FILE);
+}
+async function readDbConfig(profile) {
+  const configPath = getDbConfigPath(profile);
+  try {
+    const raw = await fs2.readFile(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      enabled: Boolean(parsed.enabled),
+      path: normalizeOptionalText(parsed.path),
+      updatedAt: normalizeOptionalText(parsed.updatedAt) ?? nowIso2()
+    };
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") {
+      return {
+        enabled: false,
+        updatedAt: nowIso2()
+      };
+    }
+    throw error;
+  }
+}
+async function writeDbConfig(profile, config) {
+  const configPath = getDbConfigPath(profile);
+  await fs2.mkdir(path2.dirname(configPath), { recursive: true });
+  await fs2.writeFile(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+async function enableDb(profile, customPath) {
+  const config = {
+    enabled: true,
+    path: normalizeOptionalText(customPath),
+    updatedAt: nowIso2()
+  };
+  await writeDbConfig(profile, config);
+  await getDb(profile);
+  return config;
+}
+async function disableDb(profile) {
+  const existing = await readDbConfig(profile);
+  const config = {
+    enabled: false,
+    path: existing.path,
+    updatedAt: nowIso2()
+  };
+  await writeDbConfig(profile, config);
+  return config;
+}
+async function isDbEnabled(profile) {
+  const config = await readDbConfig(profile);
+  return config.enabled;
+}
+async function resolveDbPath(profile) {
+  const config = await readDbConfig(profile);
+  const configured = normalizeOptionalText(config.path);
+  if (!configured) {
+    return defaultDbPath(profile);
+  }
+  return path2.isAbsolute(configured) ? configured : path2.resolve(getProfileDir(profile), configured);
+}
+async function migrateDb(db) {
+  await db.exec(`
+    PRAGMA journal_mode = WAL;
+    PRAGMA foreign_keys = ON;
+
+    CREATE TABLE IF NOT EXISTS threads (
+      profile TEXT NOT NULL,
+      scope_thread_id TEXT NOT NULL,
+      raw_thread_id TEXT NOT NULL,
+      thread_type TEXT NOT NULL,
+      peer_id TEXT,
+      title TEXT,
+      is_pinned INTEGER NOT NULL DEFAULT 0,
+      is_hidden INTEGER NOT NULL DEFAULT 0,
+      is_archived INTEGER NOT NULL DEFAULT 0,
+      raw_json TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (profile, scope_thread_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS thread_members (
+      profile TEXT NOT NULL,
+      scope_thread_id TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      display_name TEXT,
+      zalo_name TEXT,
+      avatar TEXT,
+      account_status INTEGER,
+      member_type INTEGER,
+      raw_json TEXT,
+      snapshot_at_ms INTEGER NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (profile, scope_thread_id, user_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS friends (
+      profile TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      display_name TEXT,
+      zalo_name TEXT,
+      avatar TEXT,
+      account_status INTEGER,
+      raw_json TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (profile, user_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS self_profiles (
+      profile TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      display_name TEXT,
+      info_json TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (profile)
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+      profile TEXT NOT NULL,
+      message_uid TEXT NOT NULL,
+      scope_thread_id TEXT NOT NULL,
+      raw_thread_id TEXT NOT NULL,
+      thread_type TEXT NOT NULL,
+      msg_id TEXT,
+      cli_msg_id TEXT,
+      action_id TEXT,
+      sender_id TEXT,
+      sender_name TEXT,
+      to_id TEXT,
+      timestamp_ms INTEGER NOT NULL,
+      msg_type TEXT,
+      content_text TEXT,
+      content_json TEXT,
+      quote_msg_id TEXT,
+      quote_cli_msg_id TEXT,
+      quote_owner_id TEXT,
+      quote_text TEXT,
+      source TEXT NOT NULL,
+      raw_message_json TEXT,
+      raw_payload_json TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (profile, message_uid)
+    );
+
+    CREATE TABLE IF NOT EXISTS message_media (
+      profile TEXT NOT NULL,
+      message_uid TEXT NOT NULL,
+      item_index INTEGER NOT NULL,
+      media_kind TEXT,
+      media_url TEXT,
+      media_path TEXT,
+      media_type TEXT,
+      raw_json TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (profile, message_uid, item_index)
+    );
+
+    CREATE TABLE IF NOT EXISTS message_mentions (
+      profile TEXT NOT NULL,
+      message_uid TEXT NOT NULL,
+      item_index INTEGER NOT NULL,
+      target_user_id TEXT NOT NULL,
+      pos INTEGER,
+      len INTEGER,
+      mention_type INTEGER,
+      raw_json TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (profile, message_uid, item_index)
+    );
+
+    CREATE TABLE IF NOT EXISTS sync_state (
+      profile TEXT NOT NULL,
+      scope TEXT NOT NULL,
+      scope_thread_id TEXT NOT NULL,
+      thread_type TEXT NOT NULL,
+      status TEXT NOT NULL,
+      completeness TEXT,
+      cursor TEXT,
+      last_sync_at TEXT,
+      error TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (profile, scope)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_messages_thread_time
+      ON messages (profile, scope_thread_id, timestamp_ms DESC);
+    CREATE INDEX IF NOT EXISTS idx_messages_msg_id
+      ON messages (profile, msg_id);
+    CREATE INDEX IF NOT EXISTS idx_messages_cli_msg_id
+      ON messages (profile, cli_msg_id);
+    CREATE INDEX IF NOT EXISTS idx_threads_type
+      ON threads (profile, thread_type, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_members_thread
+      ON thread_members (profile, scope_thread_id);
+    CREATE INDEX IF NOT EXISTS idx_friends_name
+      ON friends (profile, display_name, zalo_name, user_id);
+  `);
+}
+async function openDb(profile) {
+  const filename = await resolveDbPath(profile);
+  await fs2.mkdir(path2.dirname(filename), { recursive: true });
+  const db = await open({
+    filename,
+    driver: sqlite3.Database
+  });
+  await migrateDb(db);
+  return db;
+}
+async function getDb(profile) {
+  const existing = connections.get(profile);
+  if (existing) {
+    return existing;
+  }
+  const created = openDb(profile).catch((error) => {
+    connections.delete(profile);
+    throw error;
+  });
+  connections.set(profile, created);
+  return created;
+}
+async function closeDb(profile) {
+  const existing = connections.get(profile);
+  if (!existing) {
+    return;
+  }
+  connections.delete(profile);
+  const db = await existing;
+  await db.close();
+}
+function resolveDmPeerId(params) {
+  const threadId = normalizeId(params.threadId);
+  const senderId = normalizeId(params.senderId);
+  const toId = normalizeId(params.toId);
+  const selfId = normalizeId(params.selfId);
+  if (selfId) {
+    if (senderId === selfId && toId && toId !== selfId) {
+      return toId;
+    }
+    if (toId === selfId && senderId && senderId !== selfId) {
+      return senderId;
+    }
+    if (threadId && threadId !== selfId) {
+      return threadId;
+    }
+    if (toId && toId !== selfId) {
+      return toId;
+    }
+    if (senderId && senderId !== selfId) {
+      return senderId;
+    }
+  }
+  if (senderId && toId && senderId === threadId && toId !== senderId) {
+    return toId;
+  }
+  if (senderId && toId && toId === threadId && senderId !== toId) {
+    return senderId;
+  }
+  if (threadId) {
+    return threadId;
+  }
+  if (toId && toId !== senderId) {
+    return toId;
+  }
+  return senderId;
+}
+function resolveScopeThreadId(params) {
+  if (params.threadType === "group") {
+    return normalizeId(params.rawThreadId);
+  }
+  return resolveDmPeerId({
+    threadId: params.rawThreadId,
+    senderId: params.senderId,
+    toId: params.toId,
+    selfId: params.selfId
+  });
+}
+function toMessageUid(record) {
+  const scopeThreadId = normalizeId(record.scopeThreadId);
+  const msgId = normalizeId(record.msgId);
+  const cliMsgId = normalizeId(record.cliMsgId);
+  const actionId = normalizeId(record.actionId);
+  const timestamp = String(record.timestampMs || 0);
+  if (msgId) {
+    return `${scopeThreadId}:msg:${msgId}`;
+  }
+  if (cliMsgId) {
+    return `${scopeThreadId}:cli:${cliMsgId}`;
+  }
+  if (actionId) {
+    return `${scopeThreadId}:action:${actionId}`;
+  }
+  const hash = crypto.createHash("sha256").update(
+    JSON.stringify({
+      scopeThreadId,
+      rawThreadId: record.rawThreadId,
+      senderId: record.senderId,
+      toId: record.toId,
+      timestamp,
+      msgType: record.msgType,
+      contentText: record.contentText
+    })
+  ).digest("hex").slice(0, 24);
+  return `${scopeThreadId}:hash:${hash}`;
+}
+async function withWriteQueue(profile, task) {
+  const prior = writeQueues.get(profile) ?? Promise.resolve();
+  const next = prior.catch(() => void 0).then(task);
+  writeQueues.set(profile, next);
+  try {
+    await next;
+  } finally {
+    if (writeQueues.get(profile) === next) {
+      writeQueues.delete(profile);
+    }
+  }
+}
+function enqueueDbWrite(profile, task) {
+  void withWriteQueue(profile, task).catch(() => {
+  });
+}
+async function persistThread(record) {
+  const db = await getDb(record.profile);
+  const now = nowIso2();
+  await db.run(
+    `
+      INSERT INTO threads (
+        profile, scope_thread_id, raw_thread_id, thread_type, peer_id, title,
+        is_pinned, is_hidden, is_archived, raw_json, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(profile, scope_thread_id) DO UPDATE SET
+        raw_thread_id = excluded.raw_thread_id,
+        thread_type = excluded.thread_type,
+        peer_id = COALESCE(excluded.peer_id, threads.peer_id),
+        title = COALESCE(excluded.title, threads.title),
+        is_pinned = excluded.is_pinned,
+        is_hidden = excluded.is_hidden,
+        is_archived = excluded.is_archived,
+        raw_json = COALESCE(excluded.raw_json, threads.raw_json),
+        updated_at = excluded.updated_at
+    `,
+    [
+      record.profile,
+      record.scopeThreadId,
+      record.rawThreadId,
+      record.threadType,
+      record.peerId ?? null,
+      record.title ?? null,
+      record.isPinned ? 1 : 0,
+      record.isHidden ? 1 : 0,
+      record.isArchived ? 1 : 0,
+      record.rawJson ?? null,
+      now,
+      now
+    ]
+  );
+}
+async function replaceThreadMembers(profile, scopeThreadId, members) {
+  const db = await getDb(profile);
+  const now = nowIso2();
+  await db.exec("BEGIN");
+  try {
+    await db.run(
+      `DELETE FROM thread_members WHERE profile = ? AND scope_thread_id = ?`,
+      [profile, scopeThreadId]
+    );
+    for (const member of members) {
+      await db.run(
+        `
+          INSERT INTO thread_members (
+            profile, scope_thread_id, user_id, display_name, zalo_name, avatar,
+            account_status, member_type, raw_json, snapshot_at_ms, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `,
+        [
+          member.profile,
+          member.scopeThreadId,
+          member.userId,
+          member.displayName ?? null,
+          member.zaloName ?? null,
+          member.avatar ?? null,
+          member.accountStatus ?? null,
+          member.memberType ?? null,
+          member.rawJson ?? null,
+          member.snapshotAtMs,
+          now,
+          now
+        ]
+      );
+    }
+    await db.exec("COMMIT");
+  } catch (error) {
+    await db.exec("ROLLBACK");
+    throw error;
+  }
+}
+async function persistFriend(record) {
+  const db = await getDb(record.profile);
+  const now = nowIso2();
+  await db.run(
+    `
+      INSERT INTO friends (
+        profile, user_id, display_name, zalo_name, avatar,
+        account_status, raw_json, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(profile, user_id) DO UPDATE SET
+        display_name = COALESCE(excluded.display_name, friends.display_name),
+        zalo_name = COALESCE(excluded.zalo_name, friends.zalo_name),
+        avatar = COALESCE(excluded.avatar, friends.avatar),
+        account_status = COALESCE(excluded.account_status, friends.account_status),
+        raw_json = COALESCE(excluded.raw_json, friends.raw_json),
+        updated_at = excluded.updated_at
+    `,
+    [
+      record.profile,
+      record.userId,
+      record.displayName ?? null,
+      record.zaloName ?? null,
+      record.avatar ?? null,
+      record.accountStatus ?? null,
+      record.rawJson ?? null,
+      now,
+      now
+    ]
+  );
+}
+async function persistSelfProfile(params) {
+  const db = await getDb(params.profile);
+  const now = nowIso2();
+  await db.run(
+    `
+      INSERT INTO self_profiles (
+        profile, user_id, display_name, info_json, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(profile) DO UPDATE SET
+        user_id = excluded.user_id,
+        display_name = COALESCE(excluded.display_name, self_profiles.display_name),
+        info_json = COALESCE(excluded.info_json, self_profiles.info_json),
+        updated_at = excluded.updated_at
+    `,
+    [
+      params.profile,
+      params.userId,
+      params.displayName ?? null,
+      params.infoJson ?? null,
+      now,
+      now
+    ]
+  );
+}
+async function persistMessage(record) {
+  const db = await getDb(record.profile);
+  const now = nowIso2();
+  const messageUid = toMessageUid(record);
+  await db.exec("BEGIN");
+  try {
+    await persistThread({
+      profile: record.profile,
+      scopeThreadId: record.scopeThreadId,
+      rawThreadId: record.rawThreadId,
+      threadType: record.threadType,
+      peerId: record.peerId,
+      title: record.title
+    });
+    await db.run(
+      `
+        INSERT INTO messages (
+          profile, message_uid, scope_thread_id, raw_thread_id, thread_type,
+          msg_id, cli_msg_id, action_id, sender_id, sender_name, to_id,
+          timestamp_ms, msg_type, content_text, content_json,
+          quote_msg_id, quote_cli_msg_id, quote_owner_id, quote_text,
+          source, raw_message_json, raw_payload_json, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(profile, message_uid) DO UPDATE SET
+          scope_thread_id = excluded.scope_thread_id,
+          raw_thread_id = excluded.raw_thread_id,
+          thread_type = excluded.thread_type,
+          msg_id = COALESCE(excluded.msg_id, messages.msg_id),
+          cli_msg_id = COALESCE(excluded.cli_msg_id, messages.cli_msg_id),
+          action_id = COALESCE(excluded.action_id, messages.action_id),
+          sender_id = COALESCE(excluded.sender_id, messages.sender_id),
+          sender_name = COALESCE(excluded.sender_name, messages.sender_name),
+          to_id = COALESCE(excluded.to_id, messages.to_id),
+          timestamp_ms = excluded.timestamp_ms,
+          msg_type = COALESCE(excluded.msg_type, messages.msg_type),
+          content_text = COALESCE(excluded.content_text, messages.content_text),
+          content_json = COALESCE(excluded.content_json, messages.content_json),
+          quote_msg_id = COALESCE(excluded.quote_msg_id, messages.quote_msg_id),
+          quote_cli_msg_id = COALESCE(excluded.quote_cli_msg_id, messages.quote_cli_msg_id),
+          quote_owner_id = COALESCE(excluded.quote_owner_id, messages.quote_owner_id),
+          quote_text = COALESCE(excluded.quote_text, messages.quote_text),
+          source = excluded.source,
+          raw_message_json = COALESCE(excluded.raw_message_json, messages.raw_message_json),
+          raw_payload_json = COALESCE(excluded.raw_payload_json, messages.raw_payload_json),
+          updated_at = excluded.updated_at
+      `,
+      [
+        record.profile,
+        messageUid,
+        record.scopeThreadId,
+        record.rawThreadId,
+        record.threadType,
+        record.msgId ?? null,
+        record.cliMsgId ?? null,
+        record.actionId ?? null,
+        record.senderId ?? null,
+        record.senderName ?? null,
+        record.toId ?? null,
+        record.timestampMs,
+        record.msgType ?? null,
+        record.contentText ?? null,
+        record.contentJson ?? null,
+        record.quoteMsgId ?? null,
+        record.quoteCliMsgId ?? null,
+        record.quoteOwnerId ?? null,
+        record.quoteText ?? null,
+        record.source,
+        record.rawMessageJson ?? null,
+        record.rawPayloadJson ?? null,
+        now,
+        now
+      ]
+    );
+    await db.run(
+      `DELETE FROM message_media WHERE profile = ? AND message_uid = ?`,
+      [record.profile, messageUid]
+    );
+    await db.run(
+      `DELETE FROM message_mentions WHERE profile = ? AND message_uid = ?`,
+      [record.profile, messageUid]
+    );
+    for (const [index, media] of (record.media ?? []).entries()) {
+      await db.run(
+        `
+          INSERT INTO message_media (
+            profile, message_uid, item_index, media_kind, media_url,
+            media_path, media_type, raw_json, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `,
+        [
+          record.profile,
+          messageUid,
+          index,
+          media.mediaKind ?? null,
+          media.mediaUrl ?? null,
+          media.mediaPath ?? null,
+          media.mediaType ?? null,
+          media.rawJson ?? null,
+          now,
+          now
+        ]
+      );
+    }
+    for (const [index, mention] of (record.mentions ?? []).entries()) {
+      await db.run(
+        `
+          INSERT INTO message_mentions (
+            profile, message_uid, item_index, target_user_id, pos, len,
+            mention_type, raw_json, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `,
+        [
+          record.profile,
+          messageUid,
+          index,
+          mention.uid,
+          mention.pos ?? null,
+          mention.len ?? null,
+          mention.type ?? null,
+          mention.rawJson ?? null,
+          now,
+          now
+        ]
+      );
+    }
+    await db.exec("COMMIT");
+  } catch (error) {
+    await db.exec("ROLLBACK");
+    throw error;
+  }
+}
+async function setSyncState(params) {
+  const db = await getDb(params.profile);
+  const now = nowIso2();
+  const scope = `${params.threadType}:${params.scopeThreadId}`;
+  await db.run(
+    `
+      INSERT INTO sync_state (
+        profile, scope, scope_thread_id, thread_type, status, completeness,
+        cursor, last_sync_at, error, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(profile, scope) DO UPDATE SET
+        status = excluded.status,
+        completeness = excluded.completeness,
+        cursor = COALESCE(excluded.cursor, sync_state.cursor),
+        last_sync_at = excluded.last_sync_at,
+        error = excluded.error,
+        updated_at = excluded.updated_at
+    `,
+    [
+      params.profile,
+      scope,
+      params.scopeThreadId,
+      params.threadType,
+      params.status,
+      params.completeness ?? null,
+      params.cursor ?? null,
+      now,
+      params.error ?? null,
+      now,
+      now
+    ]
+  );
+}
+async function listRecentMessages(params) {
+  const db = await getDb(params.profile);
+  const rows = await db.all(
+    `
+      SELECT
+        msg_id,
+        cli_msg_id,
+        scope_thread_id,
+        thread_type,
+        sender_id,
+        sender_name,
+        timestamp_ms,
+        msg_type,
+        content_text,
+        content_json
+      FROM messages
+      WHERE profile = ? AND scope_thread_id = ? AND thread_type = ?
+      ORDER BY timestamp_ms DESC, COALESCE(msg_id, ''), COALESCE(cli_msg_id, '')
+      LIMIT ?
+    `,
+    [params.profile, params.threadId, params.threadType, params.count]
+  );
+  return rows.map((row) => ({
+    msgId: row.msg_id ?? "",
+    cliMsgId: row.cli_msg_id ?? "",
+    threadId: row.scope_thread_id,
+    threadType: row.thread_type,
+    senderId: row.sender_id ?? "",
+    senderName: row.sender_name ?? "",
+    ts: String(row.timestamp_ms),
+    msgType: row.msg_type ?? "",
+    undo: {
+      msgId: row.msg_id ?? "",
+      cliMsgId: row.cli_msg_id ?? "",
+      threadId: row.scope_thread_id,
+      group: row.thread_type === "group"
+    },
+    content: row.content_text ?? row.content_json ?? ""
+  }));
+}
+async function listMessages(params) {
+  const db = await getDb(params.profile);
+  const order = params.newestFirst ? "DESC" : "ASC";
+  const limit = Number.isFinite(params.limit) ? Math.max(Math.trunc(params.limit), 1) : null;
+  const rows = await db.all(
+    `
+      SELECT
+        m.raw_thread_id,
+        m.thread_type,
+        m.msg_id,
+        m.cli_msg_id,
+        m.sender_id,
+        COALESCE(
+          NULLIF(m.sender_name, ''),
+          NULLIF(tm.display_name, ''),
+          NULLIF(tm.zalo_name, ''),
+          NULLIF(f.display_name, ''),
+          NULLIF(f.zalo_name, '')
+        ) AS sender_name,
+        m.to_id,
+        m.timestamp_ms,
+        m.msg_type,
+        m.content_text,
+        m.content_json,
+        m.quote_msg_id,
+        m.quote_cli_msg_id,
+        m.quote_owner_id,
+        m.quote_text,
+        m.source
+      FROM messages m
+      LEFT JOIN thread_members tm
+        ON tm.profile = m.profile
+        AND tm.scope_thread_id = m.scope_thread_id
+        AND tm.user_id = m.sender_id
+      LEFT JOIN friends f
+        ON f.profile = m.profile
+        AND f.user_id = m.sender_id
+      WHERE m.profile = ?
+        AND m.scope_thread_id = ?
+        AND m.thread_type = ?
+        AND (? IS NULL OR timestamp_ms >= ?)
+        AND (? IS NULL OR timestamp_ms < ?)
+      ORDER BY m.timestamp_ms ${order}, COALESCE(m.msg_id, ''), COALESCE(m.cli_msg_id, '')
+      ${limit ? "LIMIT ?" : ""}
+    `,
+    limit ? [
+      params.profile,
+      params.threadId,
+      params.threadType,
+      params.sinceMs ?? null,
+      params.sinceMs ?? null,
+      params.untilMs ?? null,
+      params.untilMs ?? null,
+      limit
+    ] : [
+      params.profile,
+      params.threadId,
+      params.threadType,
+      params.sinceMs ?? null,
+      params.sinceMs ?? null,
+      params.untilMs ?? null,
+      params.untilMs ?? null
+    ]
+  );
+  return rows.map((row) => ({
+    msgId: row.msg_id ?? "",
+    cliMsgId: row.cli_msg_id ?? "",
+    threadId: params.threadId,
+    threadType: row.thread_type,
+    senderId: row.sender_id ?? "",
+    senderName: row.sender_name ?? "",
+    ts: String(row.timestamp_ms),
+    timestampMs: row.timestamp_ms,
+    msgType: row.msg_type ?? "",
+    undo: {
+      msgId: row.msg_id ?? "",
+      cliMsgId: row.cli_msg_id ?? "",
+      threadId: params.threadId,
+      group: row.thread_type === "group"
+    },
+    content: row.content_text ?? row.content_json ?? "",
+    rawThreadId: row.raw_thread_id,
+    toId: row.to_id ?? void 0,
+    quoteMsgId: row.quote_msg_id ?? void 0,
+    quoteCliMsgId: row.quote_cli_msg_id ?? void 0,
+    quoteOwnerId: row.quote_owner_id ?? void 0,
+    quoteText: row.quote_text ?? void 0,
+    source: row.source
+  }));
+}
+async function getMessageById(params) {
+  const db = await getDb(params.profile);
+  const row = await db.get(
+    `
+      SELECT *
+      FROM messages
+      WHERE profile = ?
+        AND (
+          msg_id = ?
+          OR cli_msg_id = ?
+          OR message_uid = ?
+        )
+      ORDER BY timestamp_ms DESC
+      LIMIT 1
+    `,
+    [params.profile, params.id, params.id, params.id]
+  );
+  if (!row) {
+    return null;
+  }
+  return {
+    threadId: row.scope_thread_id,
+    rawThreadId: row.raw_thread_id,
+    threadType: row.thread_type,
+    msgId: row.msg_id ?? void 0,
+    cliMsgId: row.cli_msg_id ?? void 0,
+    actionId: row.action_id ?? void 0,
+    senderId: row.sender_id ?? void 0,
+    senderName: row.sender_name ?? void 0,
+    toId: row.to_id ?? void 0,
+    timestampMs: row.timestamp_ms,
+    msgType: row.msg_type ?? void 0,
+    content: row.content_text ?? void 0,
+    contentJson: row.content_json ?? void 0,
+    quoteMsgId: row.quote_msg_id ?? void 0,
+    quoteCliMsgId: row.quote_cli_msg_id ?? void 0,
+    quoteOwnerId: row.quote_owner_id ?? void 0,
+    quoteText: row.quote_text ?? void 0,
+    source: row.source,
+    rawMessage: row.raw_message_json ? JSON.parse(row.raw_message_json) : void 0,
+    rawPayload: row.raw_payload_json ? JSON.parse(row.raw_payload_json) : void 0
+  };
+}
+async function listThreads(params) {
+  const db = await getDb(params.profile);
+  const rows = await db.all(
+    `
+      SELECT
+        t.scope_thread_id,
+        t.raw_thread_id,
+        t.thread_type,
+        t.title,
+        t.peer_id,
+        t.is_pinned,
+        t.is_hidden,
+        t.is_archived,
+        COUNT(m.message_uid) AS message_count,
+        MIN(m.timestamp_ms) AS first_message_at_ms,
+        MAX(m.timestamp_ms) AS last_message_at_ms,
+        (
+          SELECT COUNT(*)
+          FROM thread_members tm
+          WHERE tm.profile = t.profile AND tm.scope_thread_id = t.scope_thread_id
+        ) AS member_count
+      FROM threads t
+      LEFT JOIN messages m
+        ON m.profile = t.profile AND m.scope_thread_id = t.scope_thread_id
+      WHERE t.profile = ?
+        AND (? IS NULL OR t.thread_type = ?)
+      GROUP BY
+        t.scope_thread_id, t.raw_thread_id, t.thread_type, t.title, t.peer_id,
+        t.is_pinned, t.is_hidden, t.is_archived
+      ORDER BY COALESCE(MAX(m.timestamp_ms), 0) DESC, t.scope_thread_id
+    `,
+    [params.profile, params.threadType ?? null, params.threadType ?? null]
+  );
+  return rows.map((row) => ({
+    threadId: row.scope_thread_id,
+    rawThreadId: row.raw_thread_id,
+    threadType: row.thread_type,
+    title: row.title ?? void 0,
+    peerId: row.peer_id ?? void 0,
+    messageCount: row.message_count,
+    firstMessageAtMs: row.first_message_at_ms ?? void 0,
+    lastMessageAtMs: row.last_message_at_ms ?? void 0,
+    memberCount: row.member_count,
+    isPinned: row.is_pinned === 1,
+    isHidden: row.is_hidden === 1,
+    isArchived: row.is_archived === 1
+  }));
+}
+async function listGroups(profile) {
+  return listThreads({ profile, threadType: "group" });
+}
+async function getThreadInfo(params) {
+  const db = await getDb(params.profile);
+  const row = await db.get(
+    `
+      SELECT
+        t.scope_thread_id,
+        t.raw_thread_id,
+        t.thread_type,
+        t.title,
+        t.peer_id,
+        t.is_pinned,
+        t.is_hidden,
+        t.is_archived,
+        t.raw_json,
+        COUNT(m.message_uid) AS message_count,
+        MIN(m.timestamp_ms) AS first_message_at_ms,
+        MAX(m.timestamp_ms) AS last_message_at_ms,
+        (
+          SELECT COUNT(*)
+          FROM thread_members tm
+          WHERE tm.profile = t.profile AND tm.scope_thread_id = t.scope_thread_id
+        ) AS member_count
+      FROM threads t
+      LEFT JOIN messages m
+        ON m.profile = t.profile AND m.scope_thread_id = t.scope_thread_id
+      WHERE t.profile = ?
+        AND (? IS NULL OR t.thread_type = ?)
+        AND (t.scope_thread_id = ? OR t.raw_thread_id = ?)
+      GROUP BY
+        t.scope_thread_id, t.raw_thread_id, t.thread_type, t.title, t.peer_id,
+        t.is_pinned, t.is_hidden, t.is_archived, t.raw_json
+      ORDER BY
+        CASE WHEN t.scope_thread_id = ? THEN 0 ELSE 1 END,
+        COALESCE(MAX(m.timestamp_ms), 0) DESC
+      LIMIT 1
+    `,
+    [
+      params.profile,
+      params.threadType ?? null,
+      params.threadType ?? null,
+      params.threadId,
+      params.threadId,
+      params.threadId
+    ]
+  );
+  if (!row) {
+    return null;
+  }
+  return {
+    threadId: row.scope_thread_id,
+    rawThreadId: row.raw_thread_id,
+    threadType: row.thread_type,
+    title: row.title ?? void 0,
+    peerId: row.peer_id ?? void 0,
+    messageCount: row.message_count,
+    firstMessageAtMs: row.first_message_at_ms ?? void 0,
+    lastMessageAtMs: row.last_message_at_ms ?? void 0,
+    memberCount: row.member_count,
+    isPinned: row.is_pinned === 1,
+    isHidden: row.is_hidden === 1,
+    isArchived: row.is_archived === 1,
+    raw: row.raw_json ? JSON.parse(row.raw_json) : void 0
+  };
+}
+async function listFriends(profile) {
+  const db = await getDb(profile);
+  const rows = await db.all(
+    `
+      SELECT
+        f.user_id,
+        f.display_name,
+        f.zalo_name,
+        f.avatar,
+        f.account_status,
+        t.scope_thread_id AS chat_id,
+        t.title,
+        COUNT(m.message_uid) AS message_count,
+        MAX(m.timestamp_ms) AS last_message_at_ms
+      FROM friends f
+      LEFT JOIN threads t
+        ON t.profile = f.profile
+        AND t.thread_type = 'user'
+        AND (t.peer_id = f.user_id OR t.scope_thread_id = f.user_id OR t.raw_thread_id = f.user_id)
+      LEFT JOIN messages m
+        ON m.profile = t.profile
+        AND m.scope_thread_id = t.scope_thread_id
+      WHERE f.profile = ?
+      GROUP BY
+        f.user_id, f.display_name, f.zalo_name, f.avatar, f.account_status, t.scope_thread_id, t.title
+      ORDER BY COALESCE(f.display_name, f.zalo_name, f.user_id), f.user_id
+    `,
+    [profile]
+  );
+  return rows.map((row) => ({
+    userId: row.user_id,
+    displayName: row.display_name ?? void 0,
+    zaloName: row.zalo_name ?? void 0,
+    avatar: row.avatar ?? void 0,
+    accountStatus: row.account_status ?? void 0,
+    title: row.title ?? void 0,
+    chatId: row.chat_id ?? row.user_id,
+    messageCount: row.message_count,
+    lastMessageAtMs: row.last_message_at_ms ?? void 0
+  }));
+}
+async function getFriendInfo(params) {
+  const db = await getDb(params.profile);
+  const row = await db.get(
+    `
+      SELECT
+        f.user_id,
+        f.display_name,
+        f.zalo_name,
+        f.avatar,
+        f.account_status,
+        f.raw_json,
+        t.scope_thread_id AS chat_id,
+        t.title,
+        COUNT(m.message_uid) AS message_count,
+        MAX(m.timestamp_ms) AS last_message_at_ms
+      FROM friends f
+      LEFT JOIN threads t
+        ON t.profile = f.profile
+        AND t.thread_type = 'user'
+        AND (t.peer_id = f.user_id OR t.scope_thread_id = f.user_id OR t.raw_thread_id = f.user_id)
+      LEFT JOIN messages m
+        ON m.profile = t.profile
+        AND m.scope_thread_id = t.scope_thread_id
+      WHERE f.profile = ?
+        AND f.user_id = ?
+      GROUP BY
+        f.user_id, f.display_name, f.zalo_name, f.avatar, f.account_status,
+        f.raw_json, t.scope_thread_id, t.title
+      LIMIT 1
+    `,
+    [params.profile, params.userId]
+  );
+  if (!row) {
+    return null;
+  }
+  return {
+    userId: row.user_id,
+    displayName: row.display_name ?? void 0,
+    zaloName: row.zalo_name ?? void 0,
+    avatar: row.avatar ?? void 0,
+    accountStatus: row.account_status ?? void 0,
+    title: row.title ?? void 0,
+    chatId: row.chat_id ?? row.user_id,
+    messageCount: row.message_count,
+    lastMessageAtMs: row.last_message_at_ms ?? void 0,
+    raw: row.raw_json ? JSON.parse(row.raw_json) : void 0
+  };
+}
+async function findFriends(params) {
+  const query = normalizeSearchText(params.query);
+  if (!query) {
+    return [];
+  }
+  const rows = await listFriends(params.profile);
+  return rows.filter((row) => {
+    const haystacks = [
+      row.userId,
+      row.displayName ?? "",
+      row.zaloName ?? "",
+      row.title ?? ""
+    ];
+    return haystacks.some((value) => matchesSearchPattern(value, query));
+  });
+}
+async function listChats(profile) {
+  return listThreads({ profile });
+}
+async function getSelfProfile(profile) {
+  const db = await getDb(profile);
+  const row = await db.get(
+    `
+      SELECT user_id, display_name, info_json
+      FROM self_profiles
+      WHERE profile = ?
+      LIMIT 1
+    `,
+    [profile]
+  );
+  if (!row) {
+    return null;
+  }
+  return {
+    userId: row.user_id,
+    displayName: row.display_name ?? void 0,
+    info: row.info_json ? JSON.parse(row.info_json) : void 0
+  };
+}
+async function listThreadMembers(params) {
+  const db = await getDb(params.profile);
+  const rows = await db.all(
+    `
+      SELECT
+        user_id, display_name, zalo_name, avatar, account_status, member_type, snapshot_at_ms
+      FROM thread_members
+      WHERE profile = ? AND scope_thread_id = ?
+      ORDER BY COALESCE(display_name, zalo_name, user_id), user_id
+    `,
+    [params.profile, params.threadId]
+  );
+  return rows.map((row) => ({
+    userId: row.user_id,
+    displayName: row.display_name ?? void 0,
+    zaloName: row.zalo_name ?? void 0,
+    avatar: row.avatar ?? void 0,
+    accountStatus: row.account_status ?? void 0,
+    type: row.member_type ?? void 0,
+    snapshotAtMs: row.snapshot_at_ms
+  }));
+}
+async function getDbStatus(profile) {
+  const filename = await resolveDbPath(profile);
+  const exists = await fs2.access(filename).then(() => true).catch(() => false);
+  const config = await readDbConfig(profile);
+  if (!exists) {
+    return {
+      enabled: config.enabled,
+      path: filename,
+      exists: false,
+      messageCount: 0,
+      threadCount: 0,
+      groupCount: 0,
+      userCount: 0,
+      updatedAt: config.updatedAt
+    };
+  }
+  const db = await getDb(profile);
+  const row = await db.get(`
+    SELECT
+      (SELECT COUNT(*) FROM messages WHERE profile = ?) AS message_count,
+      (SELECT COUNT(*) FROM threads WHERE profile = ?) AS thread_count,
+      (SELECT COUNT(*) FROM threads WHERE profile = ? AND thread_type = 'group') AS group_count,
+      (SELECT COUNT(*) FROM threads WHERE profile = ? AND thread_type = 'user') AS user_count,
+      (SELECT MAX(timestamp_ms) FROM messages WHERE profile = ?) AS last_message_at_ms,
+      (
+        SELECT MAX(updated_at)
+        FROM (
+          SELECT updated_at FROM messages WHERE profile = ?
+          UNION ALL
+          SELECT updated_at FROM threads WHERE profile = ?
+        )
+      ) AS last_updated_at
+  `, [profile, profile, profile, profile, profile, profile, profile]);
+  return {
+    enabled: config.enabled,
+    path: filename,
+    exists: true,
+    messageCount: row?.message_count ?? 0,
+    threadCount: row?.thread_count ?? 0,
+    groupCount: row?.group_count ?? 0,
+    userCount: row?.user_count ?? 0,
+    lastMessageAtMs: row?.last_message_at_ms ?? void 0,
+    updatedAt: row?.last_updated_at ?? config.updatedAt
+  };
+}
+async function listSyncState(params) {
+  const filename = await resolveDbPath(params.profile);
+  const exists = await fs2.access(filename).then(() => true).catch(() => false);
+  if (!exists) {
+    return [];
+  }
+  const db = await getDb(params.profile);
+  const rows = await db.all(
+    `
+      SELECT scope, scope_thread_id, thread_type, status, cursor, completeness, last_sync_at, error
+      FROM sync_state
+      WHERE profile = ? AND (? IS NULL OR thread_type = ?)
+      ORDER BY COALESCE(last_sync_at, ''), scope
+    `,
+    [params.profile, params.threadType ?? null, params.threadType ?? null]
+  );
+  return rows.map((row) => ({
+    scope: row.scope,
+    scopeThreadId: row.scope_thread_id,
+    threadType: row.thread_type,
+    status: row.status,
+    cursor: row.cursor ?? void 0,
+    completeness: row.completeness ?? void 0,
+    lastSyncAt: row.last_sync_at ?? void 0,
+    error: row.error ?? void 0
+  }));
+}
+function normalizeInboundListenRecord(params) {
+  const scopeThreadId = resolveScopeThreadId({
+    threadType: params.threadType,
+    rawThreadId: params.rawThreadId,
+    senderId: params.senderId,
+    toId: params.toId,
+    selfId: params.selfId
+  });
+  return {
+    profile: params.profile,
+    scopeThreadId,
+    rawThreadId: params.rawThreadId,
+    threadType: params.threadType,
+    peerId: params.threadType === "user" ? scopeThreadId : void 0,
+    title: params.title,
+    msgId: normalizeOptionalText(params.msgId),
+    cliMsgId: normalizeOptionalText(params.cliMsgId),
+    actionId: normalizeOptionalText(params.actionId),
+    senderId: normalizeOptionalText(params.senderId),
+    senderName: normalizeOptionalText(params.senderName),
+    toId: normalizeOptionalText(params.toId),
+    timestampMs: params.timestampMs,
+    msgType: normalizeOptionalText(params.msgType),
+    contentText: params.contentText,
+    contentJson: params.contentJson,
+    quoteMsgId: normalizeOptionalText(params.quoteMsgId),
+    quoteCliMsgId: normalizeOptionalText(params.quoteCliMsgId),
+    quoteOwnerId: normalizeOptionalText(params.quoteOwnerId),
+    quoteText: params.quoteText,
+    media: params.media,
+    mentions: params.mentions,
+    source: params.source,
+    rawMessageJson: safeJsonStringify(params.rawMessage),
+    rawPayloadJson: safeJsonStringify(params.rawPayload)
+  };
+}
+
+// src/lib/client.ts
+import fs3 from "fs/promises";
+import { spawn } from "child_process";
+import path3 from "path";
 import { imageSize } from "image-size";
 import * as qrcodeTerminal from "qrcode-terminal";
 import {
@@ -248,7 +1471,7 @@ function renderInlineQrPngIfSupported(pngBase64, filePath) {
       if (debug) console.error("[openzca] QR render mode: iterm");
       const widthEnv = Number.parseInt(process.env.OPENZCA_QR_WIDTH ?? "", 10);
       const widthCells = Number.isFinite(widthEnv) && widthEnv >= 16 && widthEnv <= 80 ? widthEnv : 34;
-      const encodedName = Buffer.from(path2.basename(filePath)).toString("base64");
+      const encodedName = Buffer.from(path3.basename(filePath)).toString("base64");
       const osc1337 = `\x1B]1337;File=name=${encodedName};inline=1;width=${widthCells};preserveAspectRatio=1:${pngBase64}\x07`;
       process.stdout.write(`${osc1337}
 `);
@@ -321,7 +1544,7 @@ function tryOpenFile(filePath) {
   }
 }
 async function imageMetadataGetter(filePath) {
-  const data = await fs2.readFile(filePath);
+  const data = await fs3.readFile(filePath);
   const info = imageSize(data);
   if (!info.width || !info.height) {
     throw new Error(`Cannot read image size: ${filePath}`);
@@ -376,7 +1599,7 @@ async function loginWithQrAndPersist(profileName, qrPath, opts) {
         console.log("\nScan this QR in your Zalo app:\n");
         const targetPath = qrPath ?? "qr.png";
         await event.actions.saveToFile(targetPath);
-        const absolutePath = path2.resolve(targetPath);
+        const absolutePath = path3.resolve(targetPath);
         const rendered = renderInlineQrPngIfSupported(
           event.data.image,
           targetPath
@@ -452,9 +1675,9 @@ async function loginWithQrAndPersist(profileName, qrPath, opts) {
 }
 
 // src/lib/media.ts
-import fs3 from "fs/promises";
+import fs4 from "fs/promises";
 import os2 from "os";
-import path3 from "path";
+import path4 from "path";
 import { fileURLToPath } from "url";
 var CONTENT_TYPE_EXT = {
   "image/jpeg": ".jpg",
@@ -502,7 +1725,7 @@ function expandLeadingTilde(value) {
     return os2.homedir();
   }
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return path3.join(os2.homedir(), value.slice(2));
+    return path4.join(os2.homedir(), value.slice(2));
   }
   return value;
 }
@@ -534,7 +1757,7 @@ function inferExt(url, contentType) {
   }
   try {
     const pathname = new URL(url).pathname;
-    const ext = path3.extname(pathname);
+    const ext = path4.extname(pathname);
     if (ext) return ext;
   } catch {
   }
@@ -547,7 +1770,7 @@ async function downloadUrlsToTempFiles(urls) {
       cleanup: async () => Promise.resolve()
     };
   }
-  const dir = await fs3.mkdtemp(path3.join(os2.tmpdir(), "openzca-"));
+  const dir = await fs4.mkdtemp(path4.join(os2.tmpdir(), "openzca-"));
   const files = [];
   for (let i = 0; i < urls.length; i += 1) {
     const url = urls[i];
@@ -556,22 +1779,22 @@ async function downloadUrlsToTempFiles(urls) {
       throw new Error(`Failed to download URL: ${url} (${response.status})`);
     }
     const ext = inferExt(url, response.headers.get("content-type"));
-    const filePath = path3.join(dir, `url-${i + 1}${ext}`);
+    const filePath = path4.join(dir, `url-${i + 1}${ext}`);
     const data = Buffer.from(await response.arrayBuffer());
-    await fs3.writeFile(filePath, data);
+    await fs4.writeFile(filePath, data);
     files.push(filePath);
   }
   return {
     files,
     cleanup: async () => {
-      await fs3.rm(dir, { recursive: true, force: true });
+      await fs4.rm(dir, { recursive: true, force: true });
     }
   };
 }
 async function assertFilesExist(files) {
   for (const file of files) {
     try {
-      await fs3.access(file);
+      await fs4.access(file);
     } catch {
       throw new Error(`File not found: ${file}`);
     }
@@ -632,6 +1855,82 @@ function buildCreatePollOptions(options) {
   };
 }
 
+// src/lib/time-range.ts
+var DURATION_PART_RE = /(\d+)\s*(ms|s|m|h|d|w)/gi;
+function durationToMs(input) {
+  const text = input.trim().toLowerCase();
+  if (!text) {
+    return null;
+  }
+  let total = 0;
+  let matched = 0;
+  for (const match of text.matchAll(DURATION_PART_RE)) {
+    const rawAmount = match[1];
+    const unit = match[2];
+    const amount = Number(rawAmount);
+    if (!Number.isFinite(amount) || amount < 0) {
+      return null;
+    }
+    matched += match[0].length;
+    switch (unit) {
+      case "ms":
+        total += amount;
+        break;
+      case "s":
+        total += amount * 1e3;
+        break;
+      case "m":
+        total += amount * 60 * 1e3;
+        break;
+      case "h":
+        total += amount * 60 * 60 * 1e3;
+        break;
+      case "d":
+        total += amount * 24 * 60 * 60 * 1e3;
+        break;
+      case "w":
+        total += amount * 7 * 24 * 60 * 60 * 1e3;
+        break;
+      default:
+        return null;
+    }
+  }
+  if (matched === 0) {
+    return null;
+  }
+  const normalized = text.replace(/\s+/g, "");
+  const consumed = Array.from(normalized.matchAll(DURATION_PART_RE)).map((match) => match[0]).join("");
+  if (consumed !== normalized) {
+    return null;
+  }
+  return total;
+}
+function parseDurationInput(value, nowMs = Date.now()) {
+  if (!value || !value.trim()) {
+    return void 0;
+  }
+  const durationMs = durationToMs(value.trim());
+  if (durationMs == null) {
+    return void 0;
+  }
+  return nowMs - durationMs;
+}
+function parseTimeBoundaryInput(value, _nowMs = Date.now()) {
+  if (!value || !value.trim()) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  const numeric = Number(trimmed);
+  if (Number.isFinite(numeric) && numeric > 0) {
+    return numeric > 1e10 ? Math.trunc(numeric) : Math.trunc(numeric * 1e3);
+  }
+  const parsed = Date.parse(trimmed);
+  if (Number.isFinite(parsed)) {
+    return parsed;
+  }
+  return void 0;
+}
+
 // src/lib/text-send.ts
 import { ThreadType } from "zca-js";
 
@@ -1016,9 +2315,9 @@ async function resolveGroupMentionsIfNeeded(params, text) {
 
 // src/lib/video-send.ts
 import { execFile } from "child_process";
-import fs4 from "fs/promises";
+import fs5 from "fs/promises";
 import os3 from "os";
-import path4 from "path";
+import path5 from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 function planVideoSendMode(params) {
@@ -1035,7 +2334,7 @@ function planVideoSendMode(params) {
       reason: "native-video mode supports one video at a time"
     };
   }
-  const ext = path4.extname(files[0] ?? "").toLowerCase();
+  const ext = path5.extname(files[0] ?? "").toLowerCase();
   if (ext !== ".mp4") {
     return {
       mode: "attachment",
@@ -1129,8 +2428,8 @@ async function maybeProbeVideoFile(filePath) {
   }
 }
 async function generateVideoThumbnail(videoPath) {
-  const dir = await fs4.mkdtemp(path4.join(os3.tmpdir(), "openzca-video-thumb-"));
-  const outputPath = path4.join(dir, "thumbnail.jpg");
+  const dir = await fs5.mkdtemp(path5.join(os3.tmpdir(), "openzca-video-thumb-"));
+  const outputPath = path5.join(dir, "thumbnail.jpg");
   try {
     await runBinary("ffmpeg", [
       "-y",
@@ -1144,15 +2443,15 @@ async function generateVideoThumbnail(videoPath) {
       "2",
       outputPath
     ]);
-    await fs4.access(outputPath);
+    await fs5.access(outputPath);
   } catch (error) {
-    await fs4.rm(dir, { recursive: true, force: true });
+    await fs5.rm(dir, { recursive: true, force: true });
     throw error;
   }
   return {
     path: outputPath,
     cleanup: async () => {
-      await fs4.rm(dir, { recursive: true, force: true });
+      await fs5.rm(dir, { recursive: true, force: true });
     }
   };
 }
@@ -1195,33 +2494,258 @@ async function sendNativeVideo(params) {
   }
 }
 
-// src/cli.ts
-var require2 = createRequire(import.meta.url);
-var { version: PKG_VERSION } = require2("../package.json");
-var program = new Command();
-var EMOJI_REACTION_MAP = {
-  "\u2764\uFE0F": Reactions.HEART,
-  "\u2764": Reactions.HEART,
-  "\u{1F44D}": Reactions.LIKE,
-  "\u{1F606}": Reactions.HAHA,
-  "\u{1F602}": Reactions.HAHA,
-  "\u{1F62E}": Reactions.WOW,
-  "\u{1F62D}": Reactions.CRY,
-  "\u{1F621}": Reactions.ANGRY
-};
-var DEBUG_COMMAND_START = /* @__PURE__ */ new WeakMap();
-function parseDebugFlag(value) {
-  if (!value) return false;
-  const normalized = value.trim().toLowerCase();
-  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
-}
-function getActionCommand(args) {
-  for (let index = args.length - 1; index >= 0; index -= 1) {
-    const item = args[index];
-    if (item instanceof Command) {
-      return item;
-    }
-  }
+// src/lib/reply.ts
+import { ThreadType as ThreadType2 } from "zca-js";
+function prepareReplyMessage(value, params) {
+  const sourceRecord = asReplyMessageRecord(value);
+  const metadata = asOptionalReplyMessageRecord(sourceRecord.metadata);
+  const rawMessageRecord = asOptionalReplyMessageRecord(sourceRecord.rawMessage);
+  const rawPayloadRecord = asOptionalReplyMessageRecord(sourceRecord.rawPayload);
+  const canonicalRecord = rawMessageRecord ?? sourceRecord;
+  const content = parseReplyMessageContent(
+    canonicalRecord.content ?? sourceRecord.content,
+    isLikelyOpenzcaListenPayload(sourceRecord) && !rawMessageRecord
+  );
+  const msgType = requireStringLike(
+    [canonicalRecord.msgType, sourceRecord.msgType, metadata?.msgType],
+    "reply message msgType"
+  );
+  const uidFrom = requireStringLike(
+    [
+      canonicalRecord.uidFrom,
+      sourceRecord.uidFrom,
+      sourceRecord.senderId,
+      sourceRecord.fromId,
+      metadata?.senderId,
+      metadata?.fromId
+    ],
+    "reply message uidFrom"
+  );
+  const msgId = requireStringLike(
+    [canonicalRecord.msgId, sourceRecord.msgId, rawPayloadRecord?.msgId],
+    "reply message msgId"
+  );
+  const cliMsgId = requireStringLike(
+    [canonicalRecord.cliMsgId, sourceRecord.cliMsgId, rawPayloadRecord?.cliMsgId],
+    "reply message cliMsgId"
+  );
+  const ts = requireTsString(
+    [canonicalRecord.ts, sourceRecord.ts, maybeTimestampSecondsToMsString(sourceRecord.timestamp)],
+    "reply message ts"
+  );
+  const ttl = parseReplyMessageTtl(canonicalRecord.ttl ?? sourceRecord.ttl);
+  const propertyExt = parseReplyMessagePropertyExt(canonicalRecord.propertyExt);
+  return {
+    quote: {
+      content,
+      msgType,
+      propertyExt,
+      uidFrom,
+      msgId,
+      cliMsgId,
+      ts,
+      ttl
+    },
+    inferredThreadId: inferReplyMessageThreadId({
+      sourceRecord,
+      canonicalRecord,
+      metadata,
+      threadType: params?.threadType,
+      selfId: params?.selfId
+    })
+  };
+}
+function prepareStoredReplyMessage(value, params) {
+  const record = asReplyMessageRecord(value);
+  const storedThreadType = record.threadType === "group" ? ThreadType2.Group : record.threadType === "user" ? ThreadType2.User : void 0;
+  if (storedThreadType !== void 0 && storedThreadType !== params.threadType) {
+    throw new Error("Reply source thread type does not match --group.");
+  }
+  const storedThreadId = firstString([record.threadId, record.rawThreadId]) ?? void 0;
+  if (storedThreadId && storedThreadId !== params.threadId) {
+    throw new Error("Reply source belongs to a different thread.");
+  }
+  const rawMessage = asOptionalReplyMessageRecord(record.rawMessage);
+  const rawPayload = asOptionalReplyMessageRecord(record.rawPayload);
+  const replyRecord = rawMessage ?? rawPayload;
+  if (!replyRecord) {
+    throw new Error(
+      "Reply source found in DB but has no reusable raw message payload. Re-sync or capture it via listener first."
+    );
+  }
+  return prepareReplyMessage(replyRecord, {
+    threadType: params.threadType,
+    selfId: params.selfId
+  }).quote;
+}
+function asReplyMessageRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Reply message must be a JSON object matching the raw message.data shape.");
+  }
+  return value;
+}
+function asOptionalReplyMessageRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+function parseReplyMessageContent(value, stripOpenzcaDecorations) {
+  if (typeof value === "string") {
+    return stripOpenzcaDecorations ? stripEnrichedReplyDecorations(value) : value;
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  throw new Error("Reply message content must be a string or object.");
+}
+function stripEnrichedReplyDecorations(value) {
+  const lines = value.split("\n");
+  while (lines.length > 0) {
+    const last = lines[lines.length - 1].trim();
+    if (last.startsWith("[reply context: ") || last.startsWith("[reply media attached:") || last.startsWith("[reply media attached ")) {
+      lines.pop();
+      continue;
+    }
+    break;
+  }
+  return lines.join("\n");
+}
+function parseReplyMessagePropertyExt(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Reply message propertyExt must be an object when provided.");
+  }
+  return value;
+}
+function parseReplyMessageTtl(value) {
+  if (value === void 0 || value === null || value === "") {
+    return 0;
+  }
+  const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
+  if (!Number.isFinite(parsed)) {
+    throw new Error("Reply message ttl must be a finite number.");
+  }
+  return Math.trunc(parsed);
+}
+function requireStringLike(values, label) {
+  const value = firstString(values);
+  if (!value) {
+    throw new Error(`Missing ${label}.`);
+  }
+  return value;
+}
+function requireTsString(values, label) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return String(Math.trunc(value));
+    }
+  }
+  throw new Error(`Missing ${label}.`);
+}
+function firstString(values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return String(Math.trunc(value));
+    }
+  }
+  return void 0;
+}
+function maybeTimestampSecondsToMsString(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return void 0;
+  }
+  return String(Math.trunc(value * 1e3));
+}
+function isLikelyOpenzcaListenPayload(record) {
+  return typeof record.threadId === "string" && (typeof record.senderId === "string" || typeof record.chatType === "string" || typeof record.metadata === "object");
+}
+function inferReplyMessageThreadId(params) {
+  const directThreadId = firstString([
+    params.sourceRecord.threadId,
+    params.sourceRecord.targetId,
+    params.sourceRecord.conversationId,
+    params.metadata?.threadId,
+    params.metadata?.targetId
+  ]);
+  if (directThreadId) {
+    return directThreadId;
+  }
+  if (params.threadType === void 0) {
+    return void 0;
+  }
+  const idTo = firstString([
+    params.canonicalRecord.idTo,
+    params.sourceRecord.idTo,
+    params.sourceRecord.toId,
+    params.metadata?.toId
+  ]);
+  if (params.threadType === ThreadType2.Group) {
+    return idTo;
+  }
+  const uidFrom = firstString([
+    params.canonicalRecord.uidFrom,
+    params.sourceRecord.uidFrom,
+    params.sourceRecord.senderId,
+    params.sourceRecord.fromId,
+    params.metadata?.senderId,
+    params.metadata?.fromId
+  ]);
+  if (!uidFrom && !idTo) {
+    return void 0;
+  }
+  if (params.selfId) {
+    if (uidFrom && uidFrom !== params.selfId && uidFrom !== "0") {
+      return uidFrom;
+    }
+    if (idTo && idTo !== params.selfId && idTo !== "0") {
+      return idTo;
+    }
+  }
+  if (uidFrom && uidFrom !== "0") {
+    return uidFrom;
+  }
+  if (idTo && idTo !== "0") {
+    return idTo;
+  }
+  return void 0;
+}
+
+// src/cli.ts
+var require2 = createRequire(import.meta.url);
+var { version: PKG_VERSION } = require2("../package.json");
+var program = new Command();
+var EMOJI_REACTION_MAP = {
+  "\u2764\uFE0F": Reactions.HEART,
+  "\u2764": Reactions.HEART,
+  "\u{1F44D}": Reactions.LIKE,
+  "\u{1F606}": Reactions.HAHA,
+  "\u{1F602}": Reactions.HAHA,
+  "\u{1F62E}": Reactions.WOW,
+  "\u{1F62D}": Reactions.CRY,
+  "\u{1F621}": Reactions.ANGRY
+};
+var DEBUG_COMMAND_START = /* @__PURE__ */ new WeakMap();
+function parseDebugFlag(value) {
+  if (!value) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+function getActionCommand(args) {
+  for (let index = args.length - 1; index >= 0; index -= 1) {
+    const item = args[index];
+    if (item instanceof Command) {
+      return item;
+    }
+  }
   return void 0;
 }
 function commandPathLabel(command) {
@@ -1237,6 +2761,25 @@ function commandPathLabel(command) {
   }
   return names.join(" ");
 }
+function readCliFlag(names) {
+  const argv = process.argv.slice(2);
+  return argv.some((item) => names.includes(item));
+}
+function readCliOptionValue(names) {
+  const argv = process.argv.slice(2);
+  for (let index = argv.length - 1; index >= 0; index -= 1) {
+    const item = argv[index];
+    for (const name of names) {
+      if (item === name) {
+        return argv[index + 1];
+      }
+      if (item.startsWith(`${name}=`)) {
+        return item.slice(name.length + 1);
+      }
+    }
+  }
+  return void 0;
+}
 function getDebugOptions(command) {
   if (command) {
     if (typeof command.optsWithGlobals === "function") {
@@ -1257,9 +2800,9 @@ function resolveDebugEnabled(command) {
 }
 function resolveDebugFilePath(command) {
   const options = getDebugOptions(command);
-  const configured = options.debugFile?.trim() || process.env.OPENZCA_DEBUG_FILE?.trim() || path5.join(APP_HOME, "logs", "openzca-debug.log");
+  const configured = options.debugFile?.trim() || process.env.OPENZCA_DEBUG_FILE?.trim() || path6.join(APP_HOME, "logs", "openzca-debug.log");
   const normalized = normalizeMediaInput(configured);
-  return path5.isAbsolute(normalized) ? normalized : path5.resolve(process.cwd(), normalized);
+  return path6.isAbsolute(normalized) ? normalized : path6.resolve(process.cwd(), normalized);
 }
 function writeDebugLine(event, details, command) {
   if (!resolveDebugEnabled(command)) {
@@ -1270,7 +2813,7 @@ function writeDebugLine(event, details, command) {
 `;
   const filePath = resolveDebugFilePath(command);
   try {
-    fsSync.mkdirSync(path5.dirname(filePath), { recursive: true });
+    fsSync.mkdirSync(path6.dirname(filePath), { recursive: true });
     fsSync.appendFileSync(filePath, line, "utf8");
   } catch {
   }
@@ -1318,8 +2861,27 @@ function output(value, asJson = false) {
   }
   console.log(String(value));
 }
+function shouldOutputJson(opts) {
+  return Boolean(opts?.json) || readCliFlag(["--json", "-j"]);
+}
+function normalizeCommandAliases(argv) {
+  const normalized = [...argv];
+  const dbIndex = normalized.indexOf("db");
+  if (dbIndex === -1 || normalized[dbIndex + 1] !== "chat") {
+    return normalized;
+  }
+  const subcommandOrId = normalized[dbIndex + 2];
+  if (!subcommandOrId || subcommandOrId.startsWith("-")) {
+    return normalized;
+  }
+  if (["list", "info", "messages", "help"].includes(subcommandOrId)) {
+    return normalized;
+  }
+  normalized.splice(dbIndex + 2, 0, "messages");
+  return normalized;
+}
 function asThreadType(groupFlag) {
-  return groupFlag ? ThreadType2.Group : ThreadType2.User;
+  return groupFlag ? ThreadType3.Group : ThreadType3.User;
 }
 function parseBooleanFromEnv(name, fallback) {
   const raw = process.env[name]?.trim();
@@ -1358,14 +2920,14 @@ function collectIdsFromCacheEntries(entries, keys) {
   return ids;
 }
 function getListenerOwnerLockPath(profile) {
-  return path5.join(getProfileDir(profile), "listener-owner.json");
+  return path6.join(getProfileDir(profile), "listener-owner.json");
 }
 function getListenIpcSocketPath(profile) {
   if (process.platform === "win32") {
     const safe = profile.replace(/[^A-Za-z0-9_-]/g, "_");
     return `\\\\.\\pipe\\openzca-listen-${safe}`;
   }
-  return path5.join(getProfileDir(profile), "listen.sock");
+  return path6.join(getProfileDir(profile), "listen.sock");
 }
 function parsePositiveIntFromUnknown(value) {
   if (typeof value === "number" && Number.isFinite(value) && value > 0) {
@@ -1392,7 +2954,7 @@ function isProcessAlive(pid) {
 }
 async function readListenerOwnerRecord(lockPath) {
   try {
-    const raw = await fs5.readFile(lockPath, "utf8");
+    const raw = await fs6.readFile(lockPath, "utf8");
     const parsed = JSON.parse(raw);
     const pid = parsePositiveIntFromUnknown(parsed.pid);
     if (!pid) return null;
@@ -1412,11 +2974,11 @@ async function readActiveListenerOwner(profile) {
   const lockPath = getListenerOwnerLockPath(profile);
   const record = await readListenerOwnerRecord(lockPath);
   if (!record) {
-    await fs5.rm(lockPath, { force: true });
+    await fs6.rm(lockPath, { force: true });
     return null;
   }
   if (!isProcessAlive(record.pid)) {
-    await fs5.rm(lockPath, { force: true });
+    await fs6.rm(lockPath, { force: true });
     return null;
   }
   return record;
@@ -1432,7 +2994,7 @@ async function acquireListenerOwnerLock(profile, sessionId, command) {
   };
   for (let attempt = 0; attempt < 3; attempt += 1) {
     try {
-      await fs5.writeFile(lockPath, `${JSON.stringify(record, null, 2)}
+      await fs6.writeFile(lockPath, `${JSON.stringify(record, null, 2)}
 `, {
         encoding: "utf8",
         flag: "wx"
@@ -1445,7 +3007,7 @@ async function acquireListenerOwnerLock(profile, sessionId, command) {
           released = true;
           const current = await readListenerOwnerRecord(lockPath);
           if (current && current.pid !== process.pid) return;
-          await fs5.rm(lockPath, { force: true });
+          await fs6.rm(lockPath, { force: true });
           writeDebugLine(
             "listen.owner.released",
             {
@@ -1466,7 +3028,7 @@ async function acquireListenerOwnerLock(profile, sessionId, command) {
           `Another openzca listener already owns profile "${profile}" (pid ${owner.pid}).`
         );
       }
-      await fs5.rm(lockPath, { force: true });
+      await fs6.rm(lockPath, { force: true });
     }
   }
   throw new Error(`Unable to acquire listener ownership for profile "${profile}".`);
@@ -1484,7 +3046,7 @@ async function startListenerIpcServer(api, profile, sessionId, command) {
   }
   const socketPath = getListenIpcSocketPath(profile);
   if (process.platform !== "win32") {
-    await fs5.rm(socketPath, { force: true });
+    await fs6.rm(socketPath, { force: true });
   }
   const uploadTimeoutMs = parsePositiveIntFromEnv(
     "OPENZCA_UPLOAD_IPC_HANDLER_TIMEOUT_MS",
@@ -1529,7 +3091,7 @@ async function startListenerIpcServer(api, profile, sessionId, command) {
         fail(parsed.requestId, "Invalid upload payload.");
         return;
       }
-      const threadType = parsed.threadType === "group" ? ThreadType2.Group : ThreadType2.User;
+      const threadType = parsed.threadType === "group" ? ThreadType3.Group : ThreadType3.User;
       const requestTimeoutMs = parsePositiveIntFromUnknown(parsed.uploadTimeoutMs) ?? uploadTimeoutMs;
       writeDebugLine(
         "listen.ipc.upload.start",
@@ -1656,7 +3218,7 @@ async function startListenerIpcServer(api, profile, sessionId, command) {
         server.close(() => resolve());
       });
       if (process.platform !== "win32") {
-        await fs5.rm(socketPath, { force: true });
+        await fs6.rm(socketPath, { force: true });
       }
       writeDebugLine(
         "listen.ipc.stopped",
@@ -1686,7 +3248,7 @@ async function tryUploadViaListenerIpc(profile, threadId, threadType, attachment
     {
       profile,
       threadId,
-      threadType: threadType === ThreadType2.Group ? "group" : "user",
+      threadType: threadType === ThreadType3.Group ? "group" : "user",
       attachmentCount: attachments.length,
       socketPath,
       requestId,
@@ -1730,7 +3292,7 @@ async function tryUploadViaListenerIpc(profile, threadId, threadType, attachment
         requestId,
         profile,
         threadId,
-        threadType: threadType === ThreadType2.Group ? "group" : "user",
+        threadType: threadType === ThreadType3.Group ? "group" : "user",
         attachments
       };
       socket.write(`${JSON.stringify(payload)}
@@ -1792,21 +3354,21 @@ async function tryUploadViaListenerIpc(profile, threadId, threadType, attachment
 }
 async function resolveUploadThreadType(api, profile, threadId, groupFlag, command) {
   if (groupFlag) {
-    return { type: ThreadType2.Group, reason: "explicit_group_flag" };
+    return { type: ThreadType3.Group, reason: "explicit_group_flag" };
   }
   const autoDetectEnabled = parseBooleanFromEnv("OPENZCA_UPLOAD_AUTO_THREAD_TYPE", false);
   if (!autoDetectEnabled) {
-    return { type: ThreadType2.User, reason: "auto_detect_disabled" };
+    return { type: ThreadType3.User, reason: "auto_detect_disabled" };
   }
   try {
     const cache = await readCache(profile);
     const groupIds = collectIdsFromCacheEntries(cache.groups, ["groupId", "grid", "threadId", "id"]);
     if (groupIds.has(threadId)) {
-      return { type: ThreadType2.Group, reason: "cache_group_match" };
+      return { type: ThreadType3.Group, reason: "cache_group_match" };
     }
     const friendIds = collectIdsFromCacheEntries(cache.friends, ["userId", "uid", "id", "threadId"]);
     if (friendIds.has(threadId)) {
-      return { type: ThreadType2.User, reason: "cache_friend_match" };
+      return { type: ThreadType3.User, reason: "cache_friend_match" };
     }
   } catch (error) {
     writeDebugLine(
@@ -1821,7 +3383,7 @@ async function resolveUploadThreadType(api, profile, threadId, groupFlag, comman
   }
   const probeEnabled = parseBooleanFromEnv("OPENZCA_UPLOAD_GROUP_PROBE", true);
   if (!probeEnabled) {
-    return { type: ThreadType2.User, reason: "probe_disabled" };
+    return { type: ThreadType3.User, reason: "probe_disabled" };
   }
   const probeTimeoutMs = parsePositiveIntFromEnv("OPENZCA_UPLOAD_GROUP_PROBE_TIMEOUT_MS", 5e3);
   try {
@@ -1831,7 +3393,7 @@ async function resolveUploadThreadType(api, profile, threadId, groupFlag, comman
       `Timed out waiting ${probeTimeoutMs}ms while probing group thread type.`
     );
     if (groupInfo?.gridInfoMap?.[threadId]) {
-      return { type: ThreadType2.Group, reason: "probe_group_match" };
+      return { type: ThreadType3.Group, reason: "probe_group_match" };
     }
   } catch (error) {
     writeDebugLine(
@@ -1844,7 +3406,7 @@ async function resolveUploadThreadType(api, profile, threadId, groupFlag, comman
       command
     );
   }
-  return { type: ThreadType2.User, reason: "default_user" };
+  return { type: ThreadType3.User, reason: "default_user" };
 }
 function parseReaction(input) {
   const normalized = input.trim();
@@ -1927,6 +3489,675 @@ async function requireApi(command) {
   const api = await loginWithStoredCredentials(profile);
   return { profile, api };
 }
+function toDbThreadType(groupFlag) {
+  return groupFlag ? "group" : "user";
+}
+function getDbWriteOverride(opts) {
+  if (!opts || typeof opts.db !== "boolean") {
+    return void 0;
+  }
+  return opts.db;
+}
+async function shouldWriteToDb(profile, override) {
+  if (typeof override === "boolean") {
+    return override;
+  }
+  return isDbEnabled(profile);
+}
+async function resolveSendReplyQuote(params) {
+  const replyId = params.replyId?.trim();
+  const replyMessage = params.replyMessage?.trim();
+  if (replyId && replyMessage) {
+    throw new Error("Use either --reply-id or --reply-message, not both.");
+  }
+  if (!replyId && !replyMessage) {
+    return void 0;
+  }
+  if (replyId) {
+    if (!await shouldWriteToDb(params.profile)) {
+      throw new Error("`--reply-id` requires the local DB. Enable DB/listen sync first.");
+    }
+    const row = await getMessageById({
+      profile: params.profile,
+      id: replyId
+    });
+    if (!row) {
+      throw new Error(`Reply source not found in DB: ${replyId}`);
+    }
+    if (row.threadType === "group" !== (params.threadType === ThreadType3.Group)) {
+      throw new Error("Reply source thread type does not match --group.");
+    }
+    if (row.threadId !== params.threadId) {
+      throw new Error("Reply source belongs to a different thread.");
+    }
+    if (!row.rawMessage || typeof row.rawMessage !== "object") {
+      if (!row.rawPayload || typeof row.rawPayload !== "object") {
+        throw new Error(
+          "Reply source found in DB but has no reusable raw message payload. Re-sync or capture it via listener first."
+        );
+      }
+    }
+    return prepareStoredReplyMessage(row, {
+      threadId: params.threadId,
+      threadType: params.threadType,
+      selfId: params.api.getOwnId()
+    });
+  }
+  let parsedReplyMessage;
+  try {
+    parsedReplyMessage = JSON.parse(replyMessage);
+  } catch (error) {
+    throw new Error(
+      `Invalid JSON for --reply-message: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const preparedReply = prepareReplyMessage(parsedReplyMessage, {
+    threadType: params.threadType,
+    selfId: params.api.getOwnId()
+  });
+  if (preparedReply.inferredThreadId && preparedReply.inferredThreadId !== params.threadId) {
+    throw new Error("Reply message belongs to a different thread.");
+  }
+  return preparedReply.quote;
+}
+function scheduleDbWrite(profile, command, event, task) {
+  enqueueDbWrite(profile, async () => {
+    try {
+      await task();
+    } catch (error) {
+      writeDebugLine(
+        event,
+        {
+          profile,
+          message: error instanceof Error ? error.message : String(error)
+        },
+        command
+      );
+    }
+  });
+}
+function extractResponseMessageIds(value) {
+  const ids = /* @__PURE__ */ new Set();
+  const visit = (item) => {
+    if (!item) return;
+    if (Array.isArray(item)) {
+      for (const nested of item) {
+        visit(nested);
+      }
+      return;
+    }
+    if (typeof item !== "object") {
+      return;
+    }
+    const record = item;
+    const msgId = normalizeCachedId(record.msgId);
+    if (msgId) {
+      ids.add(msgId);
+    }
+    for (const key of ["message", "attachment", "attachments", "results", "response"]) {
+      if (key in record) {
+        visit(record[key]);
+      }
+    }
+  };
+  visit(value);
+  return Array.from(ids);
+}
+async function persistOutgoingMessageBestEffort(params) {
+  const selfId = params.api.getOwnId();
+  const threadType = toDbThreadType(params.group);
+  const scopeThreadId = resolveScopeThreadId({
+    threadType,
+    rawThreadId: params.threadId,
+    senderId: selfId,
+    toId: params.threadId,
+    selfId
+  });
+  const messageIds = extractResponseMessageIds(params.response);
+  const baseRecord = {
+    profile: params.profile,
+    scopeThreadId,
+    rawThreadId: params.threadId,
+    threadType,
+    peerId: threadType === "user" ? scopeThreadId : void 0,
+    senderId: selfId,
+    senderName: void 0,
+    toId: threadType === "user" ? params.threadId : void 0,
+    timestampMs: Date.now(),
+    msgType: params.msgType,
+    contentText: params.text,
+    media: params.media,
+    source: "send",
+    rawPayloadJson: params.rawPayload ? JSON.stringify(params.rawPayload) : void 0,
+    rawMessageJson: JSON.stringify(params.response)
+  };
+  if (messageIds.length === 0) {
+    await persistMessage(baseRecord);
+    return;
+  }
+  for (const msgId of messageIds) {
+    await persistMessage({
+      ...baseRecord,
+      msgId
+    });
+  }
+}
+async function persistGroupMembersSnapshot(profile, groupId, api) {
+  const rows = await listGroupMemberRows(api, groupId);
+  const snapshotAtMs = Date.now();
+  await replaceThreadMembers(
+    profile,
+    groupId,
+    rows.map((row) => ({
+      profile,
+      scopeThreadId: groupId,
+      userId: row.userId,
+      displayName: row.displayName,
+      zaloName: row.zaloName,
+      rawJson: JSON.stringify(row),
+      snapshotAtMs
+    }))
+  );
+}
+async function persistFriendDirectory(profile, api) {
+  const friends = await api.getAllFriends();
+  const nameById = /* @__PURE__ */ new Map();
+  for (const friend2 of friends) {
+    const record = friend2;
+    const userId = normalizeCachedId(record.userId);
+    if (!userId) continue;
+    const displayName = typeof record.displayName === "string" && record.displayName.trim() ? record.displayName.trim() : void 0;
+    const zaloName = typeof record.zaloName === "string" && record.zaloName.trim() ? record.zaloName.trim() : void 0;
+    const avatar = typeof record.avatar === "string" && record.avatar.trim() ? record.avatar.trim() : void 0;
+    const title = displayName || zaloName || userId;
+    await persistFriend({
+      profile,
+      userId,
+      displayName,
+      zaloName,
+      avatar,
+      accountStatus: typeof record.accountStatus === "number" && Number.isFinite(record.accountStatus) ? Math.trunc(record.accountStatus) : void 0,
+      rawJson: JSON.stringify(friend2)
+    });
+    await persistThread({
+      profile,
+      scopeThreadId: userId,
+      rawThreadId: userId,
+      threadType: "user",
+      peerId: userId,
+      title,
+      rawJson: JSON.stringify(friend2)
+    });
+    nameById.set(userId, title);
+  }
+  return nameById;
+}
+function parseSinceDuration(label, value) {
+  const parsed = parseDurationInput(value);
+  if (parsed !== void 0) {
+    return parsed;
+  }
+  if (!value || !value.trim()) {
+    return void 0;
+  }
+  throw new Error(
+    `${label} must be a relative duration like 30s, 7m, 24h, 7d, or 2w.`
+  );
+}
+function parseTimeBoundary(label, value) {
+  const parsed = parseTimeBoundaryInput(value);
+  if (parsed !== void 0) {
+    return parsed;
+  }
+  if (!value || !value.trim()) {
+    return void 0;
+  }
+  throw new Error(
+    `${label} must be an ISO timestamp, a date, or unix seconds/ms.`
+  );
+}
+function pickExclusiveOption(primaryLabel, primaryValue, aliasLabel, aliasValue) {
+  if (primaryValue?.trim() && aliasValue?.trim()) {
+    throw new Error(`Use either ${primaryLabel} or ${aliasLabel}, not both.`);
+  }
+  return primaryValue?.trim() ? primaryValue : aliasValue?.trim() ? aliasValue : void 0;
+}
+function resolveMessageTimeRange(opts) {
+  const sinceValue = opts.since?.trim() ? opts.since : void 0;
+  const fromValue = opts.from?.trim() ? opts.from : void 0;
+  const untilValue = pickExclusiveOption("--until", opts.until, "--to", opts.to);
+  if (sinceValue && fromValue) {
+    throw new Error("Use either --since for a rolling window or --from/--to for an explicit range, not both.");
+  }
+  if (sinceValue && untilValue) {
+    throw new Error("Do not combine --since with --to/--until. Use --from/--to for explicit ranges.");
+  }
+  return {
+    sinceMs: sinceValue ? parseSinceDuration("--since", sinceValue) : parseTimeBoundary("--from", fromValue),
+    untilMs: parseTimeBoundary("--to/--until", untilValue)
+  };
+}
+function resolveMessageQueryOptions(opts) {
+  const { sinceMs, untilMs } = resolveMessageTimeRange(opts);
+  if (opts.all && opts.limit?.trim()) {
+    throw new Error("Use either --all or --limit, not both.");
+  }
+  const explicitLimit = parsePositiveIntOption("--limit", opts.limit);
+  const hasTimeFilter = sinceMs !== void 0 || untilMs !== void 0;
+  const limit = opts.all ? void 0 : explicitLimit ?? (hasTimeFilter ? void 0 : 20);
+  const newestFirst = !Boolean(opts.oldestFirst);
+  return {
+    sinceMs,
+    untilMs,
+    limit,
+    newestFirst
+  };
+}
+async function resolveStoredChatThreadType(profile, chatId, forceGroup) {
+  if (forceGroup) {
+    return "group";
+  }
+  const row = await getThreadInfo({ profile, threadId: chatId });
+  return row?.threadType === "group" ? "group" : "user";
+}
+async function confirmDestructiveAction(message) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("Refusing destructive operation without --yes in non-interactive mode.");
+  }
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const answer = (await rl.question(`${message} [y/N] `)).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+function createSyncProgressReporter() {
+  if (!process.stderr.isTTY) {
+    return () => {
+    };
+  }
+  return (message) => {
+    process.stderr.write(`[db sync] ${message}
+`);
+  };
+}
+function createDbSyncSummary(profile, dbPath, count) {
+  return {
+    profile,
+    dbPath,
+    windowCount: count,
+    groupsSynced: 0,
+    groupMessagesImported: 0,
+    friendsSynced: 0,
+    chatsSynced: 0,
+    dmMessagesImported: 0,
+    syncState: []
+  };
+}
+function resolveSyncWindowCount(value) {
+  return parsePositiveIntOption("--count", value) ?? 200;
+}
+async function collectConversationIds(api) {
+  let pinnedIds = /* @__PURE__ */ new Set();
+  let hiddenIds = /* @__PURE__ */ new Set();
+  try {
+    const pins = await api.getPinConversations();
+    pinnedIds = new Set((pins.conversations ?? []).map((value) => String(value)));
+  } catch {
+  }
+  try {
+    const hidden = await api.getHiddenConversations();
+    hiddenIds = new Set((hidden.threads ?? []).map((item) => String(item.thread_id)));
+  } catch {
+  }
+  return { pinnedIds, hiddenIds };
+}
+async function prepareDbGroupTarget(params) {
+  await persistThread({
+    profile: params.profile,
+    scopeThreadId: params.groupId,
+    rawThreadId: params.groupId,
+    threadType: "group",
+    title: params.title,
+    isPinned: params.pinnedIds.has(params.groupId),
+    isHidden: params.hiddenIds.has(params.groupId),
+    rawJson: params.rawJson
+  });
+  await persistGroupMembersSnapshot(params.profile, params.groupId, params.api);
+}
+async function syncDbGroupHistoryFull(params) {
+  if (params.targetGroupIds.size === 0) {
+    return;
+  }
+  const getStoredGroupMessageCount = async () => {
+    let total = 0;
+    for (const groupId of params.targetGroupIds) {
+      const row = await getThreadInfo({
+        profile: params.profile,
+        threadId: groupId,
+        threadType: "group"
+      });
+      const count = row && typeof row.messageCount === "number" && Number.isFinite(row.messageCount) ? row.messageCount : 0;
+      total += count;
+    }
+    return total;
+  };
+  const persistMessages = async (messages) => {
+    for (const message of messages) {
+      if (!params.targetGroupIds.has(message.threadId)) {
+        continue;
+      }
+      processed += 1;
+      await persistMessage(
+        toDbRecordFromRecentMessage({
+          profile: params.profile,
+          message,
+          source: "sync_group",
+          selfId: params.selfId,
+          title: params.titleById.get(message.threadId)
+        })
+      );
+    }
+  };
+  const beforeCount = await getStoredGroupMessageCount();
+  let processed = 0;
+  let completeness = "complete";
+  let stopReason = "exhausted";
+  let pagesRequested = 0;
+  let listenerImportedCount = 0;
+  try {
+    params.progress?.(`syncing full history for ${params.targetGroupIds.size} group(s)`);
+    const result = await crawlGroupHistoryViaListener(params.api, {
+      maxPages: Number.MAX_SAFE_INTEGER,
+      idleTimeoutMs: 15e3,
+      onMessages: persistMessages,
+      onPage: ({ pagesRequested: pagesRequested2, filteredCount }) => {
+        params.progress?.(
+          `groups page ${pagesRequested2}: batch ${filteredCount}, processed ${processed}`
+        );
+      }
+    });
+    completeness = result.stopReason === "exhausted" ? "complete" : result.stopReason === "max_pages" || result.stopReason === "timeout" ? "partial" : "window";
+    stopReason = result.stopReason;
+    pagesRequested = result.pagesRequested;
+    listenerImportedCount = await getStoredGroupMessageCount() - beforeCount;
+  } catch (error) {
+    stopReason = `fallback_window:${toErrorText(error)}`;
+    completeness = "window";
+  }
+  const fallbackCount = 200;
+  params.progress?.(`merging recent group API window (${fallbackCount} per group)`);
+  const beforeApiCount = await getStoredGroupMessageCount();
+  for (const groupId of params.targetGroupIds) {
+    const messages = await fetchRecentGroupMessagesViaApi(params.api, groupId, fallbackCount);
+    await persistMessages(messages);
+    params.progress?.(`group ${groupId}: fetched ${messages.length} message(s) from group history API`);
+  }
+  const afterCount = await getStoredGroupMessageCount();
+  const apiAddedCount = afterCount - beforeApiCount;
+  if (apiAddedCount > 0) {
+    completeness = "window";
+    if (stopReason === "exhausted" && listenerImportedCount === 0) {
+      stopReason = "fallback_window:empty_listener_result";
+    } else if (stopReason === "exhausted") {
+      stopReason = "window_topoff:listener_incomplete";
+    }
+  }
+  const imported = Math.max(afterCount - beforeCount, 0);
+  for (const groupId of params.targetGroupIds) {
+    await setSyncState({
+      profile: params.profile,
+      scopeThreadId: groupId,
+      threadType: "group",
+      status: "synced",
+      completeness
+    });
+  }
+  params.summary.groupsSynced += params.targetGroupIds.size;
+  params.summary.groupMessagesImported += imported;
+  params.summary.syncState.push({
+    kind: "groups",
+    groups: params.targetGroupIds.size,
+    imported,
+    completeness,
+    stopReason,
+    pagesRequested
+  });
+}
+async function syncDbFriendDirectory(params) {
+  params.progress?.("syncing friend directory");
+  const names = await persistFriendDirectory(params.profile, params.api);
+  params.summary.friendsSynced += names.size;
+  params.progress?.(`friend directory synced: ${names.size} friend(s)`);
+  params.summary.syncState.push({
+    kind: "friends",
+    imported: names.size
+  });
+  return names;
+}
+async function syncDbChatThread(params) {
+  const scopeThreadId = resolveScopeThreadId({
+    threadType: "user",
+    rawThreadId: params.threadId,
+    senderId: params.selfId,
+    toId: params.threadId,
+    selfId: params.selfId
+  });
+  await persistThread({
+    profile: params.profile,
+    scopeThreadId,
+    rawThreadId: params.threadId,
+    threadType: "user",
+    peerId: scopeThreadId,
+    title: params.title,
+    isPinned: params.pinnedIds.has(params.threadId) || params.pinnedIds.has(scopeThreadId),
+    isHidden: params.hiddenIds.has(params.threadId) || params.hiddenIds.has(scopeThreadId)
+  });
+  const messages = await fetchRecentUserMessagesViaListener(params.api, params.threadId, params.count);
+  for (const message of messages) {
+    await persistMessage(
+      toDbRecordFromRecentMessage({
+        profile: params.profile,
+        message,
+        source: "sync_dm_best_effort",
+        selfId: params.selfId,
+        title: params.title
+      })
+    );
+  }
+  await setSyncState({
+    profile: params.profile,
+    scopeThreadId,
+    threadType: "user",
+    status: "synced",
+    completeness: "best_effort"
+  });
+  params.summary.chatsSynced += 1;
+  params.summary.dmMessagesImported += messages.length;
+  params.progress?.(`chat ${scopeThreadId}: imported ${messages.length} message(s)`);
+  params.summary.syncState.push({
+    kind: "chat",
+    chatId: scopeThreadId,
+    rawThreadId: params.threadId,
+    imported: messages.length,
+    completeness: "best_effort"
+  });
+}
+async function syncDbChatsBestEffort(params) {
+  const scanLimit = Math.max(params.count * 10, 500);
+  params.progress?.(`scanning recent DM/chat windows (target window ${params.count}, scan limit ${scanLimit})`);
+  const messages = await fetchRecentUserMessagesAcrossThreads(params.api, scanLimit);
+  const seenScopes = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    const title = params.titleById.get(message.threadId);
+    const record = toDbRecordFromRecentMessage({
+      profile: params.profile,
+      message,
+      source: "sync_dm_best_effort",
+      selfId: params.selfId,
+      title
+    });
+    await persistThread({
+      profile: params.profile,
+      scopeThreadId: record.scopeThreadId,
+      rawThreadId: record.rawThreadId,
+      threadType: "user",
+      peerId: record.scopeThreadId,
+      title,
+      isPinned: params.pinnedIds.has(record.rawThreadId) || params.pinnedIds.has(record.scopeThreadId),
+      isHidden: params.hiddenIds.has(record.rawThreadId) || params.hiddenIds.has(record.scopeThreadId)
+    });
+    await persistMessage(record);
+    if (!seenScopes.has(record.scopeThreadId)) {
+      seenScopes.add(record.scopeThreadId);
+      await setSyncState({
+        profile: params.profile,
+        scopeThreadId: record.scopeThreadId,
+        threadType: "user",
+        status: "synced",
+        completeness: "best_effort"
+      });
+    }
+  }
+  params.summary.chatsSynced += seenScopes.size;
+  params.summary.dmMessagesImported += messages.length;
+  params.progress?.(`chat scan finished: ${messages.length} message(s) across ${seenScopes.size} chat(s)`);
+  params.summary.syncState.push({
+    kind: "chats",
+    imported: messages.length,
+    chats: seenScopes.size,
+    completeness: "best_effort"
+  });
+}
+async function runDbSync(params) {
+  const { profile, api } = await requireApi(params.command);
+  const dbPath = await resolveDbPath(profile);
+  params.progress?.(`starting sync for profile ${profile}`);
+  const summary = createDbSyncSummary(
+    profile,
+    dbPath,
+    params.mode === "all" || params.mode === "chats" || params.mode === "chat" ? params.count : void 0
+  );
+  const selfId = api.getOwnId();
+  const selfInfo = normalizeMeInfoOutput(await api.fetchAccountInfo());
+  await persistSelfProfile({
+    profile,
+    userId: selfId,
+    displayName: typeof selfInfo.displayName === "string" && selfInfo.displayName.trim() ? selfInfo.displayName.trim() : void 0,
+    infoJson: JSON.stringify(selfInfo)
+  });
+  const { pinnedIds, hiddenIds } = await collectConversationIds(api);
+  let friendNames = /* @__PURE__ */ new Map();
+  if (params.mode === "all" || params.mode === "friends" || params.mode === "chats") {
+    friendNames = await syncDbFriendDirectory({
+      profile,
+      api,
+      summary,
+      progress: params.progress
+    });
+  }
+  if (params.mode === "all" || params.mode === "groups") {
+    const groups = await buildGroupsDetailed(api);
+    const targetGroupIds = /* @__PURE__ */ new Set();
+    const titleById = /* @__PURE__ */ new Map();
+    for (const group2 of groups) {
+      const record = group2;
+      const groupId = normalizeCachedId(record.groupId);
+      if (!groupId) continue;
+      const title = typeof record.name === "string" && record.name.trim() ? record.name.trim() : typeof record.groupName === "string" && record.groupName.trim() ? record.groupName.trim() : void 0;
+      targetGroupIds.add(groupId);
+      titleById.set(groupId, title);
+      await prepareDbGroupTarget({
+        profile,
+        api,
+        groupId,
+        title,
+        rawJson: JSON.stringify(group2),
+        pinnedIds,
+        hiddenIds
+      });
+    }
+    await syncDbGroupHistoryFull({
+      profile,
+      api,
+      selfId,
+      targetGroupIds,
+      titleById,
+      summary,
+      progress: params.progress
+    });
+  }
+  if (params.mode === "group") {
+    if (!params.groupId) {
+      throw new Error("Missing group id for db sync group.");
+    }
+    const groupInfo = await api.getGroupInfo(params.groupId);
+    const group2 = groupInfo.gridInfoMap[params.groupId];
+    const title = typeof group2?.name === "string" && group2.name.trim() ? group2.name.trim() : void 0;
+    await prepareDbGroupTarget({
+      profile,
+      api,
+      groupId: params.groupId,
+      title,
+      rawJson: group2 ? JSON.stringify(group2) : void 0,
+      pinnedIds,
+      hiddenIds
+    });
+    await syncDbGroupHistoryFull({
+      profile,
+      api,
+      selfId,
+      targetGroupIds: /* @__PURE__ */ new Set([params.groupId]),
+      titleById: /* @__PURE__ */ new Map([[params.groupId, title]]),
+      summary,
+      progress: params.progress
+    });
+  }
+  if (params.mode === "chat") {
+    if (!params.threadId) {
+      throw new Error("Missing chat id for db sync chat.");
+    }
+    if (friendNames.size === 0) {
+      friendNames = await persistFriendDirectory(profile, api);
+    }
+    await syncDbChatThread({
+      profile,
+      api,
+      selfId,
+      threadId: params.threadId,
+      count: params.count,
+      title: friendNames.get(params.threadId),
+      pinnedIds,
+      hiddenIds,
+      summary,
+      progress: params.progress
+    });
+  }
+  if (params.mode === "all" || params.mode === "chats") {
+    if (friendNames.size === 0) {
+      friendNames = await persistFriendDirectory(profile, api);
+    }
+    await syncDbChatsBestEffort({
+      profile,
+      api,
+      selfId,
+      count: params.count,
+      titleById: friendNames,
+      pinnedIds,
+      hiddenIds,
+      summary,
+      progress: params.progress
+    });
+  }
+  params.progress?.(
+    `done: groups=${summary.groupsSynced}, groupMessages=${summary.groupMessagesImported}, friends=${summary.friendsSynced}, chats=${summary.chatsSynced}, dmMessages=${summary.dmMessagesImported}`
+  );
+  return summary;
+}
 async function buildGroupsDetailed(api) {
   const groups = await api.getAllGroups();
   const ids = Object.keys(groups.gridVerMap ?? {});
@@ -2309,7 +4540,7 @@ function normalizeGroupHistoryMessages(messages, fallbackThreadId) {
     const threadIdRaw = String(raw.idTo ?? "").trim();
     normalized.push({
       threadId: threadIdRaw || fallbackThreadId,
-      type: ThreadType2.Group,
+      type: ThreadType3.Group,
       data: {
         actionId: typeof raw.actionId === "string" && raw.actionId.trim() ? raw.actionId : void 0,
         msgId: String(raw.msgId ?? ""),
@@ -2383,12 +4614,168 @@ async function fetchRecentGroupMessagesViaApi(api, threadId, count) {
   return fetchRecentGroupMessagesViaListener(api, threadId, count);
 }
 async function fetchRecentGroupMessagesViaListener(api, threadId, count) {
+  const result = await crawlGroupHistoryViaListener(api, {
+    threadId,
+    limit: count,
+    maxPages: parsePositiveIntFromEnv("OPENZCA_RECENT_GROUP_MAX_PAGES", 20),
+    idleTimeoutMs: 12e3
+  });
+  return result.messages;
+}
+async function crawlGroupHistoryViaListener(api, options) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let stopReason = "closed";
+    const shouldCollect = options.limit != null || !options.onMessages;
+    const collected = [];
+    const seenMessageKeys = /* @__PURE__ */ new Set();
+    const requestedCursors = /* @__PURE__ */ new Set();
+    let pagesRequested = 0;
+    let idleTimer;
+    let processing = Promise.resolve();
+    const toKey = (message) => {
+      const msgId = String(message.data?.msgId ?? "");
+      const cliMsgId = String(message.data?.cliMsgId ?? "");
+      return `${message.threadId}:${msgId}:${cliMsgId}`;
+    };
+    const requestPage = (lastId) => {
+      const cursor = String(lastId ?? "").trim();
+      if (cursor) {
+        if (requestedCursors.has(cursor)) return false;
+        requestedCursors.add(cursor);
+      }
+      pagesRequested += 1;
+      api.listener.requestOldMessages(ThreadType3.Group, cursor || null);
+      return true;
+    };
+    const armIdleTimer = () => {
+      if (idleTimer) {
+        clearTimeout(idleTimer);
+      }
+      idleTimer = setTimeout(() => {
+        finish(void 0, "timeout");
+      }, options.idleTimeoutMs);
+    };
+    const cleanup = () => {
+      if (idleTimer) {
+        clearTimeout(idleTimer);
+      }
+      api.listener.off("connected", onConnected);
+      api.listener.off("old_messages", onOldMessages);
+      api.listener.off("error", onError);
+      api.listener.off("closed", onClosed);
+      try {
+        api.listener.stop();
+      } catch {
+      }
+    };
+    const finish = (error, reason) => {
+      if (settled) return;
+      settled = true;
+      if (reason) {
+        stopReason = reason;
+      }
+      void processing.then(() => {
+        cleanup();
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve({
+          messages: options.limit != null ? sortRecentMessagesNewestFirst(collected).slice(0, options.limit) : collected,
+          stopReason,
+          pagesRequested
+        });
+      }).catch((processingError) => {
+        cleanup();
+        reject(processingError);
+      });
+    };
+    const onConnected = () => {
+      try {
+        armIdleTimer();
+        requestPage(null);
+      } catch (error) {
+        finish(error, "closed");
+      }
+    };
+    const onOldMessages = (messages, type) => {
+      if (type !== ThreadType3.Group) return;
+      armIdleTimer();
+      const typedMessages = messages;
+      processing = processing.then(async () => {
+        const filtered = [];
+        for (const message of typedMessages) {
+          if (options.threadId && message.threadId !== options.threadId) {
+            continue;
+          }
+          const key = toKey(message);
+          if (seenMessageKeys.has(key)) continue;
+          seenMessageKeys.add(key);
+          if (shouldCollect) {
+            collected.push(message);
+          }
+          filtered.push(message);
+        }
+        if (filtered.length > 0) {
+          await options.onMessages?.(filtered);
+        }
+        await options.onPage?.({
+          pagesRequested,
+          filteredCount: filtered.length,
+          collectedCount: collected.length
+        });
+        if (options.limit != null && collected.length >= options.limit) {
+          finish(void 0, "limit");
+          return;
+        }
+        if (typedMessages.length === 0) {
+          finish(void 0, "exhausted");
+          return;
+        }
+        if (pagesRequested >= options.maxPages) {
+          finish(void 0, "max_pages");
+          return;
+        }
+        const cursorCandidates = getRecentPageCursors(typedMessages);
+        let requested = false;
+        for (const cursor of cursorCandidates) {
+          if (requestPage(cursor)) {
+            requested = true;
+            break;
+          }
+        }
+        if (!requested) {
+          finish(void 0, "exhausted");
+        }
+      }).catch((error) => {
+        finish(error, "closed");
+      });
+    };
+    const onError = (error) => {
+      finish(error, "closed");
+    };
+    const onClosed = () => {
+      finish(void 0, "closed");
+    };
+    api.listener.on("connected", onConnected);
+    api.listener.on("old_messages", onOldMessages);
+    api.listener.on("error", onError);
+    api.listener.on("closed", onClosed);
+    try {
+      api.listener.start();
+    } catch (error) {
+      finish(error);
+    }
+  });
+}
+async function fetchRecentUserMessagesViaListener(api, threadId, count) {
   return new Promise((resolve, reject) => {
     let settled = false;
     const collected = [];
     const seenMessageKeys = /* @__PURE__ */ new Set();
     const requestedCursors = /* @__PURE__ */ new Set();
-    const maxPages = parsePositiveIntFromEnv("OPENZCA_RECENT_GROUP_MAX_PAGES", 20);
+    const maxPages = parsePositiveIntFromEnv("OPENZCA_RECENT_USER_MAX_PAGES", 20);
     let pagesRequested = 0;
     const toKey = (message) => {
       const msgId = String(message.data?.msgId ?? "");
@@ -2402,7 +4789,7 @@ async function fetchRecentGroupMessagesViaListener(api, threadId, count) {
         requestedCursors.add(cursor);
       }
       pagesRequested += 1;
-      api.listener.requestOldMessages(ThreadType2.Group, cursor || null);
+      api.listener.requestOldMessages(ThreadType3.User, cursor || null);
       return true;
     };
     const cleanup = () => {
@@ -2434,7 +4821,7 @@ async function fetchRecentGroupMessagesViaListener(api, threadId, count) {
       }
     };
     const onOldMessages = (messages, type) => {
-      if (type !== ThreadType2.Group) return;
+      if (type !== ThreadType3.User) return;
       const typedMessages = messages;
       for (const message of typedMessages) {
         if (message.threadId === threadId) {
@@ -2490,7 +4877,7 @@ async function fetchRecentGroupMessagesViaListener(api, threadId, count) {
     }
   });
 }
-async function fetchRecentUserMessagesViaListener(api, threadId, count) {
+async function fetchRecentUserMessagesAcrossThreads(api, maxMessages) {
   return new Promise((resolve, reject) => {
     let settled = false;
     const collected = [];
@@ -2501,7 +4888,7 @@ async function fetchRecentUserMessagesViaListener(api, threadId, count) {
     const toKey = (message) => {
       const msgId = String(message.data?.msgId ?? "");
       const cliMsgId = String(message.data?.cliMsgId ?? "");
-      return `${msgId}:${cliMsgId}`;
+      return `${message.threadId}:${msgId}:${cliMsgId}`;
     };
     const requestPage = (lastId) => {
       const cursor = String(lastId ?? "").trim();
@@ -2510,7 +4897,7 @@ async function fetchRecentUserMessagesViaListener(api, threadId, count) {
         requestedCursors.add(cursor);
       }
       pagesRequested += 1;
-      api.listener.requestOldMessages(ThreadType2.User, cursor || null);
+      api.listener.requestOldMessages(ThreadType3.User, cursor || null);
       return true;
     };
     const cleanup = () => {
@@ -2532,7 +4919,7 @@ async function fetchRecentUserMessagesViaListener(api, threadId, count) {
         reject(error);
         return;
       }
-      resolve(sortRecentMessagesNewestFirst(collected).slice(0, count));
+      resolve(sortRecentMessagesNewestFirst(collected).slice(0, maxMessages));
     };
     const onConnected = () => {
       try {
@@ -2542,25 +4929,15 @@ async function fetchRecentUserMessagesViaListener(api, threadId, count) {
       }
     };
     const onOldMessages = (messages, type) => {
-      if (type !== ThreadType2.User) return;
+      if (type !== ThreadType3.User) return;
       const typedMessages = messages;
       for (const message of typedMessages) {
-        if (message.threadId === threadId) {
-          const key = toKey(message);
-          if (seenMessageKeys.has(key)) continue;
-          seenMessageKeys.add(key);
-          collected.push(message);
-        }
-      }
-      if (collected.length >= count) {
-        finish();
-        return;
-      }
-      if (typedMessages.length === 0) {
-        finish();
-        return;
+        const key = toKey(message);
+        if (seenMessageKeys.has(key)) continue;
+        seenMessageKeys.add(key);
+        collected.push(message);
       }
-      if (pagesRequested >= maxPages) {
+      if (collected.length >= maxMessages || typedMessages.length === 0 || pagesRequested >= maxPages) {
         finish();
         return;
       }
@@ -2598,8 +4975,70 @@ async function fetchRecentUserMessagesViaListener(api, threadId, count) {
     }
   });
 }
+function normalizeRecentMessageMentions(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const rows = [];
+  const parseOptionalMentionInt = (input) => {
+    if (typeof input === "number" && Number.isFinite(input)) {
+      return Math.trunc(input);
+    }
+    if (typeof input === "string" && input.trim()) {
+      const parsed = Number(input.trim());
+      if (Number.isFinite(parsed)) {
+        return Math.trunc(parsed);
+      }
+    }
+    return void 0;
+  };
+  for (const item of value) {
+    if (!item || typeof item !== "object") continue;
+    const record = item;
+    const uid = normalizeCachedId(record.uid);
+    if (!uid) continue;
+    rows.push({
+      uid,
+      pos: parseOptionalMentionInt(record.pos),
+      len: parseOptionalMentionInt(record.len),
+      type: typeof record.type === "number" && Number.isFinite(record.type) ? Math.trunc(record.type) : typeof record.type === "string" && record.type.trim() ? Number.parseInt(record.type.trim(), 10) : void 0,
+      rawJson: JSON.stringify(record)
+    });
+  }
+  return rows;
+}
+function toDbRecordFromRecentMessage(params) {
+  const content = params.message.data?.content;
+  const quote = params.message.data?.quote;
+  return normalizeInboundListenRecord({
+    profile: params.profile,
+    threadType: params.message.type === ThreadType3.Group ? "group" : "user",
+    rawThreadId: params.message.threadId,
+    senderId: params.message.data?.uidFrom,
+    senderName: params.message.data?.dName,
+    toId: params.message.data?.idTo,
+    selfId: params.selfId,
+    title: params.title,
+    msgId: params.message.data?.msgId,
+    cliMsgId: params.message.data?.cliMsgId,
+    actionId: params.message.data?.actionId,
+    timestampMs: toEpochMs(params.message.data?.ts),
+    msgType: params.message.data?.msgType,
+    contentText: typeof content === "string" ? content : void 0,
+    contentJson: content && typeof content === "object" ? JSON.stringify(content) : void 0,
+    quoteMsgId: quote?.globalMsgId != null ? String(quote.globalMsgId) : void 0,
+    quoteCliMsgId: quote?.cliMsgId != null ? String(quote.cliMsgId) : void 0,
+    quoteOwnerId: quote?.ownerId != null ? String(quote.ownerId) : void 0,
+    quoteText: typeof quote?.msg === "string" ? quote.msg : void 0,
+    mentions: normalizeRecentMessageMentions(
+      params.message.data?.mentions
+    ),
+    rawMessage: params.message.data,
+    source: params.source
+  });
+}
 async function parseCredentialFile(filePath) {
-  const raw = await fs5.readFile(filePath, "utf8");
+  const raw = await fs6.readFile(filePath, "utf8");
   const parsed = JSON.parse(raw);
   if (!parsed.imei || !parsed.cookie || !parsed.userAgent) {
     throw new Error("Credential file must include imei, cookie, and userAgent.");
@@ -2620,7 +5059,7 @@ async function waitForFileContent(filePath, timeoutMs) {
   const startedAt = Date.now();
   while (Date.now() - startedAt < timeoutMs) {
     try {
-      const data = await fs5.readFile(filePath);
+      const data = await fs6.readFile(filePath);
       if (data.length > 0) {
         return data;
       }
@@ -2635,8 +5074,8 @@ async function emitQrBase64FromDetachedLogin(profile, qrPath) {
   if (!scriptPath) {
     throw new Error("Cannot resolve CLI entrypoint for QR base64 mode.");
   }
-  const tempDir = await fs5.mkdtemp(path5.join(os4.tmpdir(), "openzca-qr-"));
-  const targetPath = path5.resolve(qrPath ?? path5.join(tempDir, "qr.png"));
+  const tempDir = await fs6.mkdtemp(path6.join(os4.tmpdir(), "openzca-qr-"));
+  const targetPath = path6.resolve(qrPath ?? path6.join(tempDir, "qr.png"));
   const child = spawn2(
     process.execPath,
     [scriptPath, "--profile", profile, "auth", "login", "--qr-path", targetPath],
@@ -2914,7 +5353,7 @@ function mediaExtFromTypeOrUrl(mediaType, mediaUrl, kind) {
   if (fromType) return fromType;
   try {
     const parsedUrl = new URL(mediaUrl);
-    const ext = path5.extname(parsedUrl.pathname);
+    const ext = path6.extname(parsedUrl.pathname);
     if (ext) return ext;
   } catch {
   }
@@ -2945,20 +5384,20 @@ function parseInboundMediaFetchTimeoutMs() {
   return Math.trunc(parsed);
 }
 function resolveOpenClawMediaDir() {
-  const stateDir = process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim() || path5.join(os4.homedir(), ".openclaw");
-  return path5.join(stateDir, "media");
+  const stateDir = process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim() || path6.join(os4.homedir(), ".openclaw");
+  return path6.join(stateDir, "media");
 }
 function resolveInboundMediaDir(profile) {
   const configuredRaw = process.env.OPENZCA_LISTEN_MEDIA_DIR?.trim();
   if (configuredRaw) {
     const configured = normalizeMediaInput(configuredRaw);
-    return path5.isAbsolute(configured) ? configured : path5.resolve(process.cwd(), configured);
+    return path6.isAbsolute(configured) ? configured : path6.resolve(process.cwd(), configured);
   }
   const legacyRequested = process.env.OPENZCA_LISTEN_MEDIA_LEGACY_DIR?.trim() === "1";
   if (legacyRequested) {
-    return path5.join(getProfileDir(profile), "inbound-media");
+    return path6.join(getProfileDir(profile), "inbound-media");
   }
-  return path5.join(resolveOpenClawMediaDir(), "openzca", profile, "inbound");
+  return path6.join(resolveOpenClawMediaDir(), "openzca", profile, "inbound");
 }
 async function cacheInboundMediaToProfile(profile, mediaUrl, kind) {
   const maxBytes = parseMaxInboundMediaBytes();
@@ -2992,11 +5431,11 @@ async function cacheInboundMediaToProfile(profile, mediaUrl, kind) {
     return null;
   }
   const dir = resolveInboundMediaDir(profile);
-  await fs5.mkdir(dir, { recursive: true });
+  await fs6.mkdir(dir, { recursive: true });
   const ext = mediaExtFromTypeOrUrl(mediaType, mediaUrl, kind);
   const id = `${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
-  const mediaPath = path5.join(dir, `${id}${ext}`);
-  await fs5.writeFile(mediaPath, data);
+  const mediaPath = path6.join(dir, `${id}${ext}`);
+  await fs6.writeFile(mediaPath, data);
   return { mediaPath, mediaType };
 }
 async function cacheRemoteMediaEntries(params) {
@@ -3362,6 +5801,16 @@ function toEpochSeconds(input) {
   }
   return Math.floor(numeric);
 }
+function toEpochMs(input) {
+  const numeric = typeof input === "number" ? input : typeof input === "string" ? Number(input) : Number.NaN;
+  if (!Number.isFinite(numeric) || numeric <= 0) {
+    return Date.now();
+  }
+  if (numeric < 1e10) {
+    return Math.floor(numeric * 1e3);
+  }
+  return Math.floor(numeric);
+}
 function parseNonNegativeIntOption(label, value) {
   if (!value || !value.trim()) return void 0;
   const parsed = Number(value.trim());
@@ -3370,6 +5819,14 @@ function parseNonNegativeIntOption(label, value) {
   }
   return Math.trunc(parsed);
 }
+function parsePositiveIntOption(label, value) {
+  if (!value || !value.trim()) return void 0;
+  const parsed = Number(value.trim());
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${label} must be a positive number.`);
+  }
+  return Math.trunc(parsed);
+}
 program.name("openzca").description("Open-source zca-cli compatible wrapper powered by zca-js").version(PKG_VERSION).option("-p, --profile <name>", "Profile name").option("--debug", "Enable debug logging").option("--debug-file <path>", "Debug log file path").showHelpAfterError();
 program.hook("preAction", (_parent, actionCommand) => {
   if (!resolveDebugEnabled(actionCommand)) {
@@ -3488,7 +5945,7 @@ auth.command("login").description("Login with QR code").option("-q, --qr-path <p
 auth.command("login-cred [file]").alias("login-creds").description("Login using credential JSON file").action(
   wrapAction(async (file, command) => {
     const profile = await currentProfile(command);
-    const credentials = file ? await parseCredentialFile(path5.resolve(normalizeMediaInput(file))) : toCredentials(
+    const credentials = file ? await parseCredentialFile(path6.resolve(normalizeMediaInput(file))) : toCredentials(
       await loadCredentials(profile) ?? (() => {
         throw new Error(
           `No saved credentials for profile "${profile}". Run: openzca auth login`
@@ -3561,26 +6018,397 @@ auth.command("cache-clear").description("Clear local cache").action(
     console.log(`Cache cleared for profile ${profile}`);
   })
 );
+var dbCmd = program.command("db").description("Profile-scoped SQLite message database");
+dbCmd.command("enable").option("--path <path>", "Custom SQLite file path").description("Enable local SQLite persistence for the active profile").action(
+  wrapAction(async (opts, command) => {
+    const profile = await currentProfile(command);
+    await enableDb(profile, opts.path);
+    output(await getDbStatus(profile), false);
+  })
+);
+dbCmd.command("disable").description("Disable automatic SQLite persistence for the active profile").action(
+  wrapAction(async (command) => {
+    const profile = await currentProfile(command);
+    await disableDb(profile);
+    await closeDb(profile);
+    output(await getDbStatus(profile), false);
+  })
+);
+dbCmd.command("reset").option("-y, --yes", "Delete the SQLite DB file for the active profile").option("--drop-config", "Also remove the DB config file").option("-j, --json", "JSON output").description("Delete the local SQLite DB for the active profile").action(
+  wrapAction(async (opts, command) => {
+    if (!opts.yes) {
+      const confirmed = await confirmDestructiveAction(
+        "Reset the local SQLite DB for the active profile?"
+      );
+      if (!confirmed) {
+        console.log("Cancelled.");
+        return;
+      }
+    }
+    const profile = await currentProfile(command);
+    const dbPath = await resolveDbPath(profile);
+    const configPath = getDbConfigPath(profile);
+    await closeDb(profile);
+    const removedPaths = [];
+    const deleteIfExists = async (filename) => {
+      try {
+        await fs6.unlink(filename);
+        removedPaths.push(filename);
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          throw error;
+        }
+      }
+    };
+    await deleteIfExists(dbPath);
+    await deleteIfExists(`${dbPath}-wal`);
+    await deleteIfExists(`${dbPath}-shm`);
+    if (opts.dropConfig) {
+      await deleteIfExists(configPath);
+    }
+    const status = await getDbStatus(profile);
+    output(
+      {
+        profile,
+        removedPaths,
+        droppedConfig: Boolean(opts.dropConfig),
+        status: {
+          enabled: status.enabled,
+          path: status.path,
+          exists: status.exists,
+          messageCount: status.messageCount,
+          threadCount: status.threadCount,
+          groupCount: status.groupCount,
+          userCount: status.userCount
+        }
+      },
+      Boolean(opts.json)
+    );
+  })
+);
+dbCmd.command("status").option("-j, --json", "JSON output").description("Show DB status for the active profile").action(
+  wrapAction(async (opts, command) => {
+    const profile = await currentProfile(command);
+    const config = await readDbConfig(profile);
+    const status = await getDbStatus(profile);
+    const syncRows = await listSyncState({ profile });
+    output(
+      {
+        profile,
+        enabled: status.enabled,
+        path: await resolveDbPath(profile),
+        exists: status.exists,
+        configuredPath: config.path ?? null,
+        messageCount: status.messageCount,
+        threadCount: status.threadCount,
+        groupCount: status.groupCount,
+        userCount: status.userCount,
+        syncStates: {
+          total: syncRows.length,
+          synced: syncRows.filter((row) => row.status === "synced").length,
+          errors: syncRows.filter((row) => row.status === "error").length
+        },
+        lastMessageAtMs: status.lastMessageAtMs ?? null,
+        updatedAt: status.updatedAt ?? null
+      },
+      Boolean(opts.json)
+    );
+  })
+);
+var dbMe = dbCmd.command("me").description("Query stored self profile data");
+dbMe.command("info").option("-j, --json", "JSON output").description("Show stored self profile info").action(
+  wrapAction(async (opts, command) => {
+    const profile = await currentProfile(command);
+    const row = await getSelfProfile(profile);
+    if (!row?.info) {
+      throw new Error("No stored self profile in DB. Run `openzca db sync` first.");
+    }
+    output(row.info, Boolean(opts.json));
+  })
+);
+dbMe.command("id").description("Show stored self user ID").action(
+  wrapAction(async (command) => {
+    const profile = await currentProfile(command);
+    const row = await getSelfProfile(profile);
+    if (!row?.userId) {
+      throw new Error("No stored self profile in DB. Run `openzca db sync` first.");
+    }
+    console.log(row.userId);
+  })
+);
+var dbGroup = dbCmd.command("group").description("Query stored group data");
+dbGroup.command("list").option("-j, --json", "JSON output").description("List groups stored in the local DB").action(
+  wrapAction(async (opts, command) => {
+    const profile = await currentProfile(command);
+    output(await listGroups(profile), Boolean(opts.json));
+  })
+);
+dbGroup.command("info <groupId>").option("-j, --json", "JSON output").description("Show stored info for a group").action(
+  wrapAction(async (groupId, opts, command) => {
+    const profile = await currentProfile(command);
+    const row = await getThreadInfo({ profile, threadId: groupId, threadType: "group" });
+    if (!row) {
+      throw new Error(`Group not found in DB: ${groupId}`);
+    }
+    output(row, Boolean(opts.json));
+  })
+);
+dbGroup.command("members <groupId>").option("-j, --json", "JSON output").description("List stored members for a group").action(
+  wrapAction(async (groupId, opts, command) => {
+    const profile = await currentProfile(command);
+    output(await listThreadMembers({ profile, threadId: groupId }), Boolean(opts.json));
+  })
+);
+dbGroup.command("messages <groupId>").option("--since <duration>", "Rolling window ending now: duration like 30s, 7m, 24h, 7d, or 2w").option("--from <time>", "Lower time bound: ISO timestamp, date, or unix seconds/ms").option("--until <time>", "Upper time bound: ISO timestamp, date, or unix seconds/ms").option("--to <time>", "Alias for --until").option("--limit <count>", "Maximum number of rows").option("--all", "Return all matching rows").option("--oldest-first", "Sort oldest-first instead of newest-first").option("-j, --json", "JSON output").description("List stored messages for a group").action(
+  wrapAction(async (groupId, opts, command) => {
+    const profile = await currentProfile(command);
+    const { sinceMs, untilMs, limit, newestFirst } = resolveMessageQueryOptions(opts);
+    const rows = await listMessages({
+      profile,
+      threadId: groupId,
+      threadType: "group",
+      sinceMs,
+      untilMs,
+      limit,
+      newestFirst
+    });
+    output(
+      {
+        groupId,
+        count: rows.length,
+        messages: rows
+      },
+      Boolean(opts.json)
+    );
+  })
+);
+var dbFriend = dbCmd.command("friend").description("Query stored friend directory data");
+dbFriend.command("list").option("-j, --json", "JSON output").description("List friends stored in the local DB").action(
+  wrapAction(async (opts, command) => {
+    const profile = await currentProfile(command);
+    output(await listFriends(profile), Boolean(opts.json));
+  })
+);
+dbFriend.command("find <query>").option("-j, --json", "JSON output").description("Find stored friends by ID or name").action(
+  wrapAction(async (query, opts, command) => {
+    const profile = await currentProfile(command);
+    output(await findFriends({ profile, query }), Boolean(opts.json));
+  })
+);
+dbFriend.command("info <userId>").option("-j, --json", "JSON output").description("Show stored info for a friend").action(
+  wrapAction(async (userId, opts, command) => {
+    const profile = await currentProfile(command);
+    const row = await getFriendInfo({ profile, userId });
+    if (!row) {
+      throw new Error(`Friend not found in DB: ${userId}`);
+    }
+    output(row, Boolean(opts.json));
+  })
+);
+dbFriend.command("messages <userId>").option("--since <duration>", "Rolling window ending now: duration like 30s, 7m, 24h, 7d, or 2w").option("--from <time>", "Lower time bound: ISO timestamp, date, or unix seconds/ms").option("--until <time>", "Upper time bound: ISO timestamp, date, or unix seconds/ms").option("--to <time>", "Alias for --until").option("--limit <count>", "Maximum number of rows").option("--all", "Return all matching rows").option("--oldest-first", "Sort oldest-first instead of newest-first").option("-j, --json", "JSON output").description("List stored direct-message rows for a friend").action(
+  wrapAction(async (userId, opts, command) => {
+    const profile = await currentProfile(command);
+    const { sinceMs, untilMs, limit, newestFirst } = resolveMessageQueryOptions(opts);
+    const rows = await listMessages({
+      profile,
+      threadId: userId,
+      threadType: "user",
+      sinceMs,
+      untilMs,
+      limit,
+      newestFirst
+    });
+    output(
+      {
+        userId,
+        count: rows.length,
+        messages: rows
+      },
+      Boolean(opts.json)
+    );
+  })
+);
+var dbChat = dbCmd.command("chat").description("Query stored conversation data");
+dbChat.command("list").option("-j, --json", "JSON output").description("List chats stored in the local DB").action(
+  wrapAction(async (opts, command) => {
+    const profile = await currentProfile(command);
+    output(await listChats(profile), shouldOutputJson(opts));
+  })
+);
+dbChat.command("info <chatId>").option("-g, --group", "Read as a group chat").option("-j, --json", "JSON output").description("Show stored info for a chat").action(
+  wrapAction(async (chatId, opts, command) => {
+    const profile = await currentProfile(command);
+    const row = await getThreadInfo({
+      profile,
+      threadId: chatId,
+      threadType: opts.group ? "group" : void 0
+    });
+    if (!row) {
+      throw new Error(`Chat not found in DB: ${chatId}`);
+    }
+    output(row, shouldOutputJson(opts));
+  })
+);
+dbChat.command("messages <chatId>").option("-g, --group", "Read as a group chat").option("--since <duration>", "Rolling window ending now: duration like 30s, 7m, 24h, 7d, or 2w").option("--from <time>", "Lower time bound: ISO timestamp, date, or unix seconds/ms").option("--until <time>", "Upper time bound: ISO timestamp, date, or unix seconds/ms").option("--to <time>", "Alias for --until").option("--limit <count>", "Maximum number of rows").option("--all", "Return all matching rows").option("--oldest-first", "Sort oldest-first instead of newest-first").option("-j, --json", "JSON output").description("List stored messages for a chat").action(
+  wrapAction(async (chatId, opts, command) => {
+    const profile = await currentProfile(command);
+    const threadType = await resolveStoredChatThreadType(profile, chatId, opts.group);
+    const { sinceMs, untilMs, limit, newestFirst } = resolveMessageQueryOptions(opts);
+    const rows = await listMessages({
+      profile,
+      threadId: chatId,
+      threadType,
+      sinceMs,
+      untilMs,
+      limit,
+      newestFirst
+    });
+    output(
+      {
+        chatId,
+        threadType,
+        count: rows.length,
+        messages: rows
+      },
+      shouldOutputJson(opts)
+    );
+  })
+);
+var dbMessage = dbCmd.command("message").description("Query stored messages");
+dbMessage.command("get <id>").option("-j, --json", "JSON output").description("Read one stored message by msgId, cliMsgId, or internal uid").action(
+  wrapAction(async (id, opts, command) => {
+    const profile = await currentProfile(command);
+    const row = await getMessageById({ profile, id });
+    if (!row) {
+      throw new Error(`Message not found in DB: ${id}`);
+    }
+    output(row, Boolean(opts.json));
+  })
+);
+var dbSync = dbCmd.command("sync").description("Sync discoverable data into the local DB");
+dbSync.enablePositionalOptions();
+dbSync.option("-n, --count <count>", "Recent DM/chat messages to fetch per window", "200").option("-j, --json", "JSON output").action(
+  wrapAction(async (opts, command) => {
+    const count = resolveSyncWindowCount(opts.count);
+    const progress = createSyncProgressReporter();
+    const summary = await runDbSync({
+      command,
+      mode: "all",
+      count,
+      progress
+    });
+    output(summary, Boolean(opts.json));
+  })
+);
+dbSync.command("all").option("-n, --count <count>", "Recent DM/chat messages to fetch per window", "200").option("-j, --json", "JSON output").description("Sync full group history, friend directory, and recent DM/chat windows").action(
+  wrapAction(async (_opts, command) => {
+    const count = resolveSyncWindowCount(readCliOptionValue(["--count", "-n"]));
+    output(
+      await runDbSync({ command, mode: "all", count, progress: createSyncProgressReporter() }),
+      readCliFlag(["--json", "-j"])
+    );
+  })
+);
+dbSync.command("groups").option("-j, --json", "JSON output").description("Sync group directory, members, and full group history").action(
+  wrapAction(async (_opts, command) => {
+    output(
+      await runDbSync({ command, mode: "groups", count: 0, progress: createSyncProgressReporter() }),
+      readCliFlag(["--json", "-j"])
+    );
+  })
+);
+dbSync.command("friends").option("-j, --json", "JSON output").description("Sync friend directory only").action(
+  wrapAction(async (_opts, command) => {
+    output(
+      await runDbSync({ command, mode: "friends", count: 0, progress: createSyncProgressReporter() }),
+      readCliFlag(["--json", "-j"])
+    );
+  })
+);
+dbSync.command("chats").option("-n, --count <count>", "Recent messages to fetch per scan/window", "200").option("-j, --json", "JSON output").description("Sync discoverable chat windows (DM/chat sync is best-effort)").action(
+  wrapAction(async (_opts, command) => {
+    const count = resolveSyncWindowCount(readCliOptionValue(["--count", "-n"]));
+    output(
+      await runDbSync({ command, mode: "chats", count, progress: createSyncProgressReporter() }),
+      readCliFlag(["--json", "-j"])
+    );
+  })
+);
+dbSync.command("group <groupId>").option("-j, --json", "JSON output").description("Sync one group with full group history").action(
+  wrapAction(async (groupId, _opts, command) => {
+    output(
+      await runDbSync({
+        command,
+        mode: "group",
+        count: 0,
+        groupId,
+        progress: createSyncProgressReporter()
+      }),
+      readCliFlag(["--json", "-j"])
+    );
+  })
+);
+dbSync.command("chat <chatId>").option("-n, --count <count>", "Recent messages to fetch for this chat", "200").option("-j, --json", "JSON output").description("Sync one chat (best-effort for direct-message history)").action(
+  wrapAction(async (chatId, _opts, command) => {
+    const count = resolveSyncWindowCount(readCliOptionValue(["--count", "-n"]));
+    output(
+      await runDbSync({
+        command,
+        mode: "chat",
+        count,
+        threadId: chatId,
+        progress: createSyncProgressReporter()
+      }),
+      readCliFlag(["--json", "-j"])
+    );
+  })
+);
 var msg = program.command("msg").description("Messaging commands");
-msg.command("send <threadId> <message>").option("-g, --group", "Send to group").option("--raw", "Send raw text without parsing formatting markers").description("Send text message with formatting (**bold** *italic* __bold__ ~~strike~~ {underline}text{/underline} {red}color{/red} {big}size{/big} lists indents). Group sends also resolve unique @Name/@userId mentions.").action(
+msg.command("send <threadId> <message>").option("-g, --group", "Send to group").option("--raw", "Send raw text without parsing formatting markers").option("--reply-id <id>", "Reply using a stored DB message id/msgId/cliMsgId").option("--reply-message <json>", "Reply using a raw message.data JSON object").description("Send text message with formatting (**bold** *italic* __bold__ ~~strike~~ {underline}text{/underline} {red}color{/red} {big}size{/big} lists indents). Group sends also resolve unique @Name/@userId mentions.").action(
   wrapAction(async (threadId, message, opts, command) => {
-    const { api } = await requireApi(command);
+    const { api, profile } = await requireApi(command);
     const threadType = asThreadType(opts.group);
-    const payload = await buildTextSendPayload({
+    const textPayload = await buildTextSendPayload({
       message,
       raw: opts.raw,
       threadType,
       threadId,
-      listGroupMembers: threadType === ThreadType2.Group ? (groupId) => listGroupMentionMembers(api, groupId) : void 0
+      listGroupMembers: threadType === ThreadType3.Group ? (groupId) => listGroupMentionMembers(api, groupId) : void 0
     });
+    const quote = await resolveSendReplyQuote({
+      profile,
+      api,
+      threadId,
+      threadType,
+      replyId: opts.replyId,
+      replyMessage: opts.replyMessage
+    });
+    const payload = quote || typeof textPayload !== "string" ? {
+      ...typeof textPayload === "string" ? { msg: textPayload } : textPayload,
+      ...quote ? { quote } : {}
+    } : textPayload;
     const response = await api.sendMessage(payload, threadId, threadType);
     output(response, false);
+    if (await shouldWriteToDb(profile)) {
+      scheduleDbWrite(profile, command, "msg.send.db.persist_error", async () => {
+        await persistOutgoingMessageBestEffort({
+          profile,
+          api,
+          threadId,
+          group: opts.group,
+          text: message,
+          msgType: "text",
+          response,
+          rawPayload: payload
+        });
+      });
+    }
   })
 );
 msg.command("image <threadId> [file]").option("-u, --url <url>", "Image URL (repeatable)", collectValues, []).option("-m, --message <message>", "Caption").option("-g, --group", "Send to group").description("Send image(s) from file or URL").action(
   wrapAction(
     async (threadId, file, opts, command) => {
-      const { api } = await requireApi(command);
+      const { api, profile } = await requireApi(command);
       const normalizedFile = file ? normalizeMediaInput(file) : void 0;
       const files = [normalizedFile, ...normalizeInputList(opts.url)].filter(Boolean);
       const urlInputs = files.filter((entry) => isHttpUrl(entry));
@@ -3611,6 +6439,28 @@ msg.command("image <threadId> [file]").option("-u, --url <url>", "Image URL (rep
           asThreadType(opts.group)
         );
         output(response, false);
+        if (await shouldWriteToDb(profile)) {
+          scheduleDbWrite(profile, command, "msg.image.db.persist_error", async () => {
+            await persistOutgoingMessageBestEffort({
+              profile,
+              api,
+              threadId,
+              group: opts.group,
+              text: opts.message ?? "",
+              msgType: "image",
+              response,
+              rawPayload: {
+                msg: opts.message ?? "",
+                attachments
+              },
+              media: attachments.map((item) => ({
+                mediaKind: "image",
+                mediaPath: isHttpUrl(item) ? void 0 : item,
+                mediaUrl: isHttpUrl(item) ? item : void 0
+              }))
+            });
+          });
+        }
       } finally {
         await downloaded.cleanup();
       }
@@ -3691,6 +6541,30 @@ msg.command("video <threadId> [file]").option("-u, --url <url>", "Video URL (rep
               command
             );
             output(response2, false);
+            if (await shouldWriteToDb(profile)) {
+              scheduleDbWrite(profile, command, "msg.video.db.persist_error", async () => {
+                await persistOutgoingMessageBestEffort({
+                  profile,
+                  api,
+                  threadId,
+                  group: opts.group,
+                  text: opts.message ?? "",
+                  msgType: "video",
+                  response: response2,
+                  rawPayload: {
+                    msg: opts.message ?? "",
+                    videoPath: attachments[0],
+                    thumbnailPath: thumbnailPath ?? null
+                  },
+                  media: [
+                    {
+                      mediaKind: "video",
+                      mediaPath: attachments[0]
+                    }
+                  ]
+                });
+              });
+            }
             return;
           } catch (error) {
             writeDebugLine(
@@ -3729,6 +6603,28 @@ msg.command("video <threadId> [file]").option("-u, --url <url>", "Video URL (rep
           )
         );
         output(response, false);
+        if (await shouldWriteToDb(profile)) {
+          scheduleDbWrite(profile, command, "msg.video.db.persist_error", async () => {
+            await persistOutgoingMessageBestEffort({
+              profile,
+              api,
+              threadId,
+              group: opts.group,
+              text: opts.message ?? "",
+              msgType: "video",
+              response,
+              rawPayload: {
+                msg: opts.message ?? "",
+                attachments
+              },
+              media: attachments.map((item) => ({
+                mediaKind: "video",
+                mediaPath: isHttpUrl(item) ? void 0 : item,
+                mediaUrl: isHttpUrl(item) ? item : void 0
+              }))
+            });
+          });
+        }
       } finally {
         await downloaded.cleanup();
         await downloadedThumbnail.cleanup();
@@ -3739,7 +6635,7 @@ msg.command("video <threadId> [file]").option("-u, --url <url>", "Video URL (rep
 msg.command("voice <threadId> [file]").option("-u, --url <url>", "Voice URL (repeatable)", collectValues, []).option("-g, --group", "Send to group").description("Send voice message from file or URL").action(
   wrapAction(
     async (threadId, file, opts, command) => {
-      const { api } = await requireApi(command);
+      const { api, profile } = await requireApi(command);
       const type = asThreadType(opts.group);
       const normalizedFile = file ? normalizeMediaInput(file) : void 0;
       const files = [normalizedFile, ...normalizeInputList(opts.url)].filter(Boolean);
@@ -3775,6 +6671,24 @@ msg.command("voice <threadId> [file]").option("-u, --url <url>", "Voice URL (rep
           );
         }
         output(results, false);
+        if (await shouldWriteToDb(profile)) {
+          scheduleDbWrite(profile, command, "msg.voice.db.persist_error", async () => {
+            await persistOutgoingMessageBestEffort({
+              profile,
+              api,
+              threadId,
+              group: opts.group,
+              msgType: "voice",
+              response: results,
+              rawPayload: uploaded,
+              media: uploaded.map((item) => ({
+                mediaKind: "voice",
+                mediaUrl: "fileUrl" in item && typeof item.fileUrl === "string" ? item.fileUrl : void 0,
+                rawJson: JSON.stringify(item)
+              }))
+            });
+          });
+        }
       } finally {
         await downloaded.cleanup();
       }
@@ -3805,9 +6719,23 @@ msg.command("sticker <threadId> <stickerId>").option("-g, --group", "Send to gro
 );
 msg.command("link <threadId> <url>").option("-g, --group", "Send to group").description("Send link").action(
   wrapAction(async (threadId, url, opts, command) => {
-    const { api } = await requireApi(command);
+    const { api, profile } = await requireApi(command);
     const response = await api.sendLink({ link: url }, threadId, asThreadType(opts.group));
     output(response, false);
+    if (await shouldWriteToDb(profile)) {
+      scheduleDbWrite(profile, command, "msg.link.db.persist_error", async () => {
+        await persistOutgoingMessageBestEffort({
+          profile,
+          api,
+          threadId,
+          group: opts.group,
+          text: url,
+          msgType: "link",
+          response,
+          rawPayload: { link: url }
+        });
+      });
+    }
   })
 );
 msg.command("card <threadId> <contactId>").option("-g, --group", "Send to group").description("Send contact card").action(
@@ -3947,8 +6875,8 @@ msg.command("upload <arg1> [arg2]").option("-u, --url <url>", "File URL (repeata
         {
           threadId,
           explicitGroupFlag: Boolean(opts.group),
-          isGroup: threadResolution.type === ThreadType2.Group,
-          threadType: threadResolution.type === ThreadType2.Group ? "group" : "user",
+          isGroup: threadResolution.type === ThreadType3.Group,
+          threadType: threadResolution.type === ThreadType3.Group ? "group" : "user",
           threadTypeReason: threadResolution.reason,
           localFiles,
           urlInputs
@@ -3976,7 +6904,7 @@ msg.command("upload <arg1> [arg2]").option("-u, --url <url>", "File URL (repeata
             "msg.upload.ipc.done",
             {
               threadId,
-              threadType: threadResolution.type === ThreadType2.Group ? "group" : "user"
+              threadType: threadResolution.type === ThreadType3.Group ? "group" : "user"
             },
             command
           );
@@ -3987,7 +6915,7 @@ msg.command("upload <arg1> [arg2]").option("-u, --url <url>", "File URL (repeata
           "msg.upload.ipc.fallback",
           {
             threadId,
-            threadType: threadResolution.type === ThreadType2.Group ? "group" : "user",
+            threadType: threadResolution.type === ThreadType3.Group ? "group" : "user",
             reason: ipcResult.reason
           },
           command
@@ -4020,40 +6948,52 @@ msg.command("upload <arg1> [arg2]").option("-u, --url <url>", "File URL (repeata
     }
   )
 );
-msg.command("recent <threadId>").option("-g, --group", "List recent messages for group thread").option("-n, --count <count>", "Number of messages (default: 20)", "20").option("-j, --json", "JSON output").description("List recent messages (group uses direct history API when available)").action(
+msg.command("recent <threadId>").option("-g, --group", "List recent messages for group thread").option("-n, --count <count>", "Number of messages", "20").option("--source <source>", "Message source: live, db, or auto", "live").option("-j, --json", "JSON output").description("List recent messages (group uses direct history API when available)").action(
   wrapAction(
     async (threadId, opts, command) => {
-      const { api } = await requireApi(command);
+      const { api, profile } = await requireApi(command);
       const parsedCount = Number(opts.count);
       const count = Number.isFinite(parsedCount) ? Math.min(Math.max(Math.trunc(parsedCount), 1), 200) : 20;
-      const threadType = opts.group ? ThreadType2.Group : ThreadType2.User;
-      const messages = opts.group ? await fetchRecentGroupMessagesViaApi(api, threadId, count) : await fetchRecentUserMessagesViaListener(
-        api,
+      const threadType = opts.group ? ThreadType3.Group : ThreadType3.User;
+      const source = (opts.source ?? "live").trim().toLowerCase();
+      if (!["live", "db", "auto"].includes(source)) {
+        throw new Error("--source must be one of: live, db, auto");
+      }
+      let rows = source === "db" || source === "auto" ? await listRecentMessages({
+        profile,
         threadId,
+        threadType: opts.group ? "group" : "user",
         count
-      );
-      const rows = messages.map((message) => ({
-        msgId: message.data.msgId,
-        cliMsgId: message.data.cliMsgId,
-        threadId: message.threadId || threadId,
-        threadType: message.type === ThreadType2.Group ? "group" : "user",
-        senderId: message.data.uidFrom,
-        senderName: message.data.dName,
-        ts: message.data.ts,
-        msgType: message.data.msgType,
-        undo: {
+      }) : [];
+      if (source === "live" || source === "auto" && rows.length === 0) {
+        const messages = opts.group ? await fetchRecentGroupMessagesViaApi(api, threadId, count) : await fetchRecentUserMessagesViaListener(
+          api,
+          threadId,
+          count
+        );
+        rows = messages.map((message) => ({
           msgId: message.data.msgId,
           cliMsgId: message.data.cliMsgId,
           threadId: message.threadId || threadId,
-          group: message.type === ThreadType2.Group
-        },
-        content: typeof message.data.content === "string" ? message.data.content : JSON.stringify(message.data.content)
-      }));
+          threadType: message.type === ThreadType3.Group ? "group" : "user",
+          senderId: message.data.uidFrom,
+          senderName: message.data.dName ?? "",
+          ts: message.data.ts,
+          msgType: message.data.msgType,
+          undo: {
+            msgId: message.data.msgId,
+            cliMsgId: message.data.cliMsgId,
+            threadId: message.threadId || threadId,
+            group: message.type === ThreadType3.Group
+          },
+          content: typeof message.data.content === "string" ? message.data.content : JSON.stringify(message.data.content)
+        }));
+      }
       if (opts.json) {
         output(
           {
             threadId,
-            threadType: threadType === ThreadType2.Group ? "group" : "user",
+            threadType: threadType === ThreadType3.Group ? "group" : "user",
             count: rows.length,
             messages: rows
           },
@@ -4073,7 +7013,7 @@ msg.command("pin <threadId>").option("-g, --group", "Pin group conversation").de
     output(
       {
         threadId,
-        threadType: type === ThreadType2.Group ? "group" : "user",
+        threadType: type === ThreadType3.Group ? "group" : "user",
         pinned: true,
         response
       },
@@ -4089,7 +7029,7 @@ msg.command("unpin <threadId>").option("-g, --group", "Unpin group conversation"
     output(
       {
         threadId,
-        threadType: type === ThreadType2.Group ? "group" : "user",
+        threadType: type === ThreadType3.Group ? "group" : "user",
         pinned: false,
         response
       },
@@ -4678,7 +7618,7 @@ me.command("last-online <userId>").description("Get last online of a user").acti
     output(await api.lastOnline(userId), false);
   })
 );
-program.command("listen").description("Listen for real-time incoming messages").option("-e, --echo", "Echo incoming text message").option("-p, --prefix <prefix>", "Only process text starting with prefix").option("-w, --webhook <url>", "POST message payload to webhook").option("-r, --raw", "Output JSON line payload").option("-k, --keep-alive", "Auto restart listener on disconnect").option(
+program.command("listen").description("Listen for real-time incoming messages").option("-e, --echo", "Echo incoming text message").option("-p, --prefix <prefix>", "Only process text starting with prefix").option("-w, --webhook <url>", "POST message payload to webhook").option("-r, --raw", "Output JSON line payload").option("--db", "Force DB persistence for this listener session").option("--no-db", "Disable DB persistence for this listener session").option("-k, --keep-alive", "Auto restart listener on disconnect").option(
   "--supervised",
   "Supervisor mode (disable internal retry ownership; emit lifecycle events in --raw)"
 ).option(
@@ -4719,6 +7659,8 @@ program.command("listen").description("Listen for real-time incoming messages").
         process.env.OPENZCA_LISTEN_DOWNLOAD_QUOTE_MEDIA
       );
       const sessionId = `${Date.now().toString(36)}-${Math.random().toString(16).slice(2, 10)}`;
+      const selfId = api.getOwnId();
+      const dbWriteEnabled = await shouldWriteToDb(profile, getDbWriteOverride(opts));
       const emitLifecycle = (event, fields) => {
         if (!lifecycleEventsEnabled) return;
         console.log(
@@ -4927,7 +7869,7 @@ ${replyMediaText}` : replyMediaText;
             processedText = processedText.trim() ? `${processedText}
 ${replyContextText}` : replyContextText;
           }
-          const chatType = message.type === ThreadType2.Group ? "group" : "user";
+          const chatType = message.type === ThreadType3.Group ? "group" : "user";
           const senderId = getStringCandidate(messageData, ["uidFrom"]) || message.data.uidFrom;
           const senderDisplayNameRaw = getStringCandidate(messageData, [
             "dName",
@@ -4936,7 +7878,7 @@ ${replyContextText}` : replyContextText;
             "displayName"
           ]);
           const senderDisplayName = senderDisplayNameRaw || void 0;
-          const senderNameForMetadata = message.type === ThreadType2.Group ? senderDisplayName : void 0;
+          const senderNameForMetadata = message.type === ThreadType3.Group ? senderDisplayName : void 0;
           const toId = getStringCandidate(messageData, ["idTo"]) || void 0;
           const threadName = typeof messageData.threadName === "string" ? messageData.threadName : typeof messageData.tName === "string" ? messageData.tName : void 0;
           const mentions = extractInboundMentions({
@@ -4946,6 +7888,7 @@ ${replyContextText}` : replyContextText;
           });
           const mentionIds = mentions.map((item) => item.uid);
           const timestamp = toEpochSeconds(message.data.ts);
+          const timestampMs = toEpochMs(message.data.ts);
           const payload = {
             threadId: message.threadId,
             targetId: message.threadId,
@@ -4973,7 +7916,7 @@ ${replyContextText}` : replyContextText;
             mentions: mentions.length > 0 ? mentions : void 0,
             mentionIds: mentionIds.length > 0 ? mentionIds : void 0,
             metadata: {
-              isGroup: message.type === ThreadType2.Group,
+              isGroup: message.type === ThreadType3.Group,
               chatType,
               threadId: message.threadId,
               targetId: message.threadId,
@@ -5011,6 +7954,52 @@ ${replyContextText}` : replyContextText;
             toId,
             ts: message.data.ts
           };
+          if (dbWriteEnabled) {
+            const mediaForDb = mediaEntries.map((entry) => ({
+              mediaKind: mediaKind ?? void 0,
+              mediaUrl: entry.mediaUrl,
+              mediaPath: entry.mediaPath,
+              mediaType: entry.mediaType,
+              rawJson: JSON.stringify(entry)
+            }));
+            const mentionsForDb = mentions.map((mention) => ({
+              uid: mention.uid,
+              pos: mention.pos,
+              len: mention.len,
+              type: mention.type,
+              rawJson: JSON.stringify(mention)
+            }));
+            scheduleDbWrite(profile, command, "listen.db.persist_error", async () => {
+              await persistMessage(
+                normalizeInboundListenRecord({
+                  profile,
+                  threadType: chatType,
+                  rawThreadId: message.threadId,
+                  senderId,
+                  senderName: senderDisplayName,
+                  toId,
+                  selfId,
+                  title: threadName,
+                  msgId: message.data.msgId,
+                  cliMsgId: message.data.cliMsgId,
+                  actionId: getStringCandidate(messageData, ["actionId"]),
+                  timestampMs,
+                  msgType: msgType || void 0,
+                  contentText: processedText || rawText || void 0,
+                  contentJson: rawContent && typeof rawContent === "object" ? JSON.stringify(rawContent) : void 0,
+                  quoteMsgId: quote?.globalMsgId ? String(quote.globalMsgId) : void 0,
+                  quoteCliMsgId: quote?.cliMsgId ? String(quote.cliMsgId) : void 0,
+                  quoteOwnerId: quote?.ownerId ? String(quote.ownerId) : void 0,
+                  quoteText: quote?.msg,
+                  media: mediaForDb,
+                  mentions: mentionsForDb,
+                  rawMessage: message.data,
+                  rawPayload: payload,
+                  source: "listen"
+                })
+              );
+            });
+          }
           if (opts.raw) {
             console.log(JSON.stringify(payload));
           } else {
@@ -5191,4 +8180,4 @@ ${replyContextText}` : replyContextText;
     }
   )
 );
-program.parseAsync(process.argv);
+program.parseAsync(normalizeCommandAliases(process.argv));