@kyan-du/agent-wechat-openclaw 0.12.0-next.0 → 0.12.0

package/dist/index.js

@@ -5592,6 +5592,248 @@ function selectCatchUpMessages(messages, limits, mode = "latest") {
   };
 }
 
+// src/monitor-cursor.ts
+function cursorMessageKey(message) {
+  return `${message.serverId ?? ""}:${message.timestamp}:${message.type}:${message.sender ?? ""}:${message.content ?? ""}`;
+}
+function markEqualCursorUnreadHandled(chatId, message, equalCursorUnreadHandled) {
+  if (message === void 0) return;
+  equalCursorUnreadHandled.set(chatId, {
+    localId: message.localId,
+    messageKey: cursorMessageKey(message)
+  });
+}
+function markCursorMessagesHandled(chatId, messages, equalCursorUnreadHandled) {
+  if (messages.length === 0) return void 0;
+  const cursorMessage = messages.reduce(
+    (latest, message) => message.localId > latest.localId ? message : latest
+  );
+  markEqualCursorUnreadHandled(chatId, cursorMessage, equalCursorUnreadHandled);
+  return cursorMessage.localId;
+}
+function selectCursorMessages(chatId, chat, messages, lastSeenId, equalCursorUnreadHandled, startupBaseline, generationResetConfirmed = false) {
+  const firstPoll = !lastSeenId.has(chatId);
+  const prevLastSeen = lastSeenId.get(chatId) ?? 0;
+  const sorted = [...messages].sort((a, b) => a.localId - b.localId);
+  const baselineActive = startupBaseline !== void 0 && (firstPoll || prevLastSeen < startupBaseline.localId);
+  if (baselineActive) {
+    const baselineRow = sorted.find((message) => message.localId === startupBaseline.localId);
+    const generationReset = sorted.length > 0 && typeof chat.lastMsgLocalId === "number" && chat.lastMsgLocalId <= startupBaseline.localId && (baselineRow === void 0 && sorted.every((message) => message.localId < startupBaseline.localId) || baselineRow !== void 0 && startupBaseline.messageKey !== void 0 && cursorMessageKey(baselineRow) !== startupBaseline.messageKey);
+    if (generationReset || generationResetConfirmed) {
+      return {
+        firstPoll,
+        prevLastSeen,
+        messages: sorted,
+        generationReset: true
+      };
+    }
+    const live = sorted.filter(
+      (message) => message.localId > startupBaseline.localId || message.localId === startupBaseline.localId && startupBaseline.messageKey !== void 0 && cursorMessageKey(message) !== startupBaseline.messageKey
+    );
+    const seedLastSeen = sorted.filter((message) => message.localId <= startupBaseline.localId).at(-1)?.localId;
+    return {
+      firstPoll,
+      prevLastSeen,
+      messages: live,
+      seedLastSeen
+    };
+  }
+  if (firstPoll) {
+    const unread2 = chat.unreadCount ?? 0;
+    if (unread2 > 0 && unread2 < sorted.length) {
+      return {
+        firstPoll,
+        prevLastSeen,
+        messages: sorted.slice(-unread2),
+        seedLastSeen: sorted[sorted.length - unread2 - 1].localId
+      };
+    }
+    if (unread2 >= sorted.length) {
+      return { firstPoll, prevLastSeen, messages: sorted };
+    }
+    return {
+      firstPoll,
+      prevLastSeen,
+      messages: [],
+      seedLastSeen: sorted[sorted.length - 1]?.localId
+    };
+  }
+  const newer = sorted.filter((m) => m.localId > prevLastSeen);
+  if (newer.length > 0) {
+    return { firstPoll, prevLastSeen, messages: newer };
+  }
+  const unread = chat.unreadCount ?? 0;
+  const handled = equalCursorUnreadHandled.get(chatId);
+  const equalCursorRows = sorted.filter((message) => message.localId === prevLastSeen);
+  const equalIdGenerationReset = unread > 0 && chat.lastMsgLocalId === prevLastSeen && sorted.every((message) => message.localId <= prevLastSeen) && equalCursorRows.length === 1 && handled?.localId === prevLastSeen && handled.messageKey !== cursorMessageKey(equalCursorRows[0]);
+  const lowerIdGenerationReset = unread > 0 && sorted.length > 0 && sorted.every((message) => message.localId < prevLastSeen) && typeof chat.lastMsgLocalId === "number" && chat.lastMsgLocalId < prevLastSeen;
+  if (lowerIdGenerationReset || equalIdGenerationReset || generationResetConfirmed) {
+    return {
+      firstPoll,
+      prevLastSeen,
+      messages: sorted,
+      generationReset: true
+    };
+  }
+  if (unread <= 0) {
+    return { firstPoll, prevLastSeen, messages: [] };
+  }
+  const unreadSuffix = sorted.slice(-Math.min(unread, sorted.length));
+  const equalCursorUnread = unreadSuffix.filter((m) => m.localId === prevLastSeen);
+  const recoverable = equalCursorUnread.length === 1 && chat.lastMsgLocalId === prevLastSeen && (handled?.localId !== prevLastSeen || handled.messageKey !== cursorMessageKey(equalCursorUnread[0]));
+  return {
+    firstPoll,
+    prevLastSeen,
+    messages: recoverable ? equalCursorUnread : []
+  };
+}
+function seedStartupBaselineFromChat(chat) {
+  return typeof chat.lastMsgLocalId === "number" && chat.lastMsgLocalId > 0 ? { localId: chat.lastMsgLocalId } : void 0;
+}
+function enrichStartupBaselineFromMessages(baseline, messages) {
+  if (baseline === void 0 || baseline.messageKey !== void 0) return baseline;
+  const match = messages.find((message) => message.localId === baseline.localId);
+  return match ? { ...baseline, messageKey: cursorMessageKey(match) } : baseline;
+}
+function selectMessagesHandledAfterDispatch(messages, successfulSegmentLastLocalIds) {
+  if (successfulSegmentLastLocalIds.length === 0) return [];
+  const lastHandled = Math.max(...successfulSegmentLastLocalIds);
+  return messages.filter((message) => message.localId <= lastHandled);
+}
+
+// src/monitor-scan.ts
+var MONITOR_CHAT_PAGE_LIMIT = 100;
+var MONITOR_MESSAGE_PAGE_LIMIT = 200;
+var DEFAULT_MESSAGE_PAGE_BUDGET = 50;
+var DEFAULT_INITIAL_CHAT_PAGE_BUDGET = 100;
+async function listInitialMonitorChatSnapshot(client, state, pageBudget = DEFAULT_INITIAL_CHAT_PAGE_BUDGET) {
+  if (state.initialScanComplete) return [];
+  const chats = [];
+  let cursor;
+  for (let pages = 0; pages < pageBudget; pages += 1) {
+    const page = await client.listChatsPage(MONITOR_CHAT_PAGE_LIMIT, cursor);
+    chats.push(...page.items);
+    cursor = page.nextCursor;
+    if (!cursor) {
+      state.initialScanComplete = true;
+      state.cursor = void 0;
+      return chats;
+    }
+  }
+  throw new Error(`initial chat snapshot exceeded ${pageBudget} pages`);
+}
+async function listNextMonitorChatPage(client, state) {
+  const isInitialSnapshot = !state.initialScanComplete;
+  const page = await client.listChatsPage(MONITOR_CHAT_PAGE_LIMIT, state.cursor);
+  state.cursor = page.nextCursor;
+  if (!page.nextCursor) {
+    state.initialScanComplete = true;
+    state.cursor = void 0;
+  }
+  return { chats: page.items, isInitialSnapshot };
+}
+function hasReachedStableMessageBoundary(messages, chat, firstPoll, prevLastSeen, startupBaseline) {
+  if (messages.length === 0) return false;
+  const sorted = [...messages].sort((a, b) => a.localId - b.localId);
+  if (startupBaseline !== void 0 && (firstPoll || prevLastSeen < startupBaseline.localId)) {
+    if (startupBaseline.localId <= 0) return true;
+    if (sorted.some((message) => message.localId === startupBaseline.localId)) return true;
+    return false;
+  }
+  if (firstPoll) {
+    const unread2 = chat.unreadCount ?? 0;
+    if (unread2 > 0) return messages.length >= unread2 + 1;
+    return true;
+  }
+  if (sorted.some((message) => message.localId <= prevLastSeen)) return true;
+  const unread = chat.unreadCount ?? 0;
+  return unread > 0 && messages.length >= unread;
+}
+function detectsGenerationReset(messages, chat, firstPoll, prevLastSeen, startupBaseline, handledCursor) {
+  if (messages.length === 0 || typeof chat.lastMsgLocalId !== "number") return false;
+  const boundary = startupBaseline !== void 0 && (firstPoll || prevLastSeen < startupBaseline.localId) ? startupBaseline : handledCursor?.localId === prevLastSeen ? handledCursor : void 0;
+  const boundaryLocalId = boundary?.localId ?? prevLastSeen;
+  if (chat.lastMsgLocalId < boundaryLocalId) return true;
+  if (chat.lastMsgLocalId !== boundaryLocalId || boundary?.messageKey === void 0) return false;
+  const equalRow = messages.find((message) => message.localId === boundaryLocalId);
+  return equalRow !== void 0 && cursorMessageKey(equalRow) !== boundary.messageKey;
+}
+function generationBoundaryIndex(messages) {
+  for (let index = 1; index < messages.length; index += 1) {
+    if (messages[index].localId >= messages[index - 1].localId) return index;
+  }
+  return void 0;
+}
+function shouldProbeGenerationReset(messages, chat, firstPoll, prevLastSeen, startupBaseline, handledCursor) {
+  if (typeof chat.lastMsgLocalId !== "number") return false;
+  const boundary = startupBaseline !== void 0 && (firstPoll || prevLastSeen < startupBaseline.localId) ? startupBaseline : handledCursor?.localId === prevLastSeen ? handledCursor : void 0;
+  if (boundary === void 0 || chat.lastMsgLocalId > boundary.localId) return false;
+  return !messages.some((message) => message.localId === boundary.localId);
+}
+async function listMessagesForMonitorCursor(client, chatId, options) {
+  const pageBudget = options.pageBudget ?? DEFAULT_MESSAGE_PAGE_BUDGET;
+  const messages = [...options.continuation?.messages ?? []];
+  let cursor = options.continuation?.cursor;
+  let generationReset = options.continuation?.generationReset ?? false;
+  let pagesScanned = 0;
+  while (pagesScanned < pageBudget) {
+    const page = await client.listMessagesPage(chatId, MONITOR_MESSAGE_PAGE_LIMIT, cursor);
+    pagesScanned += 1;
+    messages.push(...page.items);
+    cursor = page.nextCursor;
+    generationReset ||= detectsGenerationReset(
+      messages,
+      options.chat,
+      options.firstPoll,
+      options.prevLastSeen,
+      options.startupBaseline,
+      options.handledCursor
+    );
+    if (generationReset) {
+      const boundaryIndex = generationBoundaryIndex(messages);
+      if (boundaryIndex !== void 0 || !cursor) {
+        return {
+          messages: boundaryIndex === void 0 ? messages : messages.slice(0, boundaryIndex),
+          complete: true,
+          nextCursor: void 0,
+          pagesScanned,
+          generationReset: true
+        };
+      }
+      continue;
+    }
+    const probingReset = shouldProbeGenerationReset(
+      messages,
+      options.chat,
+      options.firstPoll,
+      options.prevLastSeen,
+      options.startupBaseline,
+      options.handledCursor
+    );
+    if (!cursor || !probingReset && hasReachedStableMessageBoundary(
+      messages,
+      options.chat,
+      options.firstPoll,
+      options.prevLastSeen,
+      options.startupBaseline
+    )) {
+      return {
+        messages,
+        complete: true,
+        nextCursor: void 0,
+        pagesScanned
+      };
+    }
+  }
+  return {
+    messages,
+    complete: false,
+    nextCursor: cursor,
+    pagesScanned,
+    generationReset: generationReset || void 0
+  };
+}
+
 // src/outbound.ts
 import { randomUUID } from "node:crypto";
 async function sendLogicalMediaTask(opts) {
@@ -5623,6 +5865,255 @@ async function sendLogicalMediaTask(opts) {
   return requestId;
 }
 
+// src/monitor-retry.ts
+import {
+  existsSync,
+  closeSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+  fsyncSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var MAX_PENDING_RESET_CHATS = 100;
+var MAX_PENDING_RESET_MESSAGES = 1e4;
+var MAX_RESET_RETRY_DELAY_MS = 6e4;
+var PendingRetryStateError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "PendingRetryStateError";
+    this.code = code;
+  }
+};
+function retryStorePath(accountId, stateDir) {
+  const root = stateDir ?? process.env.OPENCLAW_STATE_DIR?.trim() ?? join(homedir(), ".openclaw");
+  const safeAccount = accountId.replace(/[^A-Za-z0-9._-]/g, "_");
+  return join(root, "wechat", `monitor-retry-${safeAccount}.json`);
+}
+function quarantinePath(path) {
+  return `${path}.corrupt`;
+}
+function blockerPath(path) {
+  return `${path}.blocked`;
+}
+function syncPath(path) {
+  const fd = openSync(path, "r");
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function syncParent(path) {
+  syncPath(dirname(path));
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function validateMessage(message) {
+  if (message === null || typeof message !== "object") return false;
+  const row = message;
+  return Number.isSafeInteger(row.localId) && typeof row.chatId === "string" && Number.isSafeInteger(row.type) && typeof row.timestamp === "string" && (row.serverId === void 0 || Number.isSafeInteger(row.serverId)) && (row.content === void 0 || typeof row.content === "string") && (row.sender === void 0 || typeof row.sender === "string") && (row.isSelf === void 0 || typeof row.isSelf === "boolean") && (row.isMentioned === void 0 || typeof row.isMentioned === "boolean");
+}
+function validateChat(chat) {
+  if (chat === null || typeof chat !== "object") return false;
+  const row = chat;
+  return typeof row.id === "string" && typeof row.name === "string" && Number.isSafeInteger(row.unreadCount) && typeof row.isGroup === "boolean" && (row.username === void 0 || typeof row.username === "string") && (row.lastMsgLocalId === void 0 || Number.isSafeInteger(row.lastMsgLocalId)) && (row.remark === void 0 || typeof row.remark === "string") && (row.members === void 0 || isStringArray(row.members));
+}
+function validateEntries(entries) {
+  if (entries.length > MAX_PENDING_RESET_CHATS) {
+    throw new PendingRetryStateError("WeChat pending retry chat capacity exceeded", "RETRY_CAPACITY");
+  }
+  let total = 0;
+  for (const entry of entries) {
+    if (!Array.isArray(entry) || typeof entry[0] !== "string") {
+      throw new PendingRetryStateError("WeChat retry state entry is invalid", "RETRY_STATE_CORRUPT");
+    }
+    const pending = entry[1];
+    if (pending?.readyForDispatch !== true || !validateChat(pending.chat) || !Array.isArray(pending.messages) || !pending.messages.every(validateMessage) || pending.generationReset !== void 0 && typeof pending.generationReset !== "boolean" || pending.retryCount !== void 0 && !Number.isSafeInteger(pending.retryCount) || pending.nextRetryAt !== void 0 && !isFiniteNumber(pending.nextRetryAt) || pending.createdAt !== void 0 && !isFiniteNumber(pending.createdAt)) {
+      throw new PendingRetryStateError("WeChat pending retry payload is invalid", "RETRY_STATE_CORRUPT");
+    }
+    total += pending.messages.length;
+  }
+  if (total > MAX_PENDING_RESET_MESSAGES) {
+    throw new PendingRetryStateError("WeChat pending retry message capacity exceeded", "RETRY_CAPACITY");
+  }
+}
+function loadPendingResetRetries(accountId, stateDir) {
+  const path = retryStorePath(accountId, stateDir);
+  const blocked = blockerPath(path);
+  if (existsSync(blocked)) {
+    let quarantine = quarantinePath(path);
+    try {
+      const marker = JSON.parse(readFileSync(blocked, "utf8"));
+      if (typeof marker.quarantine === "string") quarantine = marker.quarantine;
+    } catch {
+    }
+    throw new PendingRetryStateError(
+      `WeChat retry recovery is blocked by ${blocked}. Reconcile ${quarantine}, then explicitly remove the blocker to resume.`,
+      "RETRY_STATE_BLOCKED"
+    );
+  }
+  if (!existsSync(path)) return /* @__PURE__ */ new Map();
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf8"));
+    if (raw.version !== 1 || !Array.isArray(raw.entries)) {
+      throw new PendingRetryStateError("WeChat retry state schema is invalid", "RETRY_STATE_CORRUPT");
+    }
+    const entries = raw.entries;
+    validateEntries(entries);
+    return new Map(entries);
+  } catch (error) {
+    const quarantine = quarantinePath(path);
+    const blocked2 = blockerPath(path);
+    try {
+      rmSync(quarantine, { force: true });
+      renameSync(path, quarantine);
+      writeFileSync(blocked2, JSON.stringify({ version: 1, quarantine }), { mode: 384 });
+      syncPath(blocked2);
+      syncParent(path);
+    } catch (quarantineError) {
+      throw new PendingRetryStateError(
+        `WeChat retry state is unreadable at ${path}; quarantine failed (${String(quarantineError)}). Stop the channel and move this file aside manually.`,
+        "RETRY_STATE_CORRUPT"
+      );
+    }
+    throw new PendingRetryStateError(
+      `WeChat retry state was quarantined to ${quarantine} and blocked by ${blocked2}. Inspect/restore the quarantine, then explicitly remove the blocker to resume or discard after reconciliation. Cause: ${String(error)}`,
+      "RETRY_STATE_CORRUPT"
+    );
+  }
+}
+function persistPendingResetRetries(accountId, pending, stateDir) {
+  const path = retryStorePath(accountId, stateDir);
+  const entries = [...pending.entries()].filter(([, value]) => value.readyForDispatch);
+  validateEntries(entries);
+  if (entries.length === 0) {
+    if (!existsSync(path)) return;
+    rmSync(path, { force: true });
+    if (existsSync(dirname(path))) syncParent(path);
+    return;
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  const temp = `${path}.tmp-${process.pid}`;
+  writeFileSync(temp, JSON.stringify({ version: 1, entries }), { mode: 384 });
+  syncPath(temp);
+  renameSync(temp, path);
+  syncParent(path);
+}
+function persist(state) {
+  state.persist?.();
+}
+function mergeMessages(current, incoming) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const message of [...current, ...incoming]) {
+    merged.set(cursorMessageKey(message), message);
+  }
+  return [...merged.values()].sort((a, b) => a.localId - b.localId);
+}
+function assertStateCapacity(pending) {
+  validateEntries([...pending.entries()]);
+}
+function trimPendingResetRetries(state) {
+  assertStateCapacity(state.pendingMessageScans);
+  persist(state);
+}
+function clearPendingResetRetry(state, chatId) {
+  if (state.pendingMessageScans.delete(chatId)) persist(state);
+}
+function queueResetGenerationRetry(state, chatId, chat, messages, now = Date.now()) {
+  const existing = state.pendingMessageScans.get(chatId);
+  const merged = mergeMessages(existing?.messages ?? [], messages);
+  const next = {
+    chat,
+    messages: merged,
+    generationReset: true,
+    readyForDispatch: true,
+    retryCount: existing?.retryCount ?? 0,
+    nextRetryAt: existing?.nextRetryAt ?? now,
+    createdAt: existing?.createdAt ?? now
+  };
+  const projected = new Map(state.pendingMessageScans);
+  projected.set(chatId, next);
+  assertStateCapacity(projected);
+  state.pendingMessageScans.delete(chatId);
+  state.pendingMessageScans.set(chatId, next);
+  persist(state);
+}
+function mergePendingResetMessages(state, chatId, chat, messages) {
+  const pending = state.pendingMessageScans.get(chatId);
+  if (!pending?.readyForDispatch) return messages;
+  const merged = mergeMessages(pending.messages, messages);
+  const projected = new Map(state.pendingMessageScans);
+  projected.set(chatId, { ...pending, chat, messages: merged });
+  assertStateCapacity(projected);
+  state.pendingMessageScans.set(chatId, { ...pending, chat, messages: merged });
+  persist(state);
+  return merged;
+}
+function recordResetRetryFailure(state, chatId, now = Date.now()) {
+  const pending = state.pendingMessageScans.get(chatId);
+  if (!pending?.readyForDispatch) return;
+  const retryCount = (pending.retryCount ?? 0) + 1;
+  const delay = Math.min(MAX_RESET_RETRY_DELAY_MS, 1e3 * 2 ** Math.min(retryCount - 1, 6));
+  state.pendingMessageScans.set(chatId, {
+    ...pending,
+    retryCount,
+    nextRetryAt: now + delay
+  });
+  persist(state);
+}
+function monitorChatsToProcess(chats, state, now = Date.now()) {
+  const result = /* @__PURE__ */ new Map();
+  for (const pending of state.pendingMessageScans.values()) {
+    const chatId = pending.chat.username ?? pending.chat.id;
+    if ((pending.nextRetryAt ?? 0) <= now) result.set(chatId, pending.chat);
+  }
+  for (const chat of chats) {
+    const chatId = chat.username ?? chat.id;
+    if (chat.unreadCount > 0 || state.pendingMessageScans.has(chatId)) result.set(chatId, chat);
+  }
+  return result;
+}
+function commitResetDispatchPrefix(state, chatId, cursorMessage) {
+  if (cursorMessage === void 0) return;
+  const cursor = cursorMessage.localId;
+  const pending = state.pendingMessageScans.get(chatId);
+  if (!pending?.readyForDispatch) {
+    state.lastSeenId.set(chatId, cursor);
+    return;
+  }
+  const exactIndex = pending.messages.findIndex(
+    (message) => cursorMessageKey(message) === cursorMessageKey(cursorMessage)
+  );
+  if (exactIndex < 0) {
+    throw new PendingRetryStateError(
+      `Successful reset cursor identity is absent from pending chat ${chatId}`,
+      "RETRY_STATE_CORRUPT"
+    );
+  }
+  const remaining = pending.messages.slice(exactIndex + 1);
+  const projected = new Map(state.pendingMessageScans);
+  if (remaining.length === 0) {
+    projected.delete(chatId);
+  } else {
+    projected.set(chatId, { ...pending, messages: remaining, retryCount: 0, nextRetryAt: 0 });
+  }
+  assertStateCapacity(projected);
+  state.lastSeenId.set(chatId, cursor);
+  state.pendingMessageScans.clear();
+  for (const [key, value] of projected) state.pendingMessageScans.set(key, value);
+  persist(state);
+}
+
 // src/access-control.ts
 import {
   buildChannelKeyCandidates,
@@ -5910,6 +6401,23 @@ async function startWeChatMonitor(opts) {
   const { account, abortSignal, setStatus, log } = opts;
   const client = new WeChatClient({ baseUrl: account.serverUrl, token: account.token });
   const lastSeenId = /* @__PURE__ */ new Map();
+  const equalCursorUnreadHandled = /* @__PURE__ */ new Map();
+  const startupBaselines = /* @__PURE__ */ new Map();
+  const chatScanState = { initialScanComplete: false };
+  const pendingMessageScans = loadPendingResetRetries(account.accountId);
+  for (const [chatId, pending] of pendingMessageScans) {
+    const cursor = pending.messages.reduce(
+      (max, message) => Math.max(max, message.localId),
+      0
+    );
+    if (cursor > 0) lastSeenId.set(chatId, cursor);
+  }
+  const retryState = {
+    pendingMessageScans,
+    lastSeenId,
+    persist: () => persistPendingResetRetries(account.accountId, pendingMessageScans)
+  };
+  trimPendingResetRetries(retryState);
   const groupHistory = /* @__PURE__ */ new Map();
   const GROUP_HISTORY_LIMIT = 50;
   let lastAuthCheck = 0;
@@ -5978,8 +6486,15 @@ async function startWeChatMonitor(opts) {
         }
       }
       let chats;
+      let isInitialSnapshot = false;
       try {
-        chats = await client.listChats(50);
+        if (!chatScanState.initialScanComplete) {
+          chats = await listInitialMonitorChatSnapshot(client, chatScanState);
+          isInitialSnapshot = true;
+        } else {
+          const page = await listNextMonitorChatPage(client, chatScanState);
+          chats = page.chats;
+        }
       } catch (err) {
         log?.error?.(
           `[wechat:${account.accountId}] Failed to list chats: ${err}`
@@ -5987,9 +6502,28 @@ async function startWeChatMonitor(opts) {
         await sleep(account.pollIntervalMs, abortSignal);
         continue;
       }
+      if (isInitialSnapshot) {
+        for (const chat of chats) {
+          const chatId = chat.username ?? chat.id;
+          if (!startupBaselines.has(chatId)) {
+            const baseline = seedStartupBaselineFromChat(chat);
+            if (baseline) startupBaselines.set(chatId, baseline);
+          }
+        }
+      }
       const unreadChats = chats.filter(
         (c) => c.unreadCount > 0 && !isOfficialAccount(c.username ?? c.id)
       );
+      for (const chat of unreadChats) {
+        const chatId = chat.username ?? chat.id;
+        if (chatScanState.initialScanComplete && !lastSeenId.has(chatId) && !startupBaselines.has(chatId)) {
+          startupBaselines.set(chatId, { localId: 0 });
+        }
+      }
+      const chatsToProcess = monitorChatsToProcess(chats, retryState);
+      for (const chatId of chatsToProcess.keys()) {
+        if (isOfficialAccount(chatId)) chatsToProcess.delete(chatId);
+      }
       if (unreadChats.length > 0) {
         log?.info?.(
           `[wechat:${account.accountId}] ${unreadChats.length} chat(s) with unreads`
@@ -5997,13 +6531,17 @@ async function startWeChatMonitor(opts) {
       }
       let deferredThisTick = 0;
       let dispatchedThisTick = 0;
-      if (unreadChats.length > 0) {
-        for (const chat of unreadChats) {
+      if (chatsToProcess.size > 0) {
+        for (const chat of chatsToProcess.values()) {
           if (abortSignal.aborted) break;
           const result = await processUnreadChat(
             client,
             chat,
             lastSeenId,
+            equalCursorUnreadHandled,
+            startupBaselines,
+            pendingMessageScans,
+            retryState.persist,
             account,
             cfg,
             log,
@@ -6040,6 +6578,10 @@ async function startWeChatMonitor(opts) {
           client,
           chat,
           lastSeenId,
+          equalCursorUnreadHandled,
+          startupBaselines,
+          pendingMessageScans,
+          retryState.persist,
           account,
           cfg,
           log,
@@ -6473,7 +7015,7 @@ function bufferGroupHistory(groupHistory, chatId, pm, limit) {
     if (first) groupHistory.delete(first);
   }
 }
-async function processUnreadChat(client, chat, lastSeenId, account, cfg, log, skipOpen, groupHistory, groupHistoryLimit, catchup) {
+async function processUnreadChat(client, chat, lastSeenId, equalCursorUnreadHandled, startupBaselines, pendingMessageScans, persistRetryState, account, cfg, log, skipOpen, groupHistory, groupHistoryLimit, catchup) {
   const core = getWeChatRuntime();
   const liveAccount = resolveWeChatAccount(cfg, account.accountId) ?? account;
   const chatId = chat.username ?? chat.id;
@@ -6488,7 +7030,10 @@ async function processUnreadChat(client, chat, lastSeenId, account, cfg, log, sk
     cfg,
     surface: "wechat"
   });
-  if (!skipOpen) {
+  let opened = false;
+  const openChatIfNeeded = async () => {
+    if (skipOpen || opened) return;
+    opened = true;
     log?.info?.(`[wechat:${liveAccount.accountId}] Opening chat ${chatId}...`);
     try {
       await client.openChat(chatId, true);
@@ -6498,14 +7043,54 @@ async function processUnreadChat(client, chat, lastSeenId, account, cfg, log, sk
         `[wechat:${liveAccount.accountId}] Failed to open chat ${chatId}: ${err}`
       );
     }
-  }
+  };
   const firstPoll = !lastSeenId.has(chatId);
   const prevLastSeen = lastSeenId.get(chatId) ?? 0;
-  const recoveryWindow = Math.max(liveAccount.catchUpMaxMessages, 20);
-  const fetchLimit = Math.min(Math.max(chat.unreadCount, 20), recoveryWindow);
+  const startupBaseline = startupBaselines.get(chatId);
   let messages;
+  let generationResetConfirmed = false;
   try {
-    messages = await client.listMessages(chatId, fetchLimit);
+    const pending = pendingMessageScans.get(chatId);
+    if (pending?.readyForDispatch) {
+      const pendingTail = pending.messages.at(-1)?.localId ?? 0;
+      const scan = await listMessagesForMonitorCursor(client, chatId, {
+        chat,
+        firstPoll: false,
+        prevLastSeen: pendingTail,
+        handledCursor: equalCursorUnreadHandled.get(chatId)
+      });
+      messages = mergePendingResetMessages(
+        { pendingMessageScans, lastSeenId, persist: persistRetryState },
+        chatId,
+        chat,
+        scan.messages
+      );
+      generationResetConfirmed = pending.generationReset === true;
+    } else {
+      const scan = await listMessagesForMonitorCursor(client, chatId, {
+        chat,
+        firstPoll,
+        prevLastSeen,
+        startupBaseline,
+        handledCursor: equalCursorUnreadHandled.get(chatId),
+        continuation: pending
+      });
+      if (!scan.complete) {
+        pendingMessageScans.set(chatId, {
+          chat,
+          cursor: scan.nextCursor,
+          messages: scan.messages,
+          generationReset: scan.generationReset
+        });
+        log?.info?.(
+          `[wechat:${liveAccount.accountId}] ${chatId}: deferred after ${scan.pagesScanned} message page(s); continuing paged scan next tick`
+        );
+        return "deferred";
+      }
+      messages = scan.messages;
+      generationResetConfirmed = scan.generationReset === true;
+      pendingMessageScans.delete(chatId);
+    }
   } catch (err) {
     log?.error?.(
       `[wechat:${liveAccount.accountId}] Failed to list messages for ${chatId}: ${err}`
@@ -6516,33 +7101,72 @@ async function processUnreadChat(client, chat, lastSeenId, account, cfg, log, sk
     `[wechat:${liveAccount.accountId}] ${chatId}: fetched ${messages.length} msgs, firstPoll=${firstPoll}, prevLastSeen=${prevLastSeen}, unreadCount=${chat.unreadCount}`
   );
   if (messages.length === 0) return "skipped";
-  let newMessages;
-  if (firstPoll) {
-    messages.sort((a, b) => a.localId - b.localId);
-    const unread = chat.unreadCount ?? 0;
-    if (unread > 0 && unread < messages.length) {
-      newMessages = messages.slice(-unread);
-      const seenMax = messages[messages.length - unread - 1].localId;
-      lastSeenId.set(chatId, seenMax);
-    } else if (unread >= messages.length) {
-      newMessages = messages;
-    } else {
-      const maxId2 = messages[messages.length - 1].localId;
-      lastSeenId.set(chatId, maxId2);
-      return "skipped";
+  const enrichedBaseline = enrichStartupBaselineFromMessages(startupBaseline, messages);
+  if (enrichedBaseline) {
+    startupBaselines.set(chatId, enrichedBaseline);
+  }
+  const selected = selectCursorMessages(
+    chatId,
+    chat,
+    messages,
+    lastSeenId,
+    equalCursorUnreadHandled,
+    enrichedBaseline,
+    generationResetConfirmed
+  );
+  let newMessages = selected.messages;
+  if (selected.generationReset && !pendingMessageScans.get(chatId)?.readyForDispatch) {
+    queueResetGenerationRetry(
+      { pendingMessageScans, lastSeenId, persist: persistRetryState },
+      chatId,
+      chat,
+      newMessages
+    );
+  }
+  const advanceLastSeen = (handledMessages) => {
+    const cursor = markCursorMessagesHandled(chatId, handledMessages, equalCursorUnreadHandled);
+    if (cursor !== void 0) {
+      lastSeenId.set(chatId, cursor);
+      if (selected.generationReset) {
+        startupBaselines.delete(chatId);
+      }
+      const baseline = startupBaselines.get(chatId);
+      if (baseline && cursor >= baseline.localId) {
+        startupBaselines.delete(chatId);
+      }
+      const exactCursorMessage = handledMessages.reduce(
+        (latest, message) => latest === void 0 || message.localId > latest.localId ? message : message.localId === latest.localId ? message : latest,
+        void 0
+      );
+      commitResetDispatchPrefix(
+        { pendingMessageScans, lastSeenId, persist: persistRetryState },
+        chatId,
+        exactCursorMessage
+      );
     }
-  } else {
-    newMessages = messages.filter((m) => m.localId > prevLastSeen);
-    if (newMessages.length === 0) {
-      return "skipped";
+  };
+  const seedLastSeen = selected.seedLastSeen;
+  if (seedLastSeen !== void 0) {
+    advanceLastSeen(messages.filter((message) => message.localId <= seedLastSeen));
+  }
+  if (newMessages.length === 0) {
+    if (selected.generationReset) {
+      clearPendingResetRetry(
+        { pendingMessageScans, lastSeenId, persist: persistRetryState },
+        chatId
+      );
     }
-    newMessages.sort((a, b) => a.localId - b.localId);
+    if (chat.unreadCount > 0) {
+      await openChatIfNeeded();
+    }
+    return "skipped";
   }
+  await openChatIfNeeded();
   const catchUpLimits = {
     maxMessages: liveAccount.catchUpMaxMessages,
     maxAgeMs: liveAccount.catchUpMaxAgeMs
   };
-  const isRecovery = firstPoll || skipOpen === true && isCatchUpBatch(newMessages, catchUpLimits);
+  const isRecovery = firstPoll && startupBaseline === void 0 || skipOpen === true && isCatchUpBatch(newMessages, catchUpLimits);
   if (isRecovery) {
     const selection = selectCatchUpMessages(
       newMessages,
@@ -6551,7 +7175,7 @@ async function processUnreadChat(client, chat, lastSeenId, account, cfg, log, sk
     );
     const observedCursor = recoveryCursor(selection);
     if (liveAccount.catchUpMode === "read-only") {
-      lastSeenId.set(chatId, observedCursor);
+      advanceLastSeen(messages.filter((message) => message.localId <= observedCursor));
       log?.info?.(
         `[wechat:${liveAccount.accountId}] Recovery read-only: advanced ${chatId} to ${observedCursor} without dispatching ${newMessages.length} msg(s)`
       );
@@ -6559,7 +7183,7 @@ async function processUnreadChat(client, chat, lastSeenId, account, cfg, log, sk
     }
     newMessages = selection.messages;
     if (newMessages.length === 0) {
-      lastSeenId.set(chatId, observedCursor);
+      advanceLastSeen(messages.filter((message) => message.localId <= observedCursor));
       log?.info?.(
         `[wechat:${liveAccount.accountId}] Recovery skipped ${selection.skipped} stale msg(s) in ${chatId}`
       );
@@ -6597,7 +7221,7 @@ async function processUnreadChat(client, chat, lastSeenId, account, cfg, log, sk
         }
         log?.info?.(`[wechat:${liveAccount.accountId}] Buffered ${processed.length} msg(s) for group history in ${chatId}`);
         const maxId2 = Math.max(...newMessages.map((m) => m.localId));
-        lastSeenId.set(chatId, maxId2);
+        advanceLastSeen(newMessages.filter((message) => message.localId <= maxId2));
         return "skipped";
       }
       if (hasMention) {
@@ -6662,8 +7286,8 @@ async function processUnreadChat(client, chat, lastSeenId, account, cfg, log, sk
       log?.info?.(
         `[wechat:${liveAccount.accountId}] Skipping stale group chatter in ${chatId}`
       );
-      const maxId3 = Math.max(...newMessages.map((m) => m.localId));
-      lastSeenId.set(chatId, maxId3);
+      const maxId2 = Math.max(...newMessages.map((m) => m.localId));
+      advanceLastSeen(newMessages.filter((message) => message.localId <= maxId2));
       return "skipped";
     }
     const fold = shouldFoldSegments(catchup?.isReconnect ?? false) && !hasControlCommandInWindow;
@@ -6672,6 +7296,7 @@ async function processUnreadChat(client, chat, lastSeenId, account, cfg, log, sk
       `[wechat:${liveAccount.accountId}] ${chatId}: ${processed.length} dispatchable msg(s) in ${segments.length} segment(s) (${decision.reason})`
     );
     let allDispatched = true;
+    const successfulSegmentLastLocalIds = [];
     for (let i = 0; i < segments.length; i++) {
       const remaining = segments.length - i - 1;
       const dispatched = await dispatchSegment(
@@ -6689,17 +7314,27 @@ async function processUnreadChat(client, chat, lastSeenId, account, cfg, log, sk
       );
       if (!dispatched) {
         allDispatched = false;
+        break;
       }
+      successfulSegmentLastLocalIds.push(
+        Math.max(...segments[i].map((pm) => pm.msg.localId))
+      );
     }
     if (clearBufferedHistory && allDispatched && groupHistory) {
       groupHistory.set(chatId, []);
     }
-    const maxId2 = Math.max(...newMessages.map((m) => m.localId));
-    lastSeenId.set(chatId, maxId2);
+    const handledMessages = allDispatched ? newMessages : selectMessagesHandledAfterDispatch(newMessages, successfulSegmentLastLocalIds);
+    advanceLastSeen(handledMessages);
+    if (!allDispatched) {
+      recordResetRetryFailure(
+        { pendingMessageScans, lastSeenId, persist: persistRetryState },
+        chatId
+      );
+    }
     return allDispatched ? "dispatched" : "skipped";
   }
   const maxId = Math.max(...newMessages.map((m) => m.localId));
-  lastSeenId.set(chatId, maxId);
+  advanceLastSeen(newMessages.filter((message) => message.localId <= maxId));
   return "skipped";
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kyan-du/agent-wechat-openclaw",
-  "version": "0.12.0-next.0",
+  "version": "0.12.0",
   "type": "module",
   "files": [
     "dist",
@@ -26,7 +26,7 @@
     "channel": {
       "id": "wechat",
       "label": "WeChat",
-      "selectionLabel": "WeChat (\u5fae\u4fe1)",
+      "selectionLabel": "WeChat (微信)",
       "aliases": [
         "weixin"
       ],