openclaw-lark-multi-agent 1.0.5 → 1.0.7

package/dist/feishu-bot.d.ts

@@ -102,6 +102,7 @@ export declare class FeishuBot {
     private inferFeishuFileType;
     private isImagePath;
     private errorSummary;
+    private stripReadOnlyDocxFields;
     private createFeishuDocFromMarkdown;
     private sendBridgeAttachment;
     private sendBridgeFileAttachment;

package/dist/feishu-bot.js

@@ -637,25 +637,27 @@ export class FeishuBot {
     }
     async processQueueInner(chatId) {
         while (true) {
-            const unsyncedMessages = this.store.getUnsyncedMessages(this.config.name, chatId);
             const pendingMessages = this.store.getPendingTriggerMessages(this.config.name, chatId);
-            const messageById = new Map();
-            for (const msg of [...unsyncedMessages, ...pendingMessages]) {
-                if (msg.id)
-                    messageById.set(msg.id, msg);
-            }
-            const allUnsynced = Array.from(messageById.values()).sort((a, b) => a.timestamp - b.timestamp);
             const pendingTriggerIds = this.store.getPendingTriggerIds(this.config.name, chatId);
             // Only proceed if there are pending human messages that should actively trigger this bot.
-            // Pending triggers are included even if a later bridge command has advanced sync_state.
-            const humanUnsynced = allUnsynced.filter((m) => m.senderType === "human" && m.id && pendingTriggerIds.has(m.id));
-            if (humanUnsynced.length === 0) {
+            const pendingHumanTriggers = pendingMessages
+                .filter((m) => m.senderType === "human" && m.id && pendingTriggerIds.has(m.id))
+                .sort((a, b) => a.timestamp - b.timestamp);
+            if (pendingHumanTriggers.length === 0) {
                 break;
             }
             this.busyChats.set(chatId, Date.now());
-            // The last trigger message is the "current" one, everything else is context
-            const lastHuman = humanUnsynced[humanUnsynced.length - 1];
+            // The last trigger message is the "current" one, everything else is context.
+            const lastHuman = pendingHumanTriggers[pendingHumanTriggers.length - 1];
             const triggerId = lastHuman.id || 0;
+            const catchupMessages = this.store.getUnsyncedMessagesForBot(this.config.name, chatId, triggerId);
+            const messageById = new Map();
+            for (const msg of [...catchupMessages, ...pendingMessages]) {
+                if (msg.id)
+                    messageById.set(msg.id, msg);
+            }
+            const allUnsynced = Array.from(messageById.values()).sort((a, b) => a.timestamp - b.timestamp);
+            const humanUnsynced = allUnsynced.filter((m) => m.senderType === "human" && m.id && pendingTriggerIds.has(m.id));
             if (triggerId && this.store.hasDeliveredReply(this.config.name, chatId, triggerId)) {
                 console.warn(`[${this.config.name}] Duplicate trigger skipped for ${chatId.slice(-8)} msgId=${triggerId}`);
                 this.store.clearPendingTriggers(this.config.name, chatId, triggerId);
@@ -716,6 +718,8 @@ export class FeishuBot {
                 // must remain pending for the next loop.
                 const maxId = Math.max(...allUnsynced.map((m) => m.id || 0));
                 const processedTriggerIds = new Set(humanUnsynced.map((m) => m.id || 0).filter(Boolean));
+                const syncBatchId = `${this.config.name}:${chatId}:${triggerId}:${Date.now()}`;
+                this.store.markMessagesSynced(this.config.name, chatId, allUnsynced.map((m) => m.id || 0), syncBatchId);
                 this.store.markSynced(this.config.name, chatId, maxId);
                 this.store.clearPendingTriggers(this.config.name, chatId, maxId);
                 const shouldReply = trimmedReply.length > 0 && !explicitNoReply;
@@ -739,8 +743,10 @@ export class FeishuBot {
                         // Do not advance sync past a human message that arrived while this
                         // run was busy. Otherwise the pending trigger remains in the table
                         // but getUnsyncedMessages() can no longer see it.
-                        if (!hasEarlierPending)
+                        if (!hasEarlierPending) {
+                            this.store.markMessagesSynced(this.config.name, chatId, [replyId], `${this.config.name}:${chatId}:reply:${replyId}`);
                             this.store.markSynced(this.config.name, chatId, replyId);
+                        }
                     }
                 }
                 // Wait for all pending tool event messages to be delivered first
@@ -1227,6 +1233,20 @@ export class FeishuBot {
         const msg = data?.msg || data?.message || err?.message || String(err);
         return `${code}${msg}`.slice(0, 800);
     }
+    stripReadOnlyDocxFields(value) {
+        if (Array.isArray(value))
+            return value.map((item) => this.stripReadOnlyDocxFields(item));
+        if (value && typeof value === "object") {
+            const out = {};
+            for (const [key, child] of Object.entries(value)) {
+                if (key === "merge_info")
+                    continue;
+                out[key] = this.stripReadOnlyDocxFields(child);
+            }
+            return out;
+        }
+        return value;
+    }
     async createFeishuDocFromMarkdown(filePath) {
         const rawTitle = basename(filePath).replace(/\.[^.]+$/, "").trim() || "Markdown Document";
         const markdown = readFileSync(filePath, "utf8");
@@ -1238,7 +1258,7 @@ export class FeishuBot {
             throw new Error(`Feishu doc create returned no document_id for ${filePath}`);
         const converted = await docx.document.convert({ data: { content_type: "markdown", content: markdown } });
         const convertedData = converted?.data || converted;
-        const blocks = convertedData?.blocks || [];
+        const blocks = this.stripReadOnlyDocxFields(convertedData?.blocks || []);
         const firstLevelBlockIds = convertedData?.first_level_block_ids || [];
         if (Array.isArray(blocks) && blocks.length > 0) {
             await docx.documentBlockDescendant.create({

package/dist/message-store.d.ts

@@ -74,6 +74,12 @@ export declare class MessageStore {
      * Returns messages ordered by timestamp ascending.
      */
     getUnsyncedMessages(botName: string, chatId: string, maxCount?: number): ChatMessage[];
+    /**
+     * Get all messages at or before triggerRowId that have not been synced to a
+     * bot's session yet. Ordered by timestamp ascending.
+     */
+    getUnsyncedMessagesForBot(botName: string, chatId: string, triggerRowId: number): ChatMessage[];
+    markMessagesSynced(botName: string, chatId: string, messageRowIds: number[], syncBatchId?: string): void;
     /**
      * Mark all messages up to (and including) the given id as synced for a bot.
      */

package/dist/message-store.js

@@ -23,6 +23,7 @@ export class MessageStore {
         timestamp INTEGER NOT NULL
       );
       CREATE INDEX IF NOT EXISTS idx_messages_chat_ts ON messages(chat_id, timestamp);
+      CREATE INDEX IF NOT EXISTS idx_messages_chat_id ON messages(chat_id, id);
 
       CREATE TABLE IF NOT EXISTS chat_info (
         chat_id TEXT PRIMARY KEY,
@@ -36,7 +37,8 @@ export class MessageStore {
         updated_at INTEGER NOT NULL DEFAULT 0
       );
 
-      -- Tracks which messages have been synced to each bot's OpenClaw session.
+      -- Legacy high-water mark for which messages have been synced to each
+      -- bot's OpenClaw session. Kept for compatibility and quick inspection.
       CREATE TABLE IF NOT EXISTS sync_state (
         bot_name TEXT NOT NULL,
         chat_id TEXT NOT NULL,
@@ -44,6 +46,18 @@ export class MessageStore {
         PRIMARY KEY (bot_name, chat_id)
       );
 
+      -- Per-message sync ledger. This lets a bot catch up on all missed group
+      -- messages without relying only on a coarse high-water mark.
+      CREATE TABLE IF NOT EXISTS message_sync (
+        bot_name TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        message_row_id INTEGER NOT NULL,
+        synced_at INTEGER NOT NULL,
+        sync_batch_id TEXT NOT NULL DEFAULT '',
+        PRIMARY KEY (bot_name, chat_id, message_row_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_message_sync_bot_chat ON message_sync(bot_name, chat_id, message_row_id);
+
       -- Tracks which messages have been processed by each bot (multi-bot dedup).
       CREATE TABLE IF NOT EXISTS processed_events (
         bot_name TEXT NOT NULL,
@@ -428,6 +442,48 @@ export class MessageStore {
             timestamp: r.timestamp,
         }));
     }
+    /**
+     * Get all messages at or before triggerRowId that have not been synced to a
+     * bot's session yet. Ordered by timestamp ascending.
+     */
+    getUnsyncedMessagesForBot(botName, chatId, triggerRowId) {
+        const rows = this.db.prepare(`
+      SELECT messages.* FROM messages
+      LEFT JOIN recalled_messages ON recalled_messages.message_id = messages.message_id
+      LEFT JOIN message_sync ON message_sync.bot_name = ?
+        AND message_sync.chat_id = messages.chat_id
+        AND message_sync.message_row_id = messages.id
+      WHERE messages.chat_id = ?
+        AND messages.id <= ?
+        AND recalled_messages.message_id IS NULL
+        AND message_sync.message_row_id IS NULL
+      ORDER BY messages.timestamp ASC
+    `).all(botName, chatId, triggerRowId);
+        return rows.map((r) => ({
+            id: r.id,
+            chatId: r.chat_id,
+            messageId: r.message_id,
+            senderType: r.sender_type,
+            senderName: r.sender_name,
+            content: r.content,
+            timestamp: r.timestamp,
+        }));
+    }
+    markMessagesSynced(botName, chatId, messageRowIds, syncBatchId = '') {
+        const ids = Array.from(new Set(messageRowIds.filter((id) => Number.isFinite(id) && id > 0)));
+        if (ids.length === 0)
+            return;
+        const now = Date.now();
+        const stmt = this.db.prepare(`
+      INSERT OR IGNORE INTO message_sync (bot_name, chat_id, message_row_id, synced_at, sync_batch_id)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+        const tx = this.db.transaction((rows) => {
+            for (const id of rows)
+                stmt.run(botName, chatId, id, now, syncBatchId);
+        });
+        tx(ids);
+    }
     /**
      * Mark all messages up to (and including) the given id as synced for a bot.
      */

package/dist/openclaw-client.d.ts

@@ -39,6 +39,8 @@ export declare class OpenClawClient {
     constructor(config: OpenClawConfig);
     connect(): Promise<void>;
     private _doConnect;
+    private extractVisibleUserText;
+    private extractVisibleAssistantText;
     private handleProactiveSessionMessage;
     private scheduleReconnect;
     private rpc;
@@ -122,6 +124,8 @@ export declare class OpenClawClient {
         timeoutMs?: number;
         emptyFinalAsNoReply?: boolean;
     }): Promise<string>;
+    private formatContextLines;
+    private writeContextSyncFile;
     private extractImageAttachments;
     disconnect(): Promise<void>;
     /**

package/dist/openclaw-client.js

@@ -1,11 +1,14 @@
 import WebSocket from "ws";
 import { randomUUID } from "crypto";
-import { readFileSync } from "fs";
-import { basename, extname } from "path";
-import { getBridgeAttachmentsDir } from "./paths.js";
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { basename, extname, join } from "path";
+import { getBridgeAttachmentsDir, getStateDir } from "./paths.js";
 export const GATEWAY_PROTOCOL_MIN = 3;
 export const GATEWAY_PROTOCOL_MAX = 4;
 const BRIDGE_ATTACHMENTS_DIR = getBridgeAttachmentsDir();
+const CONTEXT_SYNC_DIR = join(getStateDir(), "context-sync");
+const MAX_INLINE_CONTEXT_MESSAGES = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_MAX_INLINE_CONTEXT_MESSAGES || 1000);
+const MAX_INLINE_CONTEXT_BYTES = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_MAX_INLINE_CONTEXT_BYTES || 8 * 1024 * 1024);
 /**
  * OpenClaw Gateway WebSocket client.
  * Full agent pipeline — tools, memory, skills, context management by OpenClaw.
@@ -164,6 +167,28 @@ export class OpenClawClient {
                     // Try both raw key and without agent:main: prefix
                     const shortKey = rawKey.replace(/^agent:[^:]+:/, "");
                     const msg = frame.payload.message || frame.payload;
+                    const visibleUserText = this.extractVisibleUserText(msg);
+                    if (visibleUserText) {
+                        if (!this.agentEvents.has(rawKey))
+                            this.agentEvents.set(rawKey, []);
+                        this.agentEvents.get(rawKey).push({
+                            runId: frame.payload.runId,
+                            sessionKey: rawKey,
+                            stream: "sessionUser",
+                            data: { text: visibleUserText },
+                        });
+                    }
+                    const visibleAssistantText = this.extractVisibleAssistantText(msg);
+                    if (visibleAssistantText) {
+                        if (!this.agentEvents.has(rawKey))
+                            this.agentEvents.set(rawKey, []);
+                        this.agentEvents.get(rawKey).push({
+                            runId: frame.payload.runId,
+                            sessionKey: rawKey,
+                            stream: "assistant",
+                            data: { deltaText: visibleAssistantText, delta: visibleAssistantText, replace: true },
+                        });
+                    }
                     this.handleProactiveSessionMessage(rawKey, msg);
                     // Tool calls in assistant messages — skip, using agent item events instead
                     // (session.message toolCall events are batched, not real-time)
@@ -196,39 +221,50 @@ export class OpenClawClient {
             });
         });
     }
+    extractVisibleUserText(msg) {
+        if (msg?.role !== "user")
+            return "";
+        const content = msg.content;
+        if (typeof content === "string")
+            return content.trim();
+        if (!Array.isArray(content))
+            return "";
+        return content
+            .filter((part) => part?.type === "text" && typeof part.text === "string")
+            .map((part) => part.text)
+            .join("\n")
+            .trim();
+    }
+    extractVisibleAssistantText(msg) {
+        if (msg?.role !== "assistant")
+            return "";
+        const content = msg.content;
+        // Extract only visible text parts and ignore thinking/tool blocks.
+        if (typeof content === "string")
+            return content.trim();
+        if (!Array.isArray(content))
+            return "";
+        const hasToolBlock = content.some((part) => {
+            const type = String(part?.type || "").toLowerCase();
+            return type === "toolcall" || type === "tool_call" || type === "tooluse" || type === "tool_use" || type === "toolresult" || type === "tool_result";
+        });
+        // Do not deliver mixed text+toolCall assistant messages through the
+        // final-text path; those are usually intermediate tool-loop status.
+        if (hasToolBlock)
+            return "";
+        return content
+            .filter((part) => part?.type === "text" && typeof part.text === "string")
+            .map((part) => part.text)
+            .join("\n")
+            .trim();
+    }
     handleProactiveSessionMessage(rawKey, msg) {
         const shortKey = rawKey.replace(/^agent:[^:]+:/, "");
-        const role = msg.role;
-        const content = msg.content;
         // Proactive assistant text messages. Cron/session-targeted runs often emit
         // structured content arrays rather than a plain string. Extract only visible
         // text parts and ignore thinking/tool blocks so the bridge can deliver final
         // cron results via the bot.
-        let proactiveText = "";
-        if (role === "assistant") {
-            if (typeof content === "string") {
-                proactiveText = content;
-            }
-            else if (Array.isArray(content)) {
-                const hasToolBlock = content.some((part) => {
-                    const type = String(part?.type || "").toLowerCase();
-                    return type === "toolcall" || type === "tool_call" || type === "tooluse" || type === "tool_use" || type === "toolresult" || type === "tool_result";
-                });
-                // Do not deliver mixed text+toolCall assistant messages through
-                // the proactive final-text path; those are usually intermediate
-                // reasoning/status during a tool loop. Tool calls are still
-                // delivered via the verbose channel from agent item events when
-                // /verbose is enabled. Cron final messages arrive as text-only
-                // (optionally with thinking).
-                if (!hasToolBlock) {
-                    proactiveText = content
-                        .filter((part) => part?.type === "text" && typeof part.text === "string")
-                        .map((part) => part.text)
-                        .join("\n")
-                        .trim();
-                }
-            }
-        }
+        const proactiveText = this.extractVisibleAssistantText(msg);
         if (!proactiveText)
             return false;
         if (this.mutedProactiveSessions.has(rawKey) || this.mutedProactiveSessions.has(shortKey)) {
@@ -293,12 +329,28 @@ export class OpenClawClient {
             let text = "";
             let chatDeltaText = "";
             let chatFinalText = "";
-            let sessionKey = targetSessionKey ? `agent:main:${targetSessionKey}` : "";
+            let sessionKey = targetSessionKey ? `agent:main:${targetSessionKey.replace(/^agent:[^:]+:/, "")}` : "";
+            let shortSessionKey = targetSessionKey ? targetSessionKey.replace(/^agent:[^:]+:/, "") : "";
             let chatFinalTimer = null;
             let lifecycleEndTimer = null;
             let replayInvalidTimer = null;
+            let pendingRuntimeFailureText = "";
+            let lastActivitySummary = "";
+            let lastActivityAt = 0;
             const collectStartedAt = Date.now();
             let lifecycleStartedLogged = false;
+            const expectedUserText = options?.expectedUserText?.trim() || "";
+            let anchorSeen = !expectedUserText;
+            const activeRunIds = new Set([runId]);
+            let preAnchorEvents = [];
+            const normalizeText = (value) => value.replace(/\s+/g, " ").trim();
+            const isExpectedUserText = (value) => {
+                const actual = normalizeText(value);
+                const expected = normalizeText(expectedUserText);
+                if (!actual || !expected)
+                    return false;
+                return actual === expected || actual.includes(expected) || expected.includes(actual);
+            };
             let idleTimer;
             const resetIdleTimer = () => {
                 if (idleTimer)
@@ -315,9 +367,69 @@ export class OpenClawClient {
                     this.abortChat(targetSessionKey || sessionKey, runId).catch((err) => {
                         console.warn(`[OpenClaw] abort after collectReply idle timeout failed:`, err.message);
                     });
-                    resolve(text || chatDeltaText || chatFinalText || "(timeout: no reply received)");
+                    const visibleText = text || chatDeltaText || chatFinalText;
+                    if (visibleText) {
+                        resolve(visibleText);
+                    }
+                    else if (pendingRuntimeFailureText) {
+                        resolve(`${pendingRuntimeFailureText}\n\nLMA 已连续 ${Math.round(timeoutMs / 60000)} 分钟没有收到新的工具输出或最终回复，已停止等待。`);
+                    }
+                    else if (lastActivitySummary) {
+                        resolve(`⚠️ Agent 长时间没有产生最终回复\n最后活动: ${lastActivitySummary}\n时间: ${new Date(lastActivityAt).toLocaleString()}\n\nLMA 已连续 ${Math.round(timeoutMs / 60000)} 分钟没有收到新的工具输出或最终回复，已停止等待。`);
+                    }
+                    else {
+                        resolve("(timeout: no reply received)");
+                    }
                 }, timeoutMs);
             };
+            const summarizeActivity = (ev) => {
+                if (ev.stream === "item") {
+                    const data = ev.data || {};
+                    if (data.kind === "tool") {
+                        const phase = data.phase ? ` ${data.phase}` : "";
+                        const meta = typeof data.meta === "string" && data.meta.trim() ? `: ${data.meta.trim().slice(0, 300)}` : "";
+                        return `工具${phase}${data.name ? ` ${data.name}` : ""}${meta}`;
+                    }
+                    return `运行事件 item${data.kind ? `/${data.kind}` : ""}`;
+                }
+                if (ev.stream === "assistant" || ev.stream === "chatDelta") {
+                    const chunk = String(ev.data?.deltaText || ev.data?.delta || "").trim();
+                    return chunk ? `模型输出片段: ${chunk.slice(0, 300)}` : "模型输出片段";
+                }
+                if (ev.stream === "chatFinal")
+                    return "收到 chat final 事件";
+                if (ev.stream === "lifecycle") {
+                    const state = ev.data?.livenessState || ev.data?.status || ev.data?.phase || "unknown";
+                    const reason = ev.data?.stopReason ? `, reason=${ev.data.stopReason}` : "";
+                    const replay = ev.data?.replayInvalid ? ", replayInvalid" : "";
+                    return `运行状态: ${state}${replay}${reason}`;
+                }
+                return `事件: ${ev.stream || "unknown"}`;
+            };
+            const rememberActivity = (ev) => {
+                // A replay-invalid lifecycle end is the terminal symptom, not the useful
+                // last activity. Keep the previous tool/model activity so user-visible
+                // timeout messages explain what the agent was actually doing.
+                if (ev.stream === "lifecycle" && ev.data?.phase === "end" && ev.data?.replayInvalid && lastActivitySummary)
+                    return;
+                const summary = summarizeActivity(ev);
+                if (summary) {
+                    lastActivitySummary = summary;
+                    lastActivityAt = Date.now();
+                }
+            };
+            const buildFailureText = (ev) => {
+                const state = ev.data?.livenessState || ev.data?.status || "unknown";
+                const reason = ev.data?.stopReason || "";
+                const replayInvalid = ev.data?.replayInvalid ? ", replayInvalid" : "";
+                const lines = [`⚠️ Agent 未正常完成`, `状态: ${state}${replayInvalid}${reason ? "\n原因: " + reason : ""}`];
+                if (lastActivitySummary) {
+                    lines.push(`最后活动: ${lastActivitySummary}`);
+                    lines.push(`最后活动时间: ${new Date(lastActivityAt).toLocaleString()}`);
+                }
+                lines.push("请重试，或用 /reset 重置会话");
+                return lines.join("\n");
+            };
             resetIdleTimer();
             const finish = (finalText) => {
                 clearTimeout(idleTimer);
@@ -332,7 +444,7 @@ export class OpenClawClient {
             };
             const poller = setInterval(() => {
                 const bucketsToScan = sessionKey
-                    ? [sessionKey]
+                    ? Array.from(new Set([sessionKey, shortSessionKey].filter(Boolean)))
                     : Array.from(this.agentEvents.keys());
                 for (const bucketKey of bucketsToScan) {
                     const bucket = this.agentEvents.get(bucketKey);
@@ -342,18 +454,74 @@ export class OpenClawClient {
                     while (i < bucket.length) {
                         const ev = bucket[i];
                         const evRunId = typeof ev.runId === "string" ? ev.runId : "";
-                        const matchesRun = evRunId ? evRunId === runId : false;
-                        // OpenClaw chat.send may emit the user-facing chat runId while the actual
-                        // agent lifecycle uses an internal runId. We clear this session's event buffer
-                        // immediately before chat.send, so matching by sessionKey here is safe and
-                        // necessary to collect the real agent output.
-                        const matchesSession = sessionKey && (ev.sessionKey === sessionKey || ev.sessionKey === targetSessionKey);
-                        if (matchesRun || matchesSession) {
-                            if (!sessionKey && ev.sessionKey)
-                                sessionKey = ev.sessionKey;
+                        const eventSessionMatches = Boolean(sessionKey && (ev.sessionKey === sessionKey || ev.sessionKey === targetSessionKey || ev.sessionKey === shortSessionKey));
+                        const matchesRun = evRunId ? activeRunIds.has(evRunId) : false;
+                        if (!sessionKey && ev.sessionKey) {
+                            shortSessionKey = String(ev.sessionKey).replace(/^agent:[^:]+:/, "");
+                            sessionKey = `agent:main:${shortSessionKey}`;
+                        }
+                        if (eventSessionMatches && ev.stream === "sessionUser") {
+                            bucket.splice(i, 1);
+                            if (!anchorSeen && isExpectedUserText(ev.data?.text || "")) {
+                                anchorSeen = true;
+                                resetIdleTimer();
+                                for (const pendingEv of preAnchorEvents) {
+                                    const pendingRunId = typeof pendingEv.runId === "string" ? pendingEv.runId : "";
+                                    if (pendingRunId && pendingEv.stream === "lifecycle" && pendingEv.data?.phase === "start") {
+                                        activeRunIds.add(pendingRunId);
+                                    }
+                                }
+                                const replay = preAnchorEvents.filter((pendingEv) => {
+                                    const pendingRunId = typeof pendingEv.runId === "string" ? pendingEv.runId : "";
+                                    return !pendingRunId || activeRunIds.has(pendingRunId);
+                                });
+                                preAnchorEvents = [];
+                                if (replay.length)
+                                    bucket.splice(i, 0, ...replay);
+                            }
+                            else if (!anchorSeen) {
+                                // A different user/runtime continuation belongs to stale queued work;
+                                // anything before it should not be attributed to the next real user turn.
+                                preAnchorEvents = [];
+                            }
+                            continue;
+                        }
+                        if (eventSessionMatches && expectedUserText && !anchorSeen && !matchesRun) {
+                            bucket.splice(i, 1);
+                            preAnchorEvents.push(ev);
+                            if (preAnchorEvents.length > 200)
+                                preAnchorEvents.shift();
+                            continue;
+                        }
+                        let matchesSession = false;
+                        if (eventSessionMatches && anchorSeen) {
+                            if (!expectedUserText) {
+                                // Backward-compatible mode for tests/internal callers that do not
+                                // provide an anchor: allow session-key matching as before.
+                                matchesSession = true;
+                            }
+                            else if (!evRunId) {
+                                matchesSession = true;
+                            }
+                            else if (activeRunIds.has(evRunId)) {
+                                matchesSession = true;
+                            }
+                            else if (ev.stream === "lifecycle" && ev.data?.phase === "start") {
+                                activeRunIds.add(evRunId);
+                                matchesSession = true;
+                            }
                         }
-                        else {
-                            i++;
+                        if (!(matchesRun || matchesSession)) {
+                            // When collectReply is anchored to a specific user message, discard stale
+                            // session events that arrive before that anchor (or from unrelated runIds)
+                            // so replayInvalid/aborted events from older runtime continuations cannot
+                            // be misattributed to the current user turn.
+                            if (eventSessionMatches && expectedUserText) {
+                                bucket.splice(i, 1);
+                            }
+                            else {
+                                i++;
+                            }
                             continue;
                         }
                         bucket.splice(i, 1);
@@ -361,12 +529,16 @@ export class OpenClawClient {
                         // means the agent is still alive. Use an idle timeout, not an absolute
                         // wall-clock timeout, so long tool-heavy tasks are not killed while active.
                         resetIdleTimer();
+                        rememberActivity(ev);
                         // If more events arrive after a replay-invalid lifecycle end, that lifecycle
                         // was not terminal for the user-visible run. Keep waiting for the real final.
                         if (replayInvalidTimer) {
                             clearTimeout(replayInvalidTimer);
                             replayInvalidTimer = null;
                         }
+                        if (ev.stream !== "lifecycle") {
+                            pendingRuntimeFailureText = "";
+                        }
                         if (ev.stream === "lifecycle" && ev.data?.phase === "start" && !lifecycleStartedLogged) {
                             lifecycleStartedLogged = true;
                             console.log(`[OpenClaw] lifecycle start for runId=${runId} after ${Date.now() - collectStartedAt}ms`);
@@ -433,13 +605,10 @@ export class OpenClawClient {
                                     return;
                                 }
                                 if (!latestFinalText) {
-                                    const state = ev.data?.livenessState || "unknown";
-                                    const reason = ev.data?.stopReason || "";
-                                    const replayInvalid = ev.data?.replayInvalid ? ", replayInvalid" : "";
-                                    const failureText = `⚠️ Agent 未正常完成\n状态: ${state}${replayInvalid}${reason ? "\n原因: " + reason : ""}\n请重试，或用 /reset 重置会话`;
+                                    const failureText = buildFailureText(ev);
                                     if (ev.data?.replayInvalid) {
-                                        console.warn(`[OpenClaw] replayInvalid lifecycle observed for runId=${evRunId || runId}; waiting for subsequent events before surfacing failure`);
-                                        replayInvalidTimer = setTimeout(() => finish(failureText), 120000);
+                                        pendingRuntimeFailureText = failureText;
+                                        console.warn(`[OpenClaw] replayInvalid lifecycle observed for runId=${evRunId || runId}; waiting for real text or idle timeout`);
                                         return;
                                     }
                                     if (ev.data?.livenessState !== "working") {
@@ -453,7 +622,7 @@ export class OpenClawClient {
                             };
                             // If lifecycle end beats chat final, a short delta like "N" can be a truncated
                             // final reply. Wait for chatFinal before resolving; otherwise suppress lone "N".
-                            if (!options?.emptyFinalAsNoReply && !chatFinalText && text.length <= 1) {
+                            if (!options?.emptyFinalAsNoReply && ev.data?.livenessState === "working" && !chatFinalText && text.length <= 1) {
                                 lifecycleEndTimer = setTimeout(finishFromLifecycle, 5000);
                             }
                             else {
@@ -679,7 +848,7 @@ export class OpenClawClient {
                 idempotencyKey: randomUUID(),
             });
             console.log(`[OpenClaw] chat.send runId: ${result.runId} (rpc=${Date.now() - sendStartedAt}ms, attachments=${params.attachments?.length || 0})`);
-            return await this.collectReply(result.runId, params.timeoutMs || 1800000, sk, { emptyFinalAsNoReply: params.emptyFinalAsNoReply });
+            return await this.collectReply(result.runId, params.timeoutMs || 1800000, sk, { emptyFinalAsNoReply: params.emptyFinalAsNoReply, expectedUserText: params.message });
         }
         finally {
             // OpenClaw can emit the final assistant session.message a moment after
@@ -733,20 +902,30 @@ export class OpenClawClient {
                 emptyFinalAsNoReply: params.emptyFinalAsNoReply,
             });
         }
-        // Build context block + actual message in one chat.send
-        const contextLines = params.unsyncedMessages.map((m) => {
-            const time = new Date(m.timestamp).toLocaleTimeString("zh-CN", {
-                hour: "2-digit",
-                minute: "2-digit",
-                hour12: false,
-            });
-            const tag = m.senderType === "bot" ? `${m.senderName} (AI)` : m.senderName;
-            return `[${tag} ${time}]: ${m.content}`;
-        });
-        const combined = `[以下是你不在线期间群里的对话，请了解上下文]\n` +
-            contextLines.join("\n") +
-            `\n---\n` +
-            `[${params.currentSenderName}]: ${params.currentMessage}`;
+        // Build context block + actual message in one chat.send, or write the
+        // full context to a local transcript file when it is too large.
+        const contextLines = this.formatContextLines(params.unsyncedMessages);
+        const inlineContext = contextLines.join("\n");
+        const inlineBytes = Buffer.byteLength(inlineContext, "utf8");
+        const useFileContext = params.unsyncedMessages.length > MAX_INLINE_CONTEXT_MESSAGES || inlineBytes > MAX_INLINE_CONTEXT_BYTES;
+        let combined;
+        if (useFileContext) {
+            const filePath = this.writeContextSyncFile(params.sessionKey, params.unsyncedMessages, contextLines);
+            combined =
+                `[以下是你不在线期间群里的长历史上下文，因消息数或大小超过直接内联阈值，已写入本地文件]\n` +
+                    `文件路径：${filePath}\n\n` +
+                    `你必须先使用 read 工具读取这个文件，理解其中的完整群聊历史，再回答当前消息。\n` +
+                    `如果无法读取文件，请明确说明，不能直接忽略历史上下文作答。\n` +
+                    `\n---\n` +
+                    `[${params.currentSenderName}]: ${params.currentMessage}`;
+        }
+        else {
+            combined =
+                `[以下是你不在线期间群里的对话，请了解上下文]\n` +
+                    inlineContext +
+                    `\n---\n` +
+                    `[${params.currentSenderName}]: ${params.currentMessage}`;
+        }
         return this.chatSend({
             sessionKey: params.sessionKey,
             message: combined + mediaInstruction + bridgeAttachmentHint,
@@ -756,6 +935,42 @@ export class OpenClawClient {
             emptyFinalAsNoReply: params.emptyFinalAsNoReply,
         });
     }
+    formatContextLines(messages) {
+        return messages.map((m) => {
+            const time = new Date(m.timestamp).toLocaleString("zh-CN", {
+                month: "2-digit",
+                day: "2-digit",
+                hour: "2-digit",
+                minute: "2-digit",
+                hour12: false,
+            });
+            const tag = m.senderType === "bot" ? `${m.senderName} (AI)` : m.senderName;
+            return `[${tag} ${time}]: ${m.content}`;
+        });
+    }
+    writeContextSyncFile(sessionKey, messages, contextLines) {
+        const safeSessionKey = sessionKey.replace(/[^a-zA-Z0-9_.-]+/g, "_");
+        const dir = join(CONTEXT_SYNC_DIR, safeSessionKey);
+        mkdirSync(dir, { recursive: true });
+        const filePath = join(dir, `${new Date().toISOString().replace(/[:.]/g, "-")}-${randomUUID()}.md`);
+        const first = messages[0];
+        const last = messages[messages.length - 1];
+        const markdown = [
+            `# LMA 群聊历史上下文同步`,
+            ``,
+            `- Session: ${sessionKey}`,
+            `- Messages: ${messages.length}`,
+            `- Range: ${first?.id ?? "?"} → ${last?.id ?? "?"}`,
+            `- Generated: ${new Date().toISOString()}`,
+            ``,
+            `## Messages`,
+            ``,
+            contextLines.join("\n\n"),
+            ``,
+        ].join("\n");
+        writeFileSync(filePath, markdown, "utf8");
+        return filePath;
+    }
     extractImageAttachments(contents) {
         const attachments = [];
         const seen = new Set();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-lark-multi-agent",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {