openclaw-lark-multi-agent 1.0.16 → 1.0.17

package/dist/feishu-bot.js

@@ -396,7 +396,8 @@ export class FeishuBot {
             const commandText = this.stripLeadingCommandMentions(trimmedCleanText);
             // Escape hatch: //command means send /command through to OpenClaw,
             // while /command remains a bridge-level openclaw-lark-multi-agent command.
-            if (commandText.startsWith("//")) {
+            const isNativeOpenClawCommand = commandText.startsWith("//");
+            if (isNativeOpenClawCommand) {
                 cleanText = "/" + commandText.slice(2).trimStart();
             }
             else if (commandText.startsWith("/")) {
@@ -413,6 +414,7 @@ export class FeishuBot {
                 senderName,
                 content: cleanText,
                 timestamp: Date.now(),
+                triggerKind: isNativeOpenClawCommand ? "native_command" : "normal",
             });
             if (insertedId < 0)
                 insertedId = this.store.getMessageId(messageId) || -1;
@@ -727,26 +729,64 @@ export class FeishuBot {
                 break;
             }
             this.busyChats.set(chatId, Date.now());
-            // 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);
+            // Pick the batch to process this loop. Consecutive plain human messages are
+            // merged into a single run; native escaped commands (//x) are processed on
+            // their own and never merged with ordinary messages, because they are exact
+            // pass-through requests that must not receive catch-up context.
+            const firstPending = pendingHumanTriggers[0];
+            const firstIsNative = firstPending.triggerKind === "native_command";
+            let mergedTriggers;
+            if (firstIsNative) {
+                // One native command at a time.
+                mergedTriggers = [firstPending];
+            }
+            else {
+                // Take the leading run of consecutive non-native messages.
+                mergedTriggers = [];
+                for (const m of pendingHumanTriggers) {
+                    if (m.triggerKind === "native_command")
+                        break;
+                    mergedTriggers.push(m);
+                }
             }
-            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));
+            const isNativeCommandTrigger = firstIsNative;
+            const lastHuman = mergedTriggers[mergedTriggers.length - 1];
+            const triggerId = lastHuman.id || 0;
+            const mergedContent = mergedTriggers.map((m) => m.content).join("\n");
+            const mergedTriggerIds = mergedTriggers.map((m) => m.id || 0).filter(Boolean);
+            const mergedTriggerIdSet = new Set(mergedTriggerIds);
+            // Catch-up is only injected in group chats. p2p must never get it.
+            // Use "not p2p" rather than "=== group": chatInfo is always cached before
+            // a message reaches the queue, but if chat_type were ever missing we'd
+            // rather treat it as a group (catch-up helps in groups, harms in p2p).
+            const chatType = this.store.getChatInfo(chatId)?.chatType || "";
+            const isGroup = chatType !== "p2p";
             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);
+                for (const id of mergedTriggerIds)
+                    this.store.clearPendingTrigger(this.config.name, chatId, id);
                 continue;
             }
-            const contextMsgs = allUnsynced.filter((m) => m.id !== lastHuman.id);
+            // Catch-up context: messages this bot has not seen yet in this GROUP chat.
+            // Includes both human and other-bot messages (so mention-only replies can
+            // see the human message they refer to). Excludes:
+            //   - the merged trigger messages themselves (they are the current input)
+            //   - other pending triggers (each is current for its own run)
+            //   - this bot's own messages
+            //   - native escaped commands
+            // p2p never injects catch-up; native command runs never inject catch-up.
+            let contextMsgs = [];
+            if (isGroup && !isNativeCommandTrigger) {
+                const catchupMessages = this.store.getUnsyncedMessagesForBot(this.config.name, chatId, triggerId);
+                contextMsgs = catchupMessages.filter((m) => m.senderName !== this.config.name
+                    && !(m.id && mergedTriggerIdSet.has(m.id))
+                    && !(m.id && pendingTriggerIds.has(m.id))
+                    && m.triggerKind !== "native_command");
+            }
+            const processedMessages = [...contextMsgs, ...mergedTriggers].filter((m) => m.id);
             const queueStartedAt = Date.now();
             const sessionKey = await this.ensureSession(chatId);
-            console.log(`[${this.config.name}] Sending ${humanUnsynced.length} trigger(s) to OpenClaw for ${chatId.slice(-8)} (context=${contextMsgs.length})`);
+            console.log(`[${this.config.name}] Sending ${mergedTriggers.length} trigger(s) as 1 run to OpenClaw for ${chatId.slice(-8)} (context=${contextMsgs.length})`);
             // Update reactions: queued messages → sent (GET/了解)
             const pendingAcks = this.pendingAckMessages.get(chatId) || [];
             for (const ack of pendingAcks) {
@@ -763,12 +803,14 @@ export class FeishuBot {
                     reply = await this.openclawClient.chatSendWithContext({
                         sessionKey,
                         unsyncedMessages: contextMsgs,
-                        currentMessage: lastHuman.content,
+                        currentMessage: mergedContent,
                         currentSenderName: lastHuman.senderName,
                         deliver: false,
                         // Keep bridge UX responsive; long agent/tool loops should surface a clear failure
                         // instead of leaving reactions stuck forever.
                         timeoutMs: 1_800_000,
+                        includeContext: !isNativeCommandTrigger,
+                        includeBridgeAttachmentHint: !isNativeCommandTrigger,
                     });
                 }
                 finally {
@@ -796,12 +838,12 @@ export class FeishuBot {
                 // arrive while the agent is busy may already be in pendingAckMessages,
                 // but they are not part of allUnsynced/humanUnsynced for this run and
                 // 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 maxId = Math.max(...processedMessages.map((m) => m.id || 0));
                 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.markMessagesSynced(this.config.name, chatId, processedMessages.map((m) => m.id || 0), syncBatchId);
                 this.store.markSynced(this.config.name, chatId, maxId);
-                this.store.clearPendingTriggers(this.config.name, chatId, maxId);
+                for (const id of mergedTriggerIds)
+                    this.store.clearPendingTrigger(this.config.name, chatId, id);
                 const shouldReply = trimmedReply.length > 0 && !explicitNoReply;
                 const isRuntimeFailure = shouldReply && this.isRuntimeFailureText(trimmedReply);
                 // Record bot reply only if it is user-visible/context-worthy.
@@ -844,8 +886,10 @@ export class FeishuBot {
                     else {
                         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);
+                            // Mark every merged trigger as delivered so retries/restarts do
+                            // not re-process any of them.
+                            for (const id of mergedTriggerIds)
+                                this.store.markDeliveredReply(this.config.name, chatId, id, lastHuman.messageId);
                         }
                         catch (err) {
                             // enqueueAndDispatchDelivery already sent a user-visible delivery
@@ -865,7 +909,7 @@ export class FeishuBot {
                 const pendingAcks = this.pendingAckMessages.get(chatId) || [];
                 const remainingAcks = [];
                 for (const ack of pendingAcks) {
-                    if (processedTriggerIds.has(ack.rowId)) {
+                    if (mergedTriggerIdSet.has(ack.rowId)) {
                         await this.removeReaction(ack.messageId, ack.emoji).catch(() => { });
                         await this.addReaction(ack.messageId, "DONE").catch(() => { });
                     }

package/dist/i18n.js

@@ -13,7 +13,8 @@ const dict = {
             "[LMA bridge policy]",
             "你正在 OpenClaw Lark Multi-Agent bridge 会话中。",
             "不要调用 message、sessions_send、feishu_im_user_message 或任何主动向飞书/外部聊天发送消息的工具。",
-            "直接在当前回复中作答；LMA bridge 会负责把最终回复投递回原始飞书群。",
+            "直接在当前回复中作答；LMA bridge 会负责把最终回复投递回原始飞书会话。",
+            "如果你是某个群的 Chairman：Chairman 的主持、调停、质疑和总结职责只在 /discuss 模式中生效。非 /discuss 模式下，即使你是 Chairman，也只按普通 @all/free/定向参与者身份给出自己的观点，不要总结、主持、调停、质疑或收束其他 bot 的回复。",
         ].join("\n"),
         discussParticipantPrompt: (p) => [
             "这是一个多智能体结构化讨论。",
@@ -77,6 +78,7 @@ const dict = {
             "You are in an OpenClaw Lark Multi-Agent bridge session.",
             "Do not call message, sessions_send, feishu_im_user_message, or any proactive external-chat sending tool.",
             "Reply directly in the current assistant response; the LMA bridge will deliver the final reply back to the original Feishu chat.",
+            "If you are the Chairman of a group: your chairman duties (moderating, challenging, summarizing, or concluding other bots' replies) apply only inside /discuss mode. Outside /discuss mode, even if you are the Chairman, answer only as a normal @all/free/direct participant with your own view; do not summarize, moderate, challenge, or conclude other bots' replies.",
         ].join("\n"),
         discussParticipantPrompt: (p) => [
             "This is a structured multi-agent discussion.",

package/dist/message-store.d.ts

@@ -27,6 +27,7 @@ export interface ChatMessage {
     senderName: string;
     content: string;
     timestamp: number;
+    triggerKind?: "normal" | "native_command";
 }
 export interface DeliveryOutboxItem {
     id?: number;

package/dist/message-store.js

@@ -20,7 +20,8 @@ export class MessageStore {
         sender_type TEXT NOT NULL,
         sender_name TEXT NOT NULL,
         content TEXT NOT NULL,
-        timestamp INTEGER NOT NULL
+        timestamp INTEGER NOT NULL,
+        trigger_kind TEXT NOT NULL DEFAULT 'normal'
       );
       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);
@@ -220,6 +221,13 @@ export class MessageStore {
         catch {
             // Column already exists
         }
+        // Migration: add trigger_kind column if missing
+        try {
+            this.db.exec(`ALTER TABLE messages ADD COLUMN trigger_kind TEXT NOT NULL DEFAULT 'normal'`);
+        }
+        catch {
+            // Column already exists
+        }
         // Migration: add free_discussion column if missing
         try {
             this.db.exec(`ALTER TABLE chat_info ADD COLUMN free_discussion INTEGER NOT NULL DEFAULT 0`);
@@ -253,9 +261,9 @@ export class MessageStore {
     insert(msg) {
         try {
             const result = this.db.prepare(`
-        INSERT INTO messages (chat_id, message_id, sender_type, sender_name, content, timestamp)
-        VALUES (?, ?, ?, ?, ?, ?)
-      `).run(msg.chatId, msg.messageId, msg.senderType, msg.senderName, msg.content, msg.timestamp);
+        INSERT INTO messages (chat_id, message_id, sender_type, sender_name, content, timestamp, trigger_kind)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).run(msg.chatId, msg.messageId, msg.senderType, msg.senderName, msg.content, msg.timestamp, msg.triggerKind || "normal");
             return Number(result.lastInsertRowid);
         }
         catch (err) {
@@ -309,6 +317,7 @@ export class MessageStore {
             senderName: r.sender_name,
             content: r.content,
             timestamp: r.timestamp,
+            triggerKind: r.trigger_kind || "normal",
         }));
     }
     clearPendingTriggers(botName, chatId, upToId) {
@@ -459,6 +468,7 @@ export class MessageStore {
             senderName: r.sender_name,
             content: r.content,
             timestamp: r.timestamp,
+            triggerKind: r.trigger_kind || "normal",
         }));
     }
     /**
@@ -486,6 +496,7 @@ export class MessageStore {
             senderName: r.sender_name,
             content: r.content,
             timestamp: r.timestamp,
+            triggerKind: r.trigger_kind || "normal",
         }));
     }
     markMessagesSynced(botName, chatId, messageRowIds, syncBatchId = '') {
@@ -531,6 +542,7 @@ export class MessageStore {
             senderName: r.sender_name,
             content: r.content,
             timestamp: r.timestamp,
+            triggerKind: r.trigger_kind || "normal",
         }));
     }
     /**

package/dist/openclaw-client.d.ts

@@ -144,6 +144,10 @@ export declare class OpenClawClient {
         deliver?: boolean;
         timeoutMs?: number;
         emptyFinalAsNoReply?: boolean;
+        /** Native escaped commands (//status -> /status) should not receive catch-up context. */
+        includeContext?: boolean;
+        /** Disable bridge attachment hints for native commands and other exact pass-through messages. */
+        includeBridgeAttachmentHint?: boolean;
     }): Promise<string>;
     private formatContextLines;
     private writeContextSyncFile;

package/dist/openclaw-client.js

@@ -955,7 +955,11 @@ export class OpenClawClient {
         }
     }
     shouldInjectBridgeAttachmentHint(text) {
-        return /发送|发到|发给|传|上传|附件|文件|文档|图片|图像|照片|生成图|做张图|画张图|导出|保存|pdf|docx?|xlsx?|pptx?|markdown|\bmd\b/i.test(text);
+        // Require an action word combined with an artifact word, so ordinary talk
+        // that merely mentions "文档/图片/投递" does not trigger the long hint.
+        const action = /(发送|发到|发给|发一[张份个]|上传|生成|做一?[张份个]|画一?[张份个]|创建|导出|保存|附上|附件形式|attach|upload|export|generate|create|save)/i;
+        const artifact = /(图片|图像|照片|配图|海报|封面|文件|文档|附件|表格|pdf|docx?|xlsx?|pptx?|markdown|\bmd\b|\.png|\.jpe?g|\.gif|\.webp|image|file|document)/i;
+        return action.test(text) && artifact.test(text);
     }
     bridgeAttachmentHint(text) {
         if (!this.shouldInjectBridgeAttachmentHint(text))
@@ -978,15 +982,19 @@ export class OpenClawClient {
      * If there are no unsynced messages, just sends the actual message directly.
      */
     async chatSendWithContext(params) {
+        const includeContext = params.includeContext !== false;
+        const includeBridgeAttachmentHint = params.includeBridgeAttachmentHint !== false;
+        const contextForAttachments = includeContext ? params.unsyncedMessages : [];
         const attachments = this.extractImageAttachments([
-            ...params.unsyncedMessages.map((m) => m.content),
+            ...contextForAttachments.map((m) => m.content),
             params.currentMessage,
         ]);
         const mediaInstruction = attachments.length > 0
             ? "\n\n[Media note: Image attachments are included with this message. If your model can inspect images directly, use the attached image input. If it cannot, use the image tool on the provided media/attachment path; do not try unrelated network or model-provider workarounds.]"
             : "";
-        const bridgeAttachmentHint = this.bridgeAttachmentHint(params.currentMessage);
-        if (params.unsyncedMessages.length === 0) {
+        const bridgeAttachmentHint = includeBridgeAttachmentHint ? this.bridgeAttachmentHint(params.currentMessage) : "";
+        const unsyncedMessages = includeContext ? params.unsyncedMessages : [];
+        if (unsyncedMessages.length === 0) {
             // No context to catch up, send directly
             return this.chatSend({
                 sessionKey: params.sessionKey,
@@ -999,24 +1007,24 @@ export class OpenClawClient {
         }
         // 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 contextLines = this.formatContextLines(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;
+        const useFileContext = unsyncedMessages.length > MAX_INLINE_CONTEXT_MESSAGES || inlineBytes > MAX_INLINE_CONTEXT_BYTES;
         let combined;
         if (useFileContext) {
-            const filePath = this.writeContextSyncFile(params.sessionKey, params.unsyncedMessages, contextLines);
+            const filePath = this.writeContextSyncFile(params.sessionKey, unsyncedMessages, contextLines);
             combined =
-                `[以下是你不在线期间群里的长历史上下文，因消息数或大小超过直接内联阈值，已写入本地文件]\n` +
+                `[以下是此前未同步的长历史对话上下文，因消息数或大小超过直接内联阈值，已写入本地文件]\n` +
                     `文件路径：${filePath}\n\n` +
-                    `你必须先使用 read 工具读取这个文件，理解其中的完整群聊历史，再回答当前消息。\n` +
+                    `你必须先使用 read 工具读取这个文件，理解其中的完整历史对话，再回答当前消息。\n` +
                     `如果无法读取文件，请明确说明，不能直接忽略历史上下文作答。\n` +
                     `\n---\n` +
                     `[${params.currentSenderName}]: ${params.currentMessage}`;
         }
         else {
             combined =
-                `[以下是你不在线期间群里的对话，请了解上下文]\n` +
+                `[以下是群里其他成员刚发、你还没看到的发言，供参考]\n` +
                     inlineContext +
                     `\n---\n` +
                     `[${params.currentSenderName}]: ${params.currentMessage}`;

package/package.json

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