openclaw-lark-multi-agent 0.1.10 → 0.1.12

package/README.md

@@ -25,11 +25,16 @@ All of them connect to the same OpenClaw Gateway while keeping sessions, queues,
 - Group chat routing:
   - reply when directly mentioned
   - reply to `@all` / `@_all`
-  - optional Free Discussion mode
+  - optional per-bot Free mode for plain human messages
+  - targeted mentions are exclusive, so Free-mode bots do not steal messages addressed to another person or bot
+  - mention-only messages can trigger a bot with the previous unsynced context
+- Per-bot anti-loop guard, so one bot's free-discussion budget is not consumed by other bots
 - Local SQLite message store for context, trigger tracking, and duplicate prevention
 - `pending_triggers` queue so restart recovery does not replay every context message
 - `delivered_replies` table so one trigger message gets at most one delivered reply per bot
 - Feishu image download and OpenClaw multimodal attachment forwarding
+- Bridge attachment marker protocol for generated files/images/documents
+- Feishu CardKit v2 Markdown rendering, including native table elements for pipe tables
 - Bridge-level slash commands and escaped OpenClaw slash commands
 - Linux systemd installer with separate runtime and state directories
 
@@ -220,7 +225,9 @@ Bridge-level commands use a single slash and are handled by this project:
 - `/compact` — compact the OpenClaw session
 - `/reset` — reset the OpenClaw session
 - `/verbose` — toggle tool-call messages for this bot in this chat
-- `/free` — toggle Free Discussion mode in group chats
+- `/free` — toggle this bot's Free mode in the current group chat
+- `/mute` — toggle this bot's mute mode in the current group chat
+- `/mode` — show this bot's current mode in the current chat
 
 OpenClaw-level slash commands can be sent by escaping with a double slash:
 
@@ -267,9 +274,39 @@ By default, a bot responds when:
 
 - it is directly mentioned;
 - `@all` / `@_all` appears in the message;
-- Free Discussion is enabled for that group.
+- this bot's Free mode is enabled and the message is a plain human message with no targeted mentions.
 
-Bot messages do not trigger other bots unless they mention them. A bot-streak guard prevents infinite bot-to-bot loops.
+Free mode is intentionally per-bot and conservative:
+
+- Free mode lets a bot reply to ordinary human messages without being mentioned.
+- If a human message mentions another bot, only that bot may respond. Other Free-mode bots stay silent.
+- If a human message mentions a regular person, Free-mode bots stay silent.
+- `@all` remains a broadcast trigger and may activate every eligible bot.
+
+Mention-only routing is supported. If a user first sends content and then sends only a bot mention, for example:
+
+```text
+Please analyze the contract risk.
+@Claude
+```
+
+the mention-only message is treated as a trigger and is combined with the previous unsynced context before being sent to the mentioned bot.
+
+Bot messages do not trigger other bots unless they mention them. The anti-loop guard is counted per bot per chat: other bots' replies do not consume the current bot's streak budget, and a human message resets the streak.
+
+`/free` is not a full multi-agent discussion scheduler. Notes for a future explicit `/discuss` mode live in [`docs/ideas/discussion-mode.md`](docs/ideas/discussion-mode.md).
+
+
+## Markdown, tables, and attachments
+
+Assistant replies are sent as Feishu CardKit v2 cards. Markdown is preprocessed for Feishu rendering:
+
+- headings are downgraded to Feishu-friendly heading levels;
+- fenced code blocks are preserved;
+- unsupported external Markdown image URLs are stripped unless already resolved to Feishu `img_` keys;
+- GitHub-style pipe tables are converted into native CardKit `table` elements.
+
+For generated files/images/documents, agents should use the bridge attachment marker protocol instead of calling Feishu messaging tools directly. The bridge strips the marker from the visible reply, validates the file path under the configured attachment directory, uploads/sends the attachment, and records it in local context. Markdown documents can be converted into Feishu cloud documents through this path.
 
 ## Data model
 

package/README.zh-CN.md

@@ -25,11 +25,16 @@ Lark/飞书里每个机器人都有自己的 App 身份，但 OpenClaw 通常在
 - 群聊路由：
   - 直接 @ 某个 bot 时回复
   - `@all` / `@_all` 时回复
-  - 可选 Free Discussion 模式
+  - 可选的 per-bot Free 模式，用于普通人类消息
+  - 定向 @ 具有排他性，Free 模式 bot 不会抢答发给其他人或其他 bot 的消息
+  - 纯 @ 某个 bot 的消息可以结合前文未同步上下文触发回复
+- per-bot anti-loop 防护，其他 bot 的发言不会消耗当前 bot 的发言额度
 - 本地 SQLite 消息存储，用于上下文、触发队列和重复投递防护
 - `pending_triggers` 队列，避免重启后把所有历史上下文都重新发给 OpenClaw
 - `delivered_replies` 表，保证同一个触发消息每个 bot 最多投递一次回复
 - 支持飞书图片下载，并以 OpenClaw multimodal attachment 形式转发
+- Bridge attachment marker 协议，用于发送生成的文件、图片和文档
+- Feishu CardKit v2 Markdown 渲染，并把 pipe table 转成原生 table 组件
 - 桥接层 slash command + 转义后的 OpenClaw slash command
 - Linux systemd 安装脚本，运行产物和状态目录分离
 
@@ -220,7 +225,9 @@ openclaw-lark-multi-agent install-windows-service
 - `/compact` — 压缩 OpenClaw session
 - `/reset` — 重置 OpenClaw session
 - `/verbose` — 开关当前 bot 在当前聊天里的 tool-call 展示
-- `/free` — 开关群聊 Free Discussion 模式
+- `/free` — 开关当前 bot 在当前群聊里的 Free 模式
+- `/mute` — 开关当前 bot 在当前群聊里的 mute 模式
+- `/mode` — 查看当前 bot 在当前聊天里的模式
 
 如果你想把 slash command 直接发给 OpenClaw，可以用双斜杠转义：
 
@@ -267,9 +274,39 @@ openclaw-lark-multi-agent install-windows-service
 
 - 被直接 @；
 - 消息里出现 `@all` / `@_all`；
-- 当前群开启了 Free Discussion 模式。
+- 当前 bot 开启了 Free 模式，并且这是一条没有定向 @ 的普通人类消息。
 
-bot 发出的消息默认不会触发其他 bot，除非明确 @。同时有 bot-streak 防护，避免 bot 之间无限互相回复。
+Free 模式是 per-bot 且保守的：
+
+- Free 模式允许 bot 在没有被 @ 时回复普通人类消息。
+- 如果人类消息 @ 了另一个 bot，只有被 @ 的 bot 可以回复，其他 Free 模式 bot 保持静默。
+- 如果人类消息 @ 了普通人，Free 模式 bot 保持静默。
+- `@all` 仍然是广播触发，可激活所有符合条件的 bot。
+
+支持“纯 @ 触发”。例如用户先发：
+
+```text
+帮我分析一下这个合同风险。
+@Claude
+```
+
+第二条纯 @ 消息会被当作触发器，并和前面未同步的上下文一起发给被 @ 的 bot。
+
+bot 发出的消息默认不会触发其他 bot，除非明确 @。anti-loop 防护按 bot + chat 单独计算：其他 bot 的发言不会消耗当前 bot 的额度，人类发言会重置计数。
+
+`/free` 不是完整的多 Agent 讨论调度器。未来独立 `/discuss` 模式的设计草案在 [`docs/ideas/discussion-mode.md`](docs/ideas/discussion-mode.md)。
+
+
+## Markdown、表格和附件
+
+助手回复会以 Feishu CardKit v2 卡片发送。Markdown 会先做飞书兼容预处理：
+
+- 标题会降级到飞书更稳定的标题层级；
+- fenced code block 会被保护；
+- 未解析成飞书 `img_` key 的外部 Markdown 图片会被剥离，避免卡片发送失败；
+- GitHub 风格 pipe table 会转换成 CardKit 原生 `table` 组件。
+
+如果 Agent 需要发送生成的文件、图片或文档，应使用 bridge attachment marker 协议，而不是直接调用飞书消息工具。桥接层会从可见回复中剥离 marker，校验文件路径位于配置的附件目录下，然后上传/发送附件，并写入本地上下文。Markdown 文档也可以通过这个路径转换成飞书云文档。
 
 ## 数据模型
 

package/dist/discussion-manager.d.ts

@@ -0,0 +1,45 @@
+export type ReplyResult = {
+    botName: string;
+    text: string;
+    visible: boolean;
+    error?: string;
+};
+type DiscussionSession = {
+    id: string;
+    chatId: string;
+    rootMessageId: string;
+    topic: string;
+    participants: string[];
+    currentRound: number;
+    maxRounds: number;
+    completedRounds: Array<{
+        round: number;
+        replies: Record<string, string>;
+    }>;
+    status: "running" | "stopped" | "completed";
+};
+export type DiscussionParticipant = {
+    name: string;
+    runDiscussionTurn(chatId: string, prompt: string): Promise<ReplyResult>;
+};
+export declare class DiscussionManager {
+    private sessions;
+    private seenRoots;
+    private readonly seenRootTtlMs;
+    isActive(chatId: string): boolean;
+    stop(chatId: string): boolean;
+    status(chatId: string): DiscussionSession | null;
+    startIfAbsent(params: {
+        chatId: string;
+        rootMessageId: string;
+        topic: string;
+        maxRounds: number;
+        participants: DiscussionParticipant[];
+        sendSystemMessage?: (text: string) => Promise<void>;
+    }): boolean;
+    private pruneSeenRoots;
+    private runLoop;
+    private buildPrompt;
+}
+export declare const discussionManager: DiscussionManager;
+export {};

package/dist/discussion-manager.js

@@ -0,0 +1,144 @@
+import { randomUUID } from "crypto";
+export class DiscussionManager {
+    sessions = new Map();
+    seenRoots = new Map();
+    seenRootTtlMs = 6 * 60 * 60 * 1000;
+    isActive(chatId) {
+        return this.sessions.get(chatId)?.status === "running";
+    }
+    stop(chatId) {
+        const session = this.sessions.get(chatId);
+        if (!session)
+            return false;
+        session.status = "stopped";
+        this.sessions.delete(chatId);
+        return true;
+    }
+    status(chatId) {
+        const session = this.sessions.get(chatId);
+        return session ? { ...session, completedRounds: [...session.completedRounds] } : null;
+    }
+    startIfAbsent(params) {
+        this.pruneSeenRoots();
+        const key = `${params.chatId}:${params.rootMessageId}`;
+        if (this.seenRoots.has(key))
+            return false;
+        this.seenRoots.set(key, Date.now());
+        if (this.isActive(params.chatId))
+            this.stop(params.chatId);
+        const participants = params.participants.filter((p, index, arr) => arr.findIndex((x) => x.name === p.name) === index);
+        if (participants.length === 0) {
+            this.seenRoots.delete(key);
+            return false;
+        }
+        const session = {
+            id: randomUUID(),
+            chatId: params.chatId,
+            rootMessageId: params.rootMessageId,
+            topic: params.topic,
+            participants: participants.map((p) => p.name),
+            currentRound: 1,
+            maxRounds: params.maxRounds,
+            completedRounds: [],
+            status: "running",
+        };
+        this.sessions.set(params.chatId, session);
+        void this.runLoop(session.id, participants, params.sendSystemMessage).catch((err) => {
+            console.warn(`[Discussion] loop failed for ${params.chatId}:`, err instanceof Error ? err.message : String(err));
+            const current = this.sessions.get(params.chatId);
+            if (current?.id === session.id)
+                this.sessions.delete(params.chatId);
+        });
+        return true;
+    }
+    pruneSeenRoots(now = Date.now()) {
+        for (const [key, ts] of this.seenRoots) {
+            if (now - ts > this.seenRootTtlMs)
+                this.seenRoots.delete(key);
+        }
+    }
+    async runLoop(sessionId, participants, sendSystemMessage) {
+        while (true) {
+            const session = Array.from(this.sessions.values()).find((s) => s.id === sessionId);
+            if (!session || session.status !== "running")
+                return;
+            if (session.currentRound > session.maxRounds) {
+                session.status = "completed";
+                this.sessions.delete(session.chatId);
+                return;
+            }
+            const prompt = this.buildPrompt(session);
+            const results = await Promise.allSettled(participants.map(async (participant) => {
+                try {
+                    return await participant.runDiscussionTurn(session.chatId, prompt);
+                }
+                catch (err) {
+                    return {
+                        botName: participant.name,
+                        text: "",
+                        visible: false,
+                        error: err instanceof Error ? err.message : String(err),
+                    };
+                }
+            }));
+            const current = this.sessions.get(session.chatId);
+            if (!current || current.id !== sessionId || current.status !== "running")
+                return;
+            const replies = {};
+            for (const result of results) {
+                const value = result.status === "fulfilled" ? result.value : undefined;
+                if (!value)
+                    continue;
+                replies[value.botName] = value.error ? `[ERROR] ${value.error}` : value.text.trim();
+            }
+            current.completedRounds.push({ round: current.currentRound, replies });
+            const allNoReply = participants.every((participant) => {
+                const text = (replies[participant.name] || "").trim();
+                return !text || text.toUpperCase() === "NO_REPLY" || text.startsWith("[ERROR]");
+            });
+            if (allNoReply) {
+                current.status = "completed";
+                this.sessions.delete(current.chatId);
+                if (sendSystemMessage)
+                    await sendSystemMessage(`💬 Discuss 已结束：第 ${current.currentRound} 轮没有新的有效补充。`).catch(() => { });
+                return;
+            }
+            if (current.currentRound >= current.maxRounds) {
+                current.status = "completed";
+                this.sessions.delete(current.chatId);
+                if (sendSystemMessage)
+                    await sendSystemMessage(`💬 Discuss 已完成：已达到 ${current.maxRounds} 轮。`).catch(() => { });
+                return;
+            }
+            current.currentRound += 1;
+        }
+    }
+    buildPrompt(session) {
+        const previous = session.completedRounds.length === 0
+            ? "（暂无，当前是第一轮）"
+            : session.completedRounds.map((round) => {
+                const lines = Object.entries(round.replies).map(([bot, text]) => `- ${bot}: ${text || "NO_REPLY"}`);
+                return `Round ${round.round}:\n${lines.join("\n")}`;
+            }).join("\n\n");
+        return [
+            "这是一个多智能体结构化讨论。",
+            "",
+            "话题：",
+            session.topic,
+            "",
+            `当前轮次：${session.currentRound}`,
+            "",
+            "已完成的轮次：",
+            previous,
+            "",
+            "本轮其他 bot 的回复你暂时看不到，请基于同一份上下文独立给出观点。",
+            "",
+            "要求：",
+            "1. 不要重复前几轮已经说过的观点。",
+            "2. 只补充新的、有价值的信息。",
+            "3. 如果没有新东西，回复 NO_REPLY。",
+            "4. 简洁作答。",
+        ].join("\n");
+    }
+}
+export const discussionManager = new DiscussionManager();

package/dist/feishu-bot.d.ts

@@ -21,7 +21,7 @@ export declare class FeishuBot {
     private initializedSessions;
     /** Per-chat busy lock: timestamp when became busy (0 = not busy) */
     private busyChats;
-    /** Per-chat pending reply message IDs (to ack with DONE when reply arrives) */
+    /** Per-chat pending reply message IDs (to ack with DONE when their trigger is processed) */
     private pendingAckMessages;
     /** Per-chat pending tool message sends (to await before final reply) */
     private pendingToolSends;
@@ -56,6 +56,7 @@ export declare class FeishuBot {
      */
     private drainOnStartup;
     static getAllBots(): Map<string, FeishuBot>;
+    static getByName(name: string): FeishuBot | undefined;
     static findByOpenId(openId: string): FeishuBot | undefined;
     private handleMessage;
     /**
@@ -75,6 +76,10 @@ export declare class FeishuBot {
     private cleanMentions;
     private stripLeadingCommandMentions;
     private buildMarkdownCard;
+    private formatUserVisibleError;
+    private isDiscussionCoordinator;
+    private getDiscussionParticipants;
+    private runDiscussionTurn;
     private replyMessage;
     private extractBridgeAttachments;
     private validateBridgeAttachmentPath;
@@ -100,6 +105,7 @@ export declare class FeishuBot {
      * Finds the bot's own reaction of that type and deletes it.
      */
     private removeReaction;
+    private handleDiscussCommand;
     /**
      * Handle /status command: show current session info.
      */

package/dist/feishu-bot.js

@@ -3,6 +3,7 @@ import { existsSync, readFileSync, statSync } from "fs";
 import { basename, extname, resolve } from "path";
 import { getBridgeAttachmentsDir } from "./paths.js";
 import { buildFeishuCardElements } from "./markdown.js";
+import { discussionManager } from "./discussion-manager.js";
 const MAX_BOT_STREAK = 10;
 const BRIDGE_ATTACHMENTS_DIR = getBridgeAttachmentsDir();
 /**
@@ -25,7 +26,7 @@ export class FeishuBot {
     initializedSessions = new Set();
     /** Per-chat busy lock: timestamp when became busy (0 = not busy) */
     busyChats = new Map();
-    /** Per-chat pending reply message IDs (to ack with DONE when reply arrives) */
+    /** Per-chat pending reply message IDs (to ack with DONE when their trigger is processed) */
     pendingAckMessages = new Map();
     /** Per-chat pending tool message sends (to await before final reply) */
     pendingToolSends = new Map();
@@ -211,6 +212,13 @@ export class FeishuBot {
     static getAllBots() {
         return FeishuBot.allBots;
     }
+    static getByName(name) {
+        for (const bot of FeishuBot.allBots.values()) {
+            if (bot.config.name === name)
+                return bot;
+        }
+        return undefined;
+    }
     static findByOpenId(openId) {
         for (const bot of FeishuBot.allBots.values()) {
             if (bot.botOpenId === openId)
@@ -351,17 +359,23 @@ export class FeishuBot {
             // Single slash commands are handled by the bridge. Double slash commands were
             // already unescaped above and should pass through to OpenClaw instead.
             const isBridgeCommand = !commandText.startsWith("//");
-            const isCommand = isBridgeCommand && /^\/(help|status|compact|reset|verbose|free|mute|mode)/.test(cleanText.trim());
+            const isCommand = isBridgeCommand && /^\/(help|status|compact|reset|verbose|free|mute|mode|discuss)/.test(cleanText.trim());
             if (isCommand) {
-                // In group chats, bridge commands must be explicitly routed to this bot
-                // or @all. Do not let Free Discussion make a bot execute commands meant
-                // for another bot.
-                if (chatType !== "p2p" && !this.shouldHandleBridgeCommand(chatType, message, isBot, message.content))
-                    return;
+                // In group chats, most bridge commands must be explicitly routed to this
+                // bot or @all. /discuss is a group-level command, so an unmentioned
+                // /discuss command is handled by one coordinator bot to avoid N replies.
+                const isDiscussCommand = cleanText.trim().startsWith("/discuss");
+                if (chatType !== "p2p" && !this.shouldHandleBridgeCommand(chatType, message, isBot, message.content)) {
+                    if (!(isDiscussCommand && this.isDiscussionCoordinator()))
+                        return;
+                }
                 const markCommandSynced = () => {
                     if (insertedId > 0) {
                         this.store.markSynced(this.config.name, chatId, insertedId);
-                        this.store.clearPendingTriggers(this.config.name, chatId, insertedId);
+                        // Bridge commands should only clear their own pending row. They
+                        // must not clear earlier human triggers that are waiting after a
+                        // failed/empty run; /status must be safe to use for debugging.
+                        this.store.clearPendingTrigger(this.config.name, chatId, insertedId);
                     }
                 };
                 if (cleanText.trim().startsWith("/help")) {
@@ -376,6 +390,7 @@ export class FeishuBot {
                         `🔓 /free   — 切换当前 bot 的 free 模式（不 @ 也可回复）`,
                         `🤐 /mute   — 切换当前 bot 的 mute 模式（禁言，不转发 OpenClaw）`,
                         `🎛️ /mode   — 查看当前 bot 在当前群聊的模式`,
+                        `💬 /discuss on|off|status|stop|rounds N — 群级多 bot 连续讨论`,
                         `❓ /help    — 显示此帮助信息`,
                         ``,
                         `OpenClaw 原生命令（双斜杠，会转成单斜杠发给 OpenClaw）`,
@@ -442,7 +457,7 @@ export class FeishuBot {
                     const next = current === "free" ? "normal" : "free";
                     this.store.setBotMode(this.config.name, chatId, next);
                     if (next === "free") {
-                        await this.replyMessage(messageId, `🔓 ${this.config.name} 已切换到 free 模式\n不需要 @ 也可以参与回复（连续 Bot 回复超过 ${MAX_BOT_STREAK} 轮将暂停，等待人类发言）`);
+                        await this.replyMessage(messageId, `🔓 ${this.config.name} 已切换到 free 模式\n不需要 @ 也可以回复普通人类消息；如果消息明确 @ 了其他 bot 或普通人，我不会抢答。\n如需多轮自动讨论，请使用群级命令 /discuss on。`);
                     }
                     else {
                         await this.replyMessage(messageId, `🔒 ${this.config.name} 已切换到 normal 模式\n只有明确 @ 我才会回复`);
@@ -480,6 +495,33 @@ export class FeishuBot {
                     markCommandSynced();
                     return;
                 }
+                if (cleanText.trim().startsWith("/discuss")) {
+                    await this.handleDiscussCommand(chatId, chatType, messageId, cleanText.trim());
+                    markCommandSynced();
+                    return;
+                }
+            }
+            // --- Discuss mode: group-level multi-bot round scheduler. It takes over
+            // plain human messages so normal Free mode does not duplicate Round 1.
+            if (chatType !== "p2p" && !isBot && this.store.getChatInfo(chatId)?.discuss) {
+                const mentions = message.mentions || [];
+                const hasTargetedMention = mentions.some((m) => !this.isAllMentionItem(m));
+                if (!hasTargetedMention) {
+                    const participants = this.getDiscussionParticipants(chatId);
+                    if (participants.length > 0) {
+                        discussionManager.startIfAbsent({
+                            chatId,
+                            rootMessageId: messageId,
+                            topic: cleanText,
+                            maxRounds: this.store.getChatInfo(chatId)?.discussMaxRounds || 3,
+                            participants,
+                            sendSystemMessage: async (text) => { await this.sendMessage(chatId, text); },
+                        });
+                    }
+                    if (insertedId > 0)
+                        this.store.markSynced(this.config.name, chatId, insertedId);
+                    return;
+                }
             }
             // --- Mute mode: do not forward anything to OpenClaw. Only direct mentions get a local notice. ---
             if (chatType !== "p2p" && !isBot && this.store.getBotMode(this.config.name, chatId) === "mute") {
@@ -487,7 +529,7 @@ export class FeishuBot {
                     await this.replyMessage(messageId, `🤐 ${this.config.name} 当前处于 mute 模式，发送 /mute 可解除`);
                     if (insertedId > 0) {
                         this.store.markSynced(this.config.name, chatId, insertedId);
-                        this.store.clearPendingTriggers(this.config.name, chatId, insertedId);
+                        this.store.clearPendingTrigger(this.config.name, chatId, insertedId);
                     }
                 }
                 return;
@@ -513,7 +555,7 @@ export class FeishuBot {
             if (isBusy) {
                 // Queued: show waiting reaction
                 await this.addReaction(messageId, "Typing").catch(() => { });
-                pending.push({ messageId, emoji: "Typing" });
+                pending.push({ messageId, emoji: "Typing", rowId: insertedId });
                 this.pendingAckMessages.set(chatId, pending);
                 console.log(`[${this.config.name}] Agent busy for ${chatId.slice(-8)}, queuing: "${cleanText.substring(0, 50)}..."`);
                 return; // Message is in DB, will be picked up when agent finishes
@@ -528,7 +570,7 @@ export class FeishuBot {
             // --- Not busy, send now (with any accumulated messages) ---
             // Acknowledge receipt: sent to OpenClaw (GET/了解)
             await this.addReaction(messageId, "Get").catch(() => { });
-            pending.push({ messageId, emoji: "Get" });
+            pending.push({ messageId, emoji: "Get", rowId: insertedId });
             this.pendingAckMessages.set(chatId, pending);
             await this.processQueue(chatId);
         }
@@ -593,18 +635,32 @@ export class FeishuBot {
                     deliver: false,
                     // Keep bridge UX responsive; long agent/tool loops should surface a clear failure
                     // instead of leaving reactions stuck forever.
-                    timeoutMs: 600000,
+                    timeoutMs: 1_800_000,
                 });
                 console.log(`[${this.config.name}] OpenClaw reply collected for ${chatId.slice(-8)} in ${Date.now() - queueStartedAt}ms`);
-                // Mark everything up to now as synced
-                const maxId = Math.max(...allUnsynced.map((m) => m.id || 0));
-                this.store.markSynced(this.config.name, chatId, maxId);
-                this.store.clearPendingTriggers(this.config.name, chatId, maxId);
                 const parsedReply = this.extractBridgeAttachments(reply);
                 const visibleReply = parsedReply.text;
                 const trimmedReply = visibleReply.trim();
-                const shouldReply = trimmedReply.length > 0 && trimmedReply.toUpperCase() !== "NO_REPLY";
                 const hasAttachments = parsedReply.attachments.length > 0;
+                const explicitNoReply = trimmedReply.toUpperCase() === "NO_REPLY";
+                const trulyEmptyReply = trimmedReply.length === 0 && !hasAttachments;
+                if (trulyEmptyReply) {
+                    // Empty final text is not the same as an explicit NO_REPLY. It often
+                    // means the upstream session/run was interrupted, raced, or collected
+                    // incorrectly. Do not mark sync, clear pending triggers, or mark DONE.
+                    // Leave the trigger pending for a later retry/new message.
+                    console.warn(`[${this.config.name}] Empty reply for ${chatId.slice(-8)} trigger=${triggerId}; keeping pending for retry`);
+                    break;
+                }
+                // Mark only the snapshot processed in this run as synced. Messages that
+                // 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));
+                this.store.markSynced(this.config.name, chatId, maxId);
+                this.store.clearPendingTriggers(this.config.name, chatId, maxId);
+                const shouldReply = trimmedReply.length > 0 && !explicitNoReply;
                 // Record bot reply only if it is user-visible/context-worthy.
                 if (shouldReply || hasAttachments) {
                     const storedContent = [visibleReply, ...parsedReply.attachments.map((a) => `[Attachment: ${a.type || "file"} ${a.path}]`)]
@@ -618,8 +674,15 @@ export class FeishuBot {
                         content: storedContent,
                         timestamp: Date.now(),
                     });
-                    if (replyId > 0)
-                        this.store.markSynced(this.config.name, chatId, replyId);
+                    if (replyId > 0) {
+                        const remainingPending = this.store.getPendingTriggerIds(this.config.name, chatId);
+                        const hasEarlierPending = Array.from(remainingPending).some((id) => id <= replyId);
+                        // 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)
+                            this.store.markSynced(this.config.name, chatId, replyId);
+                    }
                 }
                 // Wait for all pending tool event messages to be delivered first
                 const toolSends = this.pendingToolSends.get(chatId) || [];
@@ -656,16 +719,55 @@ export class FeishuBot {
                     }
                 }
                 console.log(`[${this.config.name}] [${new Date().toISOString()}] ${shouldReply || hasAttachments ? 'Replied' : 'Skipped (empty/NO_REPLY)'} (${reply.length} chars, attachments=${parsedReply.attachments.length})`);
-                // Replace ack reactions with DONE for all pending messages in this chat
+                // Replace ack reactions with DONE only for trigger messages actually
+                // processed in this run. Queued messages that arrived mid-run keep their
+                // Typing/Get reaction and will be acknowledged by the next loop.
                 const pendingAcks = this.pendingAckMessages.get(chatId) || [];
+                const remainingAcks = [];
                 for (const ack of pendingAcks) {
-                    await this.removeReaction(ack.messageId, ack.emoji).catch(() => { });
-                    await this.addReaction(ack.messageId, "DONE").catch(() => { });
+                    if (processedTriggerIds.has(ack.rowId)) {
+                        await this.removeReaction(ack.messageId, ack.emoji).catch(() => { });
+                        await this.addReaction(ack.messageId, "DONE").catch(() => { });
+                    }
+                    else {
+                        remainingAcks.push(ack);
+                    }
                 }
-                this.pendingAckMessages.set(chatId, []);
+                this.pendingAckMessages.set(chatId, remainingAcks);
             }
             catch (err) {
                 console.error(`[${this.config.name}] processQueue error:`, err);
+                const errorText = this.formatUserVisibleError(err);
+                if (lastHuman.messageId) {
+                    await this.sendOrdered(chatId, async () => {
+                        try {
+                            await this.replyMessage(lastHuman.messageId, errorText);
+                        }
+                        catch {
+                            await this.sendMessage(chatId, errorText);
+                        }
+                        if (triggerId)
+                            this.store.markDeliveredReply(this.config.name, chatId, triggerId, lastHuman.messageId);
+                    }).catch(() => { });
+                }
+                if (triggerId) {
+                    // The run failed after OpenClaw/provider rejected it. Notify the user
+                    // and clear only this failed trigger so later messages can continue.
+                    this.store.clearPendingTrigger(this.config.name, chatId, triggerId);
+                    this.store.markSynced(this.config.name, chatId, triggerId);
+                }
+                const pendingAcks = this.pendingAckMessages.get(chatId) || [];
+                const remainingAcks = [];
+                for (const ack of pendingAcks) {
+                    if (ack.rowId === triggerId) {
+                        await this.removeReaction(ack.messageId, ack.emoji).catch(() => { });
+                        await this.addReaction(ack.messageId, "FAIL").catch(() => { });
+                    }
+                    else {
+                        remainingAcks.push(ack);
+                    }
+                }
+                this.pendingAckMessages.set(chatId, remainingAcks);
                 break;
             }
             finally {
@@ -779,6 +881,72 @@ export class FeishuBot {
             },
         };
     }
+    formatUserVisibleError(err) {
+        const raw = err instanceof Error ? err.message : String(err);
+        let reason = raw.replace(/\s+/g, " ").trim();
+        if (/quota/i.test(reason) || /exceeded/i.test(reason)) {
+            const reset = reason.match(/reset at ([^.;]+)/i)?.[1];
+            reason = reset ? `模型/供应商额度已用尽，重置时间：${reset}` : "模型/供应商额度已用尽，请稍后重试或切换模型";
+        }
+        else if (/timeout/i.test(reason)) {
+            reason = "模型响应超时，请稍后重试";
+        }
+        else if (/schema|tool payload|rejected/i.test(reason)) {
+            reason = "模型供应商拒绝了请求格式或工具参数，需要调整模型/工具调用";
+        }
+        else if (reason.length > 220) {
+            reason = reason.slice(0, 220) + "...";
+        }
+        return `⚠️ ${this.config.name} 这次没有完成回复。\n原因：${reason}`;
+    }
+    isDiscussionCoordinator() {
+        const bots = Array.from(FeishuBot.allBots.values()).filter((bot) => bot.store === this.store);
+        if (bots.length === 0)
+            return true;
+        return bots[0] === this;
+    }
+    getDiscussionParticipants(chatId) {
+        return Array.from(FeishuBot.allBots.values())
+            .filter((bot) => bot.store === this.store && bot.store.getBotMode(bot.config.name, chatId) === "free")
+            .map((bot) => ({
+            name: bot.config.name,
+            runDiscussionTurn: async (_chatId, prompt) => bot.runDiscussionTurn(chatId, prompt),
+        }));
+    }
+    async runDiscussionTurn(chatId, prompt) {
+        const sessionKey = await this.ensureSession(chatId);
+        const reply = await this.openclawClient.chatSendWithContext({
+            sessionKey,
+            unsyncedMessages: [],
+            currentMessage: prompt,
+            currentSenderName: "Discussion Scheduler",
+            deliver: false,
+            timeoutMs: 1_800_000,
+        });
+        const parsedReply = this.extractBridgeAttachments(reply);
+        const visibleReply = parsedReply.text.trim();
+        const isVisible = visibleReply.length > 0 && visibleReply.toUpperCase() !== "NO_REPLY";
+        if (isVisible || parsedReply.attachments.length > 0) {
+            const storedContent = [visibleReply, ...parsedReply.attachments.map((a) => `[Attachment: ${a.type || "file"} ${a.path}]`)]
+                .filter(Boolean)
+                .join("\n");
+            this.store.insert({
+                chatId,
+                messageId: `self-${this.config.name}-discuss-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+                senderType: "bot",
+                senderName: this.config.name,
+                content: storedContent,
+                timestamp: Date.now(),
+            });
+            await this.sendOrdered(chatId, async () => {
+                if (isVisible)
+                    await this.sendMessage(chatId, visibleReply);
+                for (const attachment of parsedReply.attachments)
+                    await this.sendBridgeAttachment(chatId, attachment);
+            });
+        }
+        return { botName: this.config.name, text: visibleReply, visible: isVisible };
+    }
     async replyMessage(messageId, text) {
         // Use Feishu CardKit v2 markdown component for full Markdown rendering.
         const card = this.buildMarkdownCard(text);
@@ -1013,6 +1181,49 @@ ${doc.url}`);
             // ignore
         }
     }
+    async handleDiscussCommand(chatId, chatType, messageId, text) {
+        if (chatType === "p2p") {
+            await this.replyMessage(messageId, "❌ Discuss 模式只在群聊中可用");
+            return;
+        }
+        const parts = text.split(/\s+/).filter(Boolean);
+        const action = parts[1] || "status";
+        if (action === "on") {
+            this.store.setDiscussMode(chatId, true);
+            await this.replyMessage(messageId, `💬 Discuss 已开启\n参与者：当前群所有 free 模式 bot\n轮数：${this.store.getChatInfo(chatId)?.discussMaxRounds || 3}`);
+            return;
+        }
+        if (action === "off") {
+            this.store.setDiscussMode(chatId, false);
+            discussionManager.stop(chatId);
+            await this.replyMessage(messageId, "💬 Discuss 已关闭");
+            return;
+        }
+        if (action === "stop") {
+            const stopped = discussionManager.stop(chatId);
+            await this.replyMessage(messageId, stopped ? "💬 当前 discuss 已停止" : "💬 当前没有运行中的 discuss");
+            return;
+        }
+        if (action === "rounds") {
+            const n = Number.parseInt(parts[2] || "", 10);
+            if (!Number.isFinite(n)) {
+                await this.replyMessage(messageId, "❌ 用法：/discuss rounds <1-10>");
+                return;
+            }
+            this.store.setDiscussMaxRounds(chatId, n);
+            await this.replyMessage(messageId, `💬 Discuss 轮数已设置为 ${this.store.getChatInfo(chatId)?.discussMaxRounds || n}`);
+            return;
+        }
+        const info = this.store.getChatInfo(chatId);
+        const active = discussionManager.status(chatId);
+        const participants = this.getDiscussionParticipants(chatId).map((p) => p.name);
+        await this.replyMessage(messageId, [
+            `💬 Discuss: ${info?.discuss ? "on" : "off"}`,
+            `轮数：${info?.discussMaxRounds || 3}`,
+            `参与者：${participants.length ? participants.join(", ") : "（无 free bot）"}`,
+            active ? `运行中：第 ${active.currentRound}/${active.maxRounds} 轮，topic=${active.topic.slice(0, 80)}` : "运行中：无",
+        ].join("\n"));
+    }
     /**
      * Handle /status command: show current session info.
      */
@@ -1113,6 +1324,8 @@ ${doc.url}`);
                     ownerBot: this.config.name,
                     freeDiscussion: this.store.getChatInfo(chatId)?.freeDiscussion || false,
                     verbose: this.store.getChatInfo(chatId)?.verbose || false,
+                    discuss: this.store.getChatInfo(chatId)?.discuss || false,
+                    discussMaxRounds: this.store.getChatInfo(chatId)?.discussMaxRounds || 3,
                     updatedAt: Date.now(),
                 });
                 return;
@@ -1150,6 +1363,8 @@ ${doc.url}`);
                 ownerBot: "", // group chats are shared, no owner
                 freeDiscussion: this.store.getChatInfo(chatId)?.freeDiscussion || false,
                 verbose: this.store.getChatInfo(chatId)?.verbose || false,
+                discuss: this.store.getChatInfo(chatId)?.discuss || false,
+                discussMaxRounds: this.store.getChatInfo(chatId)?.discussMaxRounds || 3,
                 updatedAt: Date.now(),
             });
             console.log(`[${this.config.name}] Cached chat info: ${chatName} (${chatId.slice(-8)})`);

package/dist/message-store.d.ts

@@ -12,6 +12,8 @@ export interface ChatInfo {
     /** Legacy chat-level free discussion flag; per-bot mode is authoritative. */
     freeDiscussion: boolean;
     verbose: boolean;
+    discuss: boolean;
+    discussMaxRounds: number;
     updatedAt: number;
 }
 export interface ChatMessage {
@@ -35,6 +37,7 @@ export declare class MessageStore {
     markPendingTrigger(botName: string, chatId: string, messageRowId: number): void;
     getPendingTriggerIds(botName: string, chatId: string): Set<number>;
     clearPendingTriggers(botName: string, chatId: string, upToId: number): void;
+    clearPendingTrigger(botName: string, chatId: string, messageRowId: number): void;
     hasDeliveredReply(botName: string, chatId: string, triggerMessageRowId: number): boolean;
     markDeliveredReply(botName: string, chatId: string, triggerMessageRowId: number, replyMessageId?: string): void;
     /**
@@ -61,6 +64,8 @@ export declare class MessageStore {
     upsertChatInfo(info: ChatInfo): void;
     setFreeDiscussion(chatId: string, on: boolean): void;
     setVerbose(chatId: string, verbose: boolean): void;
+    setDiscussMode(chatId: string, on: boolean): void;
+    setDiscussMaxRounds(chatId: string, rounds: number): void;
     setBotVerbose(botName: string, chatId: string, verbose: boolean): void;
     getBotVerbose(botName: string, chatId: string): boolean;
     setBotMode(botName: string, chatId: string, mode: BotChatMode): void;

package/dist/message-store.js

@@ -31,6 +31,8 @@ export class MessageStore {
         members TEXT NOT NULL DEFAULT '',
         member_names TEXT NOT NULL DEFAULT '',
         verbose INTEGER NOT NULL DEFAULT 0,
+        discuss INTEGER NOT NULL DEFAULT 0,
+        discuss_max_rounds INTEGER NOT NULL DEFAULT 3,
         updated_at INTEGER NOT NULL DEFAULT 0
       );
 
@@ -88,6 +90,19 @@ export class MessageStore {
         catch {
             // Column already exists
         }
+        // Migration: add discuss columns if missing
+        try {
+            this.db.exec(`ALTER TABLE chat_info ADD COLUMN discuss INTEGER NOT NULL DEFAULT 0`);
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec(`ALTER TABLE chat_info ADD COLUMN discuss_max_rounds INTEGER NOT NULL DEFAULT 3`);
+        }
+        catch {
+            // Column already exists
+        }
         // Migration: add owner_bot column if missing
         try {
             this.db.exec(`ALTER TABLE chat_info ADD COLUMN owner_bot TEXT NOT NULL DEFAULT ''`);
@@ -163,6 +178,12 @@ export class MessageStore {
       WHERE bot_name = ? AND chat_id = ? AND message_row_id <= ?
     `).run(botName, chatId, upToId);
     }
+    clearPendingTrigger(botName, chatId, messageRowId) {
+        this.db.prepare(`
+      DELETE FROM pending_triggers
+      WHERE bot_name = ? AND chat_id = ? AND message_row_id = ?
+    `).run(botName, chatId, messageRowId);
+    }
     hasDeliveredReply(botName, chatId, triggerMessageRowId) {
         const row = this.db.prepare(`
       SELECT 1 FROM delivered_replies
@@ -258,8 +279,8 @@ export class MessageStore {
     // --- Chat info ---
     upsertChatInfo(info) {
         this.db.prepare(`
-      INSERT INTO chat_info (chat_id, chat_type, chat_name, members, member_names, verbose, free_discussion, owner_bot, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO chat_info (chat_id, chat_type, chat_name, members, member_names, verbose, free_discussion, owner_bot, discuss, discuss_max_rounds, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT (chat_id) DO UPDATE SET
         chat_type = excluded.chat_type,
         chat_name = excluded.chat_name,
@@ -268,8 +289,10 @@ export class MessageStore {
         verbose = excluded.verbose,
         free_discussion = excluded.free_discussion,
         owner_bot = CASE WHEN excluded.owner_bot != '' THEN excluded.owner_bot ELSE chat_info.owner_bot END,
+        discuss = CASE WHEN excluded.discuss != 0 THEN excluded.discuss ELSE chat_info.discuss END,
+        discuss_max_rounds = CASE WHEN excluded.discuss_max_rounds != 3 THEN excluded.discuss_max_rounds ELSE chat_info.discuss_max_rounds END,
         updated_at = excluded.updated_at
-    `).run(info.chatId, info.chatType, info.chatName, info.members, info.memberNames, info.verbose ? 1 : 0, info.freeDiscussion ? 1 : 0, info.ownerBot || '', info.updatedAt);
+    `).run(info.chatId, info.chatType, info.chatName, info.members, info.memberNames, info.verbose ? 1 : 0, info.freeDiscussion ? 1 : 0, info.ownerBot || '', info.discuss ? 1 : 0, info.discussMaxRounds || 3, info.updatedAt);
     }
     setFreeDiscussion(chatId, on) {
         this.db.prepare(`UPDATE chat_info SET free_discussion = ? WHERE chat_id = ?`).run(on ? 1 : 0, chatId);
@@ -279,6 +302,21 @@ export class MessageStore {
       UPDATE chat_info SET verbose = ? WHERE chat_id = ?
     `).run(verbose ? 1 : 0, chatId);
     }
+    setDiscussMode(chatId, on) {
+        this.db.prepare(`
+      INSERT INTO chat_info (chat_id, chat_type, chat_name, discuss, discuss_max_rounds, updated_at)
+      VALUES (?, 'group', '', ?, 3, ?)
+      ON CONFLICT (chat_id) DO UPDATE SET discuss = excluded.discuss, updated_at = excluded.updated_at
+    `).run(chatId, on ? 1 : 0, Date.now());
+    }
+    setDiscussMaxRounds(chatId, rounds) {
+        const normalized = Math.max(1, Math.min(10, Math.round(rounds)));
+        this.db.prepare(`
+      INSERT INTO chat_info (chat_id, chat_type, chat_name, discuss, discuss_max_rounds, updated_at)
+      VALUES (?, 'group', '', 0, ?, ?)
+      ON CONFLICT (chat_id) DO UPDATE SET discuss_max_rounds = excluded.discuss_max_rounds, updated_at = excluded.updated_at
+    `).run(chatId, normalized, Date.now());
+    }
     setBotVerbose(botName, chatId, verbose) {
         this.db.prepare(`
       INSERT INTO bot_chat_settings (bot_name, chat_id, verbose, updated_at)
@@ -334,6 +372,8 @@ export class MessageStore {
             ownerBot: row.owner_bot || '',
             freeDiscussion: !!row.free_discussion,
             verbose: !!row.verbose,
+            discuss: !!row.discuss,
+            discussMaxRounds: row.discuss_max_rounds || 3,
             updatedAt: row.updated_at,
         };
     }
@@ -348,6 +388,8 @@ export class MessageStore {
             ownerBot: r.owner_bot || '',
             freeDiscussion: !!r.free_discussion,
             verbose: !!r.verbose,
+            discuss: !!r.discuss,
+            discussMaxRounds: r.discuss_max_rounds || 3,
             updatedAt: r.updated_at,
         }));
     }

package/dist/openclaw-client.js

@@ -266,22 +266,28 @@ export class OpenClawClient {
             let replayInvalidTimer = null;
             const collectStartedAt = Date.now();
             let lifecycleStartedLogged = false;
-            const timer = setTimeout(() => {
-                clearInterval(poller);
-                if (chatFinalTimer)
-                    clearTimeout(chatFinalTimer);
-                if (lifecycleEndTimer)
-                    clearTimeout(lifecycleEndTimer);
-                if (replayInvalidTimer)
-                    clearTimeout(replayInvalidTimer);
-                console.warn(`[OpenClaw] collectReply timeout for runId=${runId} sessionKey=${sessionKey}`);
-                this.abortChat(targetSessionKey || sessionKey, runId).catch((err) => {
-                    console.warn(`[OpenClaw] abort after collectReply timeout failed:`, err.message);
-                });
-                resolve(text || chatFinalText || "(timeout: no reply received)");
-            }, timeoutMs);
+            let idleTimer;
+            const resetIdleTimer = () => {
+                if (idleTimer)
+                    clearTimeout(idleTimer);
+                idleTimer = setTimeout(() => {
+                    clearInterval(poller);
+                    if (chatFinalTimer)
+                        clearTimeout(chatFinalTimer);
+                    if (lifecycleEndTimer)
+                        clearTimeout(lifecycleEndTimer);
+                    if (replayInvalidTimer)
+                        clearTimeout(replayInvalidTimer);
+                    console.warn(`[OpenClaw] collectReply idle timeout for runId=${runId} sessionKey=${sessionKey}`);
+                    this.abortChat(targetSessionKey || sessionKey, runId).catch((err) => {
+                        console.warn(`[OpenClaw] abort after collectReply idle timeout failed:`, err.message);
+                    });
+                    resolve(text || chatFinalText || "(timeout: no reply received)");
+                }, timeoutMs);
+            };
+            resetIdleTimer();
             const finish = (finalText) => {
-                clearTimeout(timer);
+                clearTimeout(idleTimer);
                 clearInterval(poller);
                 if (chatFinalTimer)
                     clearTimeout(chatFinalTimer);
@@ -318,6 +324,10 @@ export class OpenClawClient {
                             continue;
                         }
                         bucket.splice(i, 1);
+                        // Any matching event — including toolCall/toolResult/item/lifecycle —
+                        // 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();
                         // 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) {
@@ -386,7 +396,7 @@ export class OpenClawClient {
                             return;
                         }
                         if (ev.stream === "lifecycle" && ev.data?.phase === "error") {
-                            clearTimeout(timer);
+                            clearTimeout(idleTimer);
                             clearInterval(poller);
                             if (chatFinalTimer)
                                 clearTimeout(chatFinalTimer);

package/package.json

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