openclaw-lark-multi-agent 1.0.6 → 1.0.8

package/dist/feishu-bot.d.ts

@@ -98,6 +98,7 @@ export declare class FeishuBot {
     private runDiscussionTurn;
     private replyMessage;
     private extractBridgeAttachments;
+    private pushBridgeAttachment;
     private validateBridgeAttachmentPath;
     private inferFeishuFileType;
     private isImagePath;

package/dist/feishu-bot.js

@@ -2,14 +2,13 @@ import * as lark from "@larksuiteoapi/node-sdk";
 import { createRequire } from "module";
 import { existsSync, readFileSync, statSync } from "fs";
 import { basename, extname, resolve } from "path";
-import { getBridgeAttachmentAllowedRoots, getBridgeAttachmentsDir } from "./paths.js";
+import { getBridgeAttachmentsDir } from "./paths.js";
 import { buildFeishuCardElements } from "./markdown.js";
 import { discussionManager } from "./discussion-manager.js";
 const require = createRequire(import.meta.url);
 const LMA_VERSION = require("../package.json").version;
 const MAX_BOT_STREAK = 10;
 const BRIDGE_ATTACHMENTS_DIR = getBridgeAttachmentsDir();
-const BRIDGE_ATTACHMENT_ALLOWED_ROOTS = getBridgeAttachmentAllowedRoots();
 /**
  * Manages a single Feishu bot instance.
  *
@@ -637,25 +636,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 +717,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 +742,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
@@ -756,9 +761,17 @@ export class FeishuBot {
                         console.warn(`[${this.config.name}] Reply already delivered, skip duplicate for ${chatId.slice(-8)} msgId=${triggerId}`);
                     }
                     else {
-                        await this.enqueueAndDispatchDelivery(chatId, "assistant_visible", this.deliverySourceId("visible", `${(shouldReply ? visibleReply : "").trim()}|${JSON.stringify(parsedReply.attachments)}`), shouldReply ? visibleReply : "", parsedReply.attachments, lastHuman.messageId, `trigger:${triggerId}`);
-                        if (triggerId)
-                            this.store.markDeliveredReply(this.config.name, chatId, triggerId, lastHuman.messageId);
+                        try {
+                            await this.enqueueAndDispatchDelivery(chatId, "assistant_visible", this.deliverySourceId("visible", `${(shouldReply ? visibleReply : "").trim()}|${JSON.stringify(parsedReply.attachments)}`), shouldReply ? visibleReply : "", parsedReply.attachments, lastHuman.messageId, `trigger:${triggerId}`);
+                            if (triggerId)
+                                this.store.markDeliveredReply(this.config.name, chatId, triggerId, lastHuman.messageId);
+                        }
+                        catch (err) {
+                            // enqueueAndDispatchDelivery already sent a user-visible delivery
+                            // failure. Do not fall through to the generic provider-error path;
+                            // that creates a second misleading "bot did not complete" message.
+                            console.warn(`[${this.config.name}] assistant delivery failed after notification:`, this.errorSummary(err));
+                        }
                     }
                 }
                 if (isRuntimeFailure && lastHuman.messageId) {
@@ -1172,29 +1185,39 @@ export class FeishuBot {
             try {
                 const parsed = JSON.parse(String(jsonText).trim());
                 const rawAttachments = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.attachments) ? parsed.attachments : [parsed];
-                for (const item of rawAttachments) {
-                    if (!item || typeof item.path !== "string")
-                        continue;
-                    attachments.push({
-                        type: item.type === "image" || item.type === "document" || item.type === "file" ? item.type : undefined,
-                        path: item.path,
-                        caption: typeof item.caption === "string" ? item.caption : undefined,
-                    });
-                }
+                for (const item of rawAttachments)
+                    this.pushBridgeAttachment(attachments, item);
             }
             catch (err) {
                 console.warn(`[${this.config.name}] Failed to parse bridge attachment marker:`, err.message);
             }
             return "";
+        });
+        // Compatibility fallback for agents that use OpenClaw's channel directive
+        // syntax instead of the LMA marker. In Feishu/LMA, leaving MEDIA:<path> in
+        // plain text only shows the path, so parse it into bridge attachments.
+        const mediaDirectivePattern = /^\s*MEDIA:(.+)$/gm;
+        text = text.replace(mediaDirectivePattern, (_match, rawPath) => {
+            const mediaPath = String(rawPath).trim();
+            if (!mediaPath)
+                return "";
+            const cleanPath = mediaPath.replace(/^['\"]|['\"]$/g, "");
+            attachments.push({ type: this.isImagePath(cleanPath) ? "image" : "file", path: cleanPath });
+            return "";
         }).trim();
         return { text, attachments };
     }
+    pushBridgeAttachment(attachments, item) {
+        if (!item || typeof item.path !== "string")
+            return;
+        attachments.push({
+            type: item.type === "image" || item.type === "document" || item.type === "file" ? item.type : undefined,
+            path: item.path,
+            caption: typeof item.caption === "string" ? item.caption : undefined,
+        });
+    }
     validateBridgeAttachmentPath(filePath) {
         const resolvedPath = resolve(filePath);
-        const isAllowed = BRIDGE_ATTACHMENT_ALLOWED_ROOTS.some((root) => resolvedPath === root || resolvedPath.startsWith(root + "/"));
-        if (!isAllowed) {
-            throw new Error(`Attachment path outside allowed directories (${BRIDGE_ATTACHMENT_ALLOWED_ROOTS.join(", ")}): ${resolvedPath}`);
-        }
         if (!existsSync(resolvedPath))
             throw new Error(`Attachment file not found: ${resolvedPath}`);
         const stats = statSync(resolvedPath);
@@ -1628,7 +1651,8 @@ export class FeishuBot {
     async downloadResource(messageId, fileKey, type) {
         const { mkdirSync, writeFileSync } = await import("fs");
         const { resolve } = await import("path");
-        const dir = resolve(process.cwd(), "data", "media");
+        const { getStateDir } = await import("./paths.js");
+        const dir = resolve(getStateDir(), "data", "media");
         mkdirSync(dir, { recursive: true });
         const resp = await this.client.im.messageResource.get({
             path: { message_id: messageId, file_key: fileKey },

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
@@ -698,7 +867,7 @@ export class OpenClawClient {
             return "";
         return `
 
-[Bridge attachment capability hint: This is an OpenClaw Lark Multi-Agent bridge session. You cannot send Feishu files/images directly from inside OpenClaw. Do NOT call message, sessions_send, Feishu tools, or proactive send tools for this request. If the user asks you to send an image/file/document to Feishu, prefer creating new files under ${BRIDGE_ATTACHMENTS_DIR}/; existing files under the OpenClaw workspace are also allowed. Include this exact marker at the very end of your final reply (do not explain or expose the marker as normal text): <LMA_BRIDGE_ATTACHMENTS>{"attachments":[{"type":"image|file|document","path":"/absolute/path","caption":"optional"}]}</LMA_BRIDGE_ATTACHMENTS>. The bridge layer will parse this marker and send the attachment. Use type=image for images; use type=document for Markdown documents (.md) so the bridge creates a Feishu cloud document and sends its link; use type=file for other ordinary files.]`;
+[Bridge attachment capability hint: This is an OpenClaw Lark Multi-Agent bridge session. You cannot send Feishu files/images directly from inside OpenClaw. Do NOT call message, sessions_send, Feishu tools, or proactive send tools for this request. If the user asks you to send an image/file/document to Feishu, save or copy the real file under ${BRIDGE_ATTACHMENTS_DIR}/, or use an existing real file under the OpenClaw workspace. NEVER use placeholder paths such as /absolute/path, /real/path, /path/to/file, or example paths; the path must be the actual file you created and it must exist. Include this exact marker at the very end of your final reply (do not explain or expose the marker as normal text): <LMA_BRIDGE_ATTACHMENTS>{"attachments":[{"type":"image","path":"${BRIDGE_ATTACHMENTS_DIR}/replace-with-actual-created-file.png","caption":"optional"}]}</LMA_BRIDGE_ATTACHMENTS>. Replace the example path with the actual existing file path before replying. The bridge layer will parse this marker and send the attachment. Use type=image for images; use type=document for Markdown documents (.md) so the bridge creates a Feishu cloud document and sends its link; use type=file for other ordinary files.]`;
     }
     /**
      * Build and send a context catch-up message followed by the actual message.
@@ -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/dist/paths.js

@@ -14,7 +14,7 @@ export function getOpenClawWorkspaceDir() {
     return resolve(process.env.OPENCLAW_WORKSPACE_DIR || resolve(homedir(), ".openclaw/workspace"));
 }
 export function getBridgeAttachmentAllowedRoots() {
-    const roots = [getBridgeAttachmentsDir(), getOpenClawWorkspaceDir()];
+    const roots = [getBridgeAttachmentsDir(), getOpenClawWorkspaceDir(), resolve(getStateDir(), "data", "media")];
     const extra = process.env.OPENCLAW_LARK_MULTI_AGENT_ATTACHMENT_ALLOW_ROOTS || "";
     for (const part of extra.split(",")) {
         const trimmed = part.trim();

package/package.json

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