openclaw-lark-multi-agent 1.0.21 → 1.0.22

package/dist/feishu-bot.d.ts

@@ -73,8 +73,10 @@ export declare class FeishuBot {
     static getByName(name: string): FeishuBot | undefined;
     static findByOpenId(openId: string): FeishuBot | undefined;
     private handleMessage;
+    private shouldUseLiveStatus;
     private getUnhealthySessionStatus;
-    private recoverFromUnhealthySession;
+    private warnUnhealthySessionAndContinue;
+    private stopForUnhealthySession;
     private withSessionHealthMonitor;
     /**
      * Process queued messages for a chat: batch all unsynced messages and send to OpenClaw.
@@ -125,6 +127,9 @@ export declare class FeishuBot {
     private getChairmanParticipant;
     private asDiscussionParticipant;
     private runDiscussionTurn;
+    private replyTextMessage;
+    private editTextMessage;
+    private deleteMessageById;
     private replyMessage;
     private extractBridgeAttachments;
     private pushBridgeAttachment;

package/dist/feishu-bot.js

@@ -2,6 +2,7 @@ import * as lark from "@larksuiteoapi/node-sdk";
 import { createRequire } from "module";
 import { persistBotModel } from "./config.js";
 import { getI18n, normalizeLocale } from "./i18n.js";
+import { LiveStatusController } from "./live-status.js";
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
 import { basename, extname, join, resolve } from "path";
 import { getBridgeAttachmentsDir, getDataDir } from "./paths.js";
@@ -447,7 +448,7 @@ export class FeishuBot {
                 cleanText = commandText;
             }
             const preliminaryCommandName = cleanText.trim().split(/\s+/)[0]?.toLowerCase() || "";
-            const preliminaryBridgeCommands = new Set(["/help", "/status", "/compact", "/reset", "/stop", "/verbose", "/free", "/mute", "/mode", "/model", "/models", "/discuss", "/chairman", "/locale"]);
+            const preliminaryBridgeCommands = new Set(["/help", "/status", "/compact", "/reset", "/stop", "/verbose", "/livestatus", "/free", "/mute", "/mode", "/model", "/models", "/discuss", "/chairman", "/locale"]);
             const isPreliminaryBridgeCommand = !isNativeOpenClawCommand && preliminaryBridgeCommands.has(preliminaryCommandName);
             // --- Record to local store (ALL messages, before command/response checks) ---
             const senderName = isBot
@@ -591,12 +592,13 @@ export class FeishuBot {
                         `🔄 /reset   — 重置当前 bot 的 OpenClaw session`,
                         `⏹️ /stop    — 强制停止当前 bot 在本聊天的卡死 run，解锁队列`,
                         `🔊 /verbose — 开关当前聊天里的 Tool Call 显示`,
-                        `🔓 /free [on|off] — 开关当前 bot 的 free 模式（不 @ 也可回复）`,
+                        `📡 /livestatus [on|off] — 开关非 verbose 下的单条覆盖式运行状态消息（默认开启；/livestatus off 可关闭）`,
+                        `🔓 /free [on|off] — 开关当前 bot 的 free 模式（仅非 Discuss 模式下影响普通消息主动回复）`,
                         `🤐 /mute   — 切换当前 bot 的 mute 模式（禁言，不转发 OpenClaw）`,
                         `🎛️ /mode   — 查看当前 bot 在当前群聊的模式`,
                         `🤖 /model [id] — 查看/切换当前 bot 绑定模型（持久化）`,
-                        `💬 /discuss on|off|status|stop|rounds N — 群级多 bot 连续讨论`,
-                        `👑 /chairman @Bot|off — 设置/查看/清除本群唯一 Chairman`,
+                        `💬 /discuss on|off|status|stop|rounds N — 群级多 bot 连续讨论（所有非 mute bot + Chairman 参与，忽略 free）`,
+                        `👑 /chairman @Bot|off — 设置/清除本群唯一 Chairman（状态见 /status）`,
                         `🌐 /locale zh|en — 设置/查看当前群语言`,
                         `❓ /help    — 显示此帮助信息`,
                         ``,
@@ -679,6 +681,18 @@ export class FeishuBot {
                     markCommandSynced();
                     return;
                 }
+                if (commandName === "/livestatus") {
+                    const current = this.store.getBotLiveStatus(this.config.name, chatId);
+                    const parts = cleanText.trim().split(/\s+/);
+                    const arg = (parts[1] || "toggle").toLowerCase();
+                    const next = arg === "on" ? true : arg === "off" ? false : !current;
+                    this.store.setBotLiveStatus(this.config.name, chatId, next);
+                    await this.replyMessage(messageId, next
+                        ? `📡 ${this.config.name} Live Status 已开启\n非 verbose 模式下会用一条可覆盖消息显示运行状态，并在最终回复时覆盖成答案。`
+                        : `📡 ${this.config.name} Live Status 已关闭\n非 verbose 模式下只发送最终回复。`);
+                    markCommandSynced();
+                    return;
+                }
                 if (commandName === "/free") {
                     if (chatType === "p2p") {
                         await this.replyMessage(messageId, "❌ Free 模式只在群聊中可用");
@@ -792,16 +806,18 @@ export class FeishuBot {
                     }
                     else if (this.isDiscussionCoordinator()) {
                         await this.sendMessage(chatId, this.isEn(chatId)
-                            ? "💬 Discuss is on, but there are no free bots or Chairman available. Use /free on or /chairman @Bot first."
-                            : "💬 Discuss 已开启，但当前没有 free bot 或 Chairman 可参与。请先使用 /free on 或 /chairman @Bot。");
+                            ? "💬 Discuss is on, but there is no available participant. Unmute at least one bot or set a Chairman."
+                            : "💬 Discuss 已开启，但当前没有可参与者。请至少解除一个 bot 的禁言，或设置 Chairman。");
                     }
                     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") {
+            // --- Mute mode: do not forward ordinary muted bots to OpenClaw. Chairman
+            // intentionally outranks mute, so a muted Chairman can still answer/facilitate
+            // in Chairman paths.
+            if (chatType !== "p2p" && !isBot && this.store.getBotMode(this.config.name, chatId) === "mute" && this.store.getChairmanBot(chatId) !== this.config.name) {
                 if (routing.isCurrentBotMentioned) {
                     await this.replyMessage(messageId, `🤐 ${this.config.name} 当前处于 mute 模式，发送 /mute 可解除`);
                     if (insertedId > 0) {
@@ -821,8 +837,7 @@ export class FeishuBot {
             const pending = this.pendingAckMessages.get(chatId) || [];
             const unhealthy = await this.getUnhealthySessionStatus(chatId);
             if (unhealthy) {
-                await this.recoverFromUnhealthySession(chatId, messageId, insertedId, unhealthy);
-                return;
+                await this.warnUnhealthySessionAndContinue(chatId, messageId, unhealthy);
             }
             // Anti-loop
             const streak = this.store.getBotStreak(chatId, this.config.name);
@@ -860,6 +875,15 @@ export class FeishuBot {
             console.error(`[${this.config.name}] Error:`, err);
         }
     }
+    shouldUseLiveStatus(chatId, isNativeCommandTrigger = false) {
+        if (isNativeCommandTrigger)
+            return false;
+        if (this.store.getBotVerbose(this.config.name, chatId))
+            return false;
+        if (!this.store.getBotLiveStatus(this.config.name, chatId))
+            return false;
+        return process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS !== "0";
+    }
     async getUnhealthySessionStatus(chatId) {
         const sessionKey = this.getSessionKey(chatId);
         try {
@@ -877,24 +901,28 @@ export class FeishuBot {
         }
         return null;
     }
-    async recoverFromUnhealthySession(chatId, messageId, insertedId, status) {
+    async warnUnhealthySessionAndContinue(chatId, messageId, status) {
+        await this.replyMessage(messageId, this.isEn(chatId)
+            ? `⚠️ ${this.config.name} session is currently unhealthy (${status}). I will still try this message. If it keeps failing, send /reset and retry.`
+            : `⚠️ ${this.config.name} 的 session 当前状态异常（${status}）。我会继续尝试处理这条消息；如果连续失败，再发送 /reset 后重试。`);
+        console.warn(`[${this.config.name}] unhealthy session ${this.getSessionKey(chatId)} status=${status}; warning user but allowing retry for ${chatId.slice(-8)}`);
+    }
+    async stopForUnhealthySession(chatId, messageId, status) {
         const sessionKey = this.getSessionKey(chatId);
         await this.openclawClient.abortChat(sessionKey).catch(() => { });
         this.busyChats.set(chatId, 0);
-        const cleared = this.store.clearAllPendingTriggers(this.config.name, chatId);
-        if (insertedId > 0)
-            this.store.markMessagesSynced(this.config.name, chatId, [insertedId], `${this.config.name}:${chatId}:${insertedId}:unhealthy-session`);
         const acks = this.pendingAckMessages.get(chatId) || [];
+        const remainingAcks = [];
         for (const ack of acks) {
             await this.removeReaction(ack.messageId, ack.emoji).catch(() => { });
-            await this.addReaction(ack.messageId, "FAIL").catch(() => { });
+            await this.addReaction(ack.messageId, "DONE").catch(() => { });
         }
-        this.pendingAckMessages.set(chatId, []);
-        await this.addReaction(messageId, "FAIL").catch(() => { });
+        this.pendingAckMessages.set(chatId, remainingAcks);
+        await this.addReaction(messageId, "DONE").catch(() => { });
         await this.replyMessage(messageId, this.isEn(chatId)
-            ? `⚠️ ${this.config.name} session is unhealthy (${status}). Cleared ${cleared} pending message(s) and stopped waiting. Please send /reset and retry.`
-            : `⚠️ ${this.config.name} 的 session 状态异常（${status}）。已停止等待、清掉 ${cleared} 条待处理消息并关闭等待反应。请先发送 /reset 后重试。`);
-        console.warn(`[${this.config.name}] unhealthy session ${sessionKey} status=${status}; cleared ${cleared} pending trigger(s) for ${chatId.slice(-8)}`);
+            ? `⚠️ ${this.config.name} session became unhealthy while waiting (${status}). I stopped this attempt. You can send another message to try again; if it keeps failing, send /reset.`
+            : `⚠️ ${this.config.name} 的 session 在等待过程中变成异常状态（${status}）。我已停止这次等待。你可以直接再发一条继续尝试；如果连续失败，再发送 /reset。`);
+        console.warn(`[${this.config.name}] unhealthy session ${sessionKey} status=${status}; stopped current attempt for ${chatId.slice(-8)}`);
     }
     async withSessionHealthMonitor(chatId, messageId, insertedId, work) {
         let done = false;
@@ -906,7 +934,7 @@ export class FeishuBot {
                     break;
                 const unhealthy = await this.getUnhealthySessionStatus(chatId);
                 if (unhealthy) {
-                    await this.recoverFromUnhealthySession(chatId, messageId, insertedId, unhealthy);
+                    await this.stopForUnhealthySession(chatId, messageId, unhealthy);
                     throw new UnhealthySessionError(unhealthy);
                 }
             }
@@ -946,12 +974,11 @@ export class FeishuBot {
             if (pendingHumanTriggers.length === 0) {
                 break;
             }
-            const unhealthy = await this.getUnhealthySessionStatus(chatId);
-            if (unhealthy) {
-                const latest = pendingHumanTriggers[pendingHumanTriggers.length - 1];
-                await this.recoverFromUnhealthySession(chatId, latest.messageId, latest.id || 0, unhealthy);
-                break;
-            }
+            // Do not preflight-block a retry just because the previous session status
+            // is still marked unhealthy. handleMessage already warns the user; the
+            // current chat.send attempt should be allowed so users can choose to try
+            // again without being forced through /reset. The in-flight health monitor
+            // below still stops a run that becomes unhealthy while waiting.
             this.busyChats.set(chatId, Date.now());
             // Pick the batch to process this loop. Consecutive plain human messages are
             // merged into a single run; native escaped commands (//x) are processed on
@@ -1080,6 +1107,7 @@ export class FeishuBot {
                 }
             }
             let runAcceptedByOpenClaw = false;
+            let liveStatus;
             try {
                 const releaseActiveDeliveryTarget = lastHuman.messageId ? this.setActiveDeliveryTarget(chatId, triggerId, lastHuman.messageId) : () => { };
                 let reply;
@@ -1098,6 +1126,20 @@ export class FeishuBot {
                         currentMarkedSubmitted = true;
                     }
                 };
+                liveStatus = this.shouldUseLiveStatus(chatId, isNativeCommandTrigger)
+                    ? new LiveStatusController({
+                        create: (text) => this.sendOrdered(chatId, () => this.replyTextMessage(lastHuman.messageId || "", text)),
+                        edit: (messageId, text) => this.sendOrdered(chatId, () => this.editTextMessage(messageId, text)),
+                        warn: (message, err) => console.warn(`[${this.config.name}] ${message}:`, this.errorSummary(err)),
+                    }, {
+                        botName: this.config.name,
+                        locale: this.isEn(chatId) ? "en" : "zh",
+                        disableHint: this.isEn(chatId)
+                            ? `Tip: send /livestatus off to hide this status message`
+                            : `提示：调用 /livestatus off 关闭该状态提示`,
+                    })
+                    : undefined;
+                liveStatus?.start(this.isEn(chatId) ? "waiting for OpenClaw" : "等待 OpenClaw 回复");
                 try {
                     reply = await this.withSessionHealthMonitor(chatId, lastHuman.messageId || "", triggerId, this.openclawClient.chatSendWithContext({
                         sessionKey,
@@ -1123,6 +1165,7 @@ export class FeishuBot {
                             // INSERT OR IGNORE in message_sync.
                             markSubmittedBatch(`submitted:${runId}`);
                         },
+                        onProgress: (event) => liveStatus?.progress(event),
                     }));
                 }
                 finally {
@@ -1145,6 +1188,7 @@ export class FeishuBot {
                     // submitted far enough that auto-replaying risks duplicate delivery.
                     // The user can resend a new message if they want to retry.
                     markSubmittedBatch("empty-returned");
+                    liveStatus?.dispose();
                     console.warn(`[${this.config.name}] Empty reply for ${chatId.slice(-8)} trigger=${triggerId}; not replaying submitted message(s)`);
                     const pendingAcks = this.pendingAckMessages.get(chatId) || [];
                     const remainingAcks = [];
@@ -1218,7 +1262,12 @@ export class FeishuBot {
                     }
                     else {
                         try {
+                            // Final answer always goes through the normal interactive-card
+                            // delivery path so Markdown renders correctly. The live status is a
+                            // SEPARATE message: once the final reply is enqueued, mark the
+                            // status message done.
                             await this.enqueueAndDispatchDelivery(chatId, "assistant_visible", this.deliverySourceId("visible", `${(shouldReply ? visibleReply : "").trim()}|${JSON.stringify(parsedReply.attachments)}`), shouldReply ? visibleReply : "", parsedReply.attachments, lastHuman.messageId, `trigger:${triggerId}`);
+                            await liveStatus?.complete();
                             // Mark every merged trigger as delivered so retries/restarts do
                             // not re-process any of them.
                             for (const id of mergedTriggerIds)
@@ -1228,13 +1277,18 @@ export class FeishuBot {
                             // 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.
+                            await liveStatus?.fail().catch(() => { });
                             console.warn(`[${this.config.name}] assistant delivery failed after notification:`, this.errorSummary(err));
                         }
                     }
                 }
                 if (isRuntimeFailure && lastHuman.messageId) {
+                    liveStatus?.dispose();
                     this.scheduleDelayedFailure(chatId, lastHuman.messageId, visibleReply, triggerId);
                 }
+                else if (!shouldReply && !hasAttachments) {
+                    liveStatus?.dispose();
+                }
                 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 only for trigger messages actually
                 // processed in this run. Queued messages that arrived mid-run keep their
@@ -1254,18 +1308,28 @@ export class FeishuBot {
             }
             catch (err) {
                 if (err instanceof UnhealthySessionError) {
+                    // stopForUnhealthySession already warned the user; mark the live
+                    // status as interrupted. The user can send another message to retry
+                    // without being forced through /reset.
+                    await liveStatus?.fail().catch(() => { });
                     console.warn(`[${this.config.name}] processQueue stopped because session became unhealthy: ${err.status}`);
                     break;
                 }
                 console.error(`[${this.config.name}] processQueue error:`, err);
                 const errorText = this.formatUserVisibleError(err);
                 if (lastHuman.messageId) {
+                    // Error message goes through the normal delivery path; the live status
+                    // is a separate message that we mark interrupted afterwards.
                     await this.enqueueAndDispatchDelivery(chatId, "provider_error", `trigger:${triggerId}:provider-error`, errorText, [], lastHuman.messageId, `trigger:${triggerId}:provider-error`)
                         .then(() => {
                         if (triggerId)
                             this.store.markDeliveredReply(this.config.name, chatId, triggerId, lastHuman.messageId);
                     })
                         .catch(() => { });
+                    await liveStatus?.fail().catch(() => { });
+                }
+                else {
+                    await liveStatus?.fail().catch(() => { });
                 }
                 if (triggerId) {
                     // At-most-once: if anything after send attempt failed, this batch has
@@ -1282,7 +1346,7 @@ export class FeishuBot {
                 for (const ack of pendingAcks) {
                     if (completedTriggerIdSet.has(ack.rowId)) {
                         await this.removeReaction(ack.messageId, ack.emoji).catch(() => { });
-                        await this.addReaction(ack.messageId, "FAIL").catch(() => { });
+                        await this.addReaction(ack.messageId, "DONE").catch(() => { });
                     }
                     else {
                         remainingAcks.push(ack);
@@ -1477,7 +1541,7 @@ export class FeishuBot {
         const t = text.trim();
         if (!t)
             return false;
-        return /^\/(help|status|compact|reset|stop|verbose|free|mute|mode|model|models|discuss|chairman|locale)(\s|$)/i.test(t)
+        return /^\/(help|status|compact|reset|stop|verbose|livestatus|free|mute|mode|model|models|discuss|chairman|locale)(\s|$)/i.test(t)
             || this.isBridgeControlReply(t);
     }
     isRuntimeFailureText(text) {
@@ -1688,7 +1752,7 @@ export class FeishuBot {
     getDiscussionParticipants(chatId) {
         const chairman = this.store.getChairmanBot(chatId);
         return Array.from(FeishuBot.allBots.values())
-            .filter((bot) => bot.store === this.store && bot.config.name !== chairman && bot.store.getBotMode(bot.config.name, chatId) === "free")
+            .filter((bot) => bot.store === this.store && bot.config.name !== chairman && bot.store.getBotMode(bot.config.name, chatId) !== "mute")
             .map((bot) => this.asDiscussionParticipant(bot, chatId));
     }
     getChairmanParticipant(chatId) {
@@ -1755,27 +1819,51 @@ export class FeishuBot {
         }
         return { botName: this.config.name, text: cleanVisibleReply, visible: isVisible };
     }
+    async replyTextMessage(messageId, text) {
+        const res = await this.client.im.message.reply({
+            path: { message_id: messageId },
+            data: {
+                content: JSON.stringify({ text }),
+                msg_type: "text",
+            },
+        });
+        return res?.data?.message_id || res?.message_id;
+    }
+    async editTextMessage(messageId, text) {
+        await this.client.im.v1.message.update({
+            path: { message_id: messageId },
+            data: {
+                content: JSON.stringify({ text }),
+                msg_type: "text",
+            },
+        });
+    }
+    async deleteMessageById(messageId) {
+        await this.client.im.v1.message.delete({ path: { message_id: messageId } });
+    }
     async replyMessage(messageId, text) {
         // Use Feishu CardKit v2 markdown component for full Markdown rendering.
         const card = this.buildMarkdownCard(text);
         try {
-            await this.client.im.message.reply({
+            const res = await this.client.im.message.reply({
                 path: { message_id: messageId },
                 data: {
                     content: JSON.stringify(card),
                     msg_type: "interactive",
                 },
             });
+            return res?.data?.message_id || res?.message_id;
         }
         catch {
             // Fallback to plain text if card fails
-            await this.client.im.message.reply({
+            const res = await this.client.im.message.reply({
                 path: { message_id: messageId },
                 data: {
                     content: JSON.stringify({ text }),
                     msg_type: "text",
                 },
             });
+            return res?.data?.message_id || res?.message_id;
         }
     }
     extractBridgeAttachments(reply) {
@@ -1956,7 +2044,7 @@ export class FeishuBot {
     async sendMessage(chatId, text) {
         const card = this.buildMarkdownCard(text);
         try {
-            await this.client.im.message.create({
+            const res = await this.client.im.message.create({
                 params: { receive_id_type: "chat_id" },
                 data: {
                     receive_id: chatId,
@@ -1964,12 +2052,13 @@ export class FeishuBot {
                     msg_type: "interactive",
                 },
             });
+            return res?.data?.message_id || res?.message_id;
         }
         catch (err) {
             console.warn(`[${this.config.name}] sendMessage interactive failed:`, JSON.stringify(err?.response?.data || err?.data || { message: err.message }));
             // Fallback to plain text
             try {
-                await this.client.im.message.create({
+                const res = await this.client.im.message.create({
                     params: { receive_id_type: "chat_id" },
                     data: {
                         receive_id: chatId,
@@ -1977,6 +2066,7 @@ export class FeishuBot {
                         msg_type: "text",
                     },
                 });
+                return res?.data?.message_id || res?.message_id;
             }
             catch (fallbackErr) {
                 console.warn(`[${this.config.name}] sendMessage text failed:`, JSON.stringify(fallbackErr?.response?.data || fallbackErr?.data || { message: fallbackErr.message }));
@@ -1991,7 +2081,7 @@ export class FeishuBot {
     sendOrdered(chatId, fn) {
         const prev = this.sendQueue.get(chatId) || Promise.resolve();
         const next = prev.then(fn, fn); // run even if previous failed
-        this.sendQueue.set(chatId, next);
+        this.sendQueue.set(chatId, next.then(() => undefined, () => undefined));
         return next;
     }
     /**
@@ -2066,8 +2156,8 @@ export class FeishuBot {
             }
             this.store.setDiscussMode(chatId, true);
             await this.replyMessage(messageId, this.isEn(chatId)
-                ? `💬 Discuss enabled\nChairman: ${chairman}\nParticipants: all free-mode bots in this group + Chairman\nRounds: ${this.store.getChatInfo(chatId)?.discussMaxRounds || 10}`
-                : `💬 Discuss 已开启\nChairman：${chairman}\n参与者：当前群所有 free 模式 bot + Chairman\n轮数：${this.store.getChatInfo(chatId)?.discussMaxRounds || 10}`);
+                ? `💬 Discuss enabled\nChairman: ${chairman}\nParticipants: all non-muted bots + Chairman; free mode is ignored in Discuss\nRounds: ${this.store.getChatInfo(chatId)?.discussMaxRounds || 10}`
+                : `💬 Discuss 已开启\nChairman：${chairman}\n参与者：当前群所有非 mute bot + Chairman（Discuss 模式忽略 free 开关）\n轮数：${this.store.getChatInfo(chatId)?.discussMaxRounds || 10}`);
             return;
         }
         if (action === "off") {
@@ -2102,13 +2192,13 @@ export class FeishuBot {
             `💬 Discuss: ${info?.discuss ? "on" : "off"}`,
             `Rounds: ${info?.discussMaxRounds || 10}`,
             `Chairman: ${info?.chairmanBot || "not set"}`,
-            `Participants: ${participants.length ? participants.join(", ") : "(no free bot / chairman)"}`,
+            `Participants: ${[...participants, info?.chairmanBot].filter(Boolean).length ? [...participants, info?.chairmanBot].filter(Boolean).join(", ") : "(none available)"}`,
             active ? `Active: round ${active.currentRound}/${active.maxRounds}, topic=${active.topic.slice(0, 80)}` : "Active: none",
         ].join("\n") : [
             `💬 Discuss: ${info?.discuss ? "on" : "off"}`,
             `轮数：${info?.discussMaxRounds || 10}`,
             `Chairman：${info?.chairmanBot || "未设置"}`,
-            `参与者：${participants.length ? participants.join(", ") : "（无 free bot / chairman）"}`,
+            `参与者：${[...participants, info?.chairmanBot].filter(Boolean).length ? [...participants, info?.chairmanBot].filter(Boolean).join(", ") : "（无可参与者）"}`,
             active ? `运行中：第 ${active.currentRound}/${active.maxRounds} 轮，topic=${active.topic.slice(0, 80)}` : "运行中：无",
         ].join("\n"));
     }
@@ -2154,8 +2244,9 @@ export class FeishuBot {
         const mode = this.store.getBotMode(next, chatId);
         const lines = [previous && previous !== next ? `✅ Chairman 已从 ${previous} 切换为 ${next}` : `✅ Chairman 已设置为 ${next}`];
         lines.push("作用：");
-        lines.push("- 当没有 free bot 且普通消息无人被 @ 时，Chairman 会负责回答");
-        lines.push("- Discuss 模式下，Chairman 会参与主持、调停并做最终总结");
+        lines.push("- 非 Discuss 模式下：free bot 会主动回答普通消息；没有 free bot 时由 Chairman 兜底");
+        lines.push("- Discuss 模式下：所有非 mute bot + Chairman 参与讨论，free 开关会被忽略");
+        lines.push("- Chairman 优先级高于 mute，会参与兜底回答、主持、调停并做最终总结");
         if (mode === "mute")
             lines.push(`⚠️ ${next} 当前是 mute，但 Chairman 场景下仍会发言`);
         await this.replyMessage(messageId, lines.join("\n"));
@@ -2221,6 +2312,7 @@ export class FeishuBot {
         const sessionExists = session ? "✅ 活跃" : "⏳ 未初始化";
         const status = session?.status || "unknown";
         const verboseStatus = this.store.getBotVerbose(this.config.name, chatId) ? "🔊 开启" : "🔇 关闭";
+        const liveStatus = this.store.getBotLiveStatus(this.config.name, chatId) ? "📡 开启" : "📴 关闭";
         const mode = chatType === "p2p" ? "normal" : this.store.getBotMode(this.config.name, chatId);
         const chairman = chatType === "p2p" ? "" : this.store.getChairmanBot(chatId);
         const chairmanStatus = chatType === "p2p"
@@ -2242,6 +2334,7 @@ export class FeishuBot {
             `🧮 上下文: ${fmtK(totalTokens)} / ${fmtK(contextTokens)} (${usedPct}%)${tokenNote}`,
             `📥 输入: ${fmtK(inputTokens)} | 📤 输出: ${fmtK(outputTokens)}`,
             `🔧 Verbose: ${verboseStatus}`,
+            `📡 Live Status: ${liveStatus}`,
             `🎛️ Mode: ${mode}`,
             `👑 Chairman: ${chairmanStatus}`,
             `🌐 Locale: ${localeStatus}`,

package/dist/live-status.d.ts

@@ -0,0 +1,56 @@
+import type { ProgressEvent } from "./openclaw-client";
+export type LiveStatusCallbacks = {
+    create: (text: string) => Promise<string | undefined>;
+    edit: (messageId: string, text: string) => Promise<void>;
+    warn?: (message: string, err?: unknown) => void;
+};
+export type LiveStatusOptions = {
+    botName: string;
+    locale?: "zh" | "en";
+    delayMs?: number;
+    maxChars?: number;
+    maxEdits?: number;
+    disableHint?: string;
+};
+export declare class LiveStatusController {
+    private readonly callbacks;
+    private readonly opts;
+    private messageId?;
+    private lastSentText;
+    private detail;
+    /** Number of edits already issued against the live message (excludes create). */
+    private editCount;
+    private createTimer?;
+    private createPromise?;
+    private finalized;
+    private disabled;
+    /** True after the running-state budget is spent; future progress is ignored. */
+    private runningLimitReached;
+    constructor(callbacks: LiveStatusCallbacks, opts: LiveStatusOptions);
+    get id(): string | undefined;
+    start(initialDetail?: string): void;
+    progress(event: ProgressEvent | string): Promise<void>;
+    /**
+     * Finish the live status when the real (final) reply is delivered separately.
+     * The final answer is sent by the normal interactive-card path, so the status
+     * message must NOT be overwritten with the answer (text type does not render
+     * Markdown). Feishu renders message deletion as a visible "recalled a message"
+     * tombstone, so keep the status message and mark it done instead.
+     */
+    complete(): Promise<void>;
+    /**
+     * Finish the live status when the run failed and the error is delivered by the
+     * normal path. Use a neutral/negative marker so it does not contradict the
+     * separately delivered error message.
+     */
+    fail(): Promise<void>;
+    dispose(): void;
+    private stopTimers;
+    private ensureCreatedNow;
+    private ensureCreated;
+    private editRunningStatus;
+    private safeEdit;
+    private formatToolStart;
+    private formatStatus;
+    private formatLimitNotice;
+}

package/dist/live-status.js

@@ -0,0 +1,184 @@
+const DEFAULT_DELAY_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_DELAY_MS || 800);
+const DEFAULT_MAX_CHARS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_MAX_CHARS || 120);
+// Feishu caps a single message at 20 edits (code=230072 once exhausted). Keep the
+// final edit for the completion marker; running-state updates may consume at most
+// maxEdits - 1, with the last running edit reserved for an explicit limit notice.
+const DEFAULT_MAX_EDITS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_MAX_EDITS || 20);
+export class LiveStatusController {
+    callbacks;
+    opts;
+    messageId;
+    lastSentText = "";
+    detail = "";
+    /** Number of edits already issued against the live message (excludes create). */
+    editCount = 0;
+    createTimer;
+    createPromise;
+    finalized = false;
+    disabled = false;
+    /** True after the running-state budget is spent; future progress is ignored. */
+    runningLimitReached = false;
+    constructor(callbacks, opts) {
+        this.callbacks = callbacks;
+        this.opts = opts;
+    }
+    get id() { return this.messageId; }
+    start(initialDetail) {
+        if (this.disabled || this.finalized || this.createTimer || this.messageId)
+            return;
+        this.detail = initialDetail || "";
+        this.createTimer = setTimeout(() => {
+            this.createTimer = undefined;
+            this.createPromise = this.ensureCreated();
+        }, this.opts.delayMs ?? DEFAULT_DELAY_MS);
+    }
+    async progress(event) {
+        if (this.disabled || this.finalized || this.runningLimitReached)
+            return;
+        // Only tool-call start is meaningful enough to spend one of Feishu's limited
+        // edit slots. Ignore verbose assistant notes, lifecycle ticks, tool end, and
+        // tool error; the final/error answer is delivered by the normal message path.
+        if (typeof event !== "string") {
+            if (event.kind !== "tool" || event.phase !== "start")
+                return;
+            this.detail = this.formatToolStart(event);
+        }
+        else {
+            // String progress is kept for tests/backwards compatibility, but in normal
+            // runtime OpenClaw progress is structured and only tool start passes above.
+            this.detail = event.trim();
+        }
+        if (!this.detail)
+            return;
+        await this.ensureCreatedNow();
+        await this.editRunningStatus();
+    }
+    /**
+     * Finish the live status when the real (final) reply is delivered separately.
+     * The final answer is sent by the normal interactive-card path, so the status
+     * message must NOT be overwritten with the answer (text type does not render
+     * Markdown). Feishu renders message deletion as a visible "recalled a message"
+     * tombstone, so keep the status message and mark it done instead.
+     */
+    async complete() {
+        this.finalized = true;
+        this.stopTimers();
+        if (this.createPromise)
+            await this.createPromise.catch(() => { });
+        if (!this.messageId || this.disabled)
+            return;
+        const doneText = this.opts.locale === "en"
+            ? `\u2705 ${this.opts.botName} done`
+            : `\u2705 ${this.opts.botName} \u5df2\u5b8c\u6210`;
+        await this.safeEdit(doneText, true);
+    }
+    /**
+     * Finish the live status when the run failed and the error is delivered by the
+     * normal path. Use a neutral/negative marker so it does not contradict the
+     * separately delivered error message.
+     */
+    async fail() {
+        this.finalized = true;
+        this.stopTimers();
+        if (this.createPromise)
+            await this.createPromise.catch(() => { });
+        if (!this.messageId || this.disabled)
+            return;
+        const failedText = this.opts.locale === "en"
+            ? `\u26A0\uFE0F ${this.opts.botName} stopped`
+            : `\u26A0\uFE0F ${this.opts.botName} \u6267\u884c\u4e2d\u65ad`;
+        await this.safeEdit(failedText, true);
+    }
+    dispose() {
+        this.finalized = true;
+        this.stopTimers();
+    }
+    stopTimers() {
+        if (this.createTimer) {
+            clearTimeout(this.createTimer);
+            this.createTimer = undefined;
+        }
+    }
+    async ensureCreatedNow() {
+        if (this.createTimer) {
+            clearTimeout(this.createTimer);
+            this.createTimer = undefined;
+            this.createPromise = this.ensureCreated();
+        }
+        if (this.createPromise)
+            await this.createPromise.catch(() => { });
+    }
+    async ensureCreated() {
+        if (this.disabled || this.finalized || this.messageId)
+            return;
+        const text = this.formatStatus(true);
+        try {
+            const id = await this.callbacks.create(text);
+            if (!id) {
+                this.disabled = true;
+                return;
+            }
+            this.messageId = id;
+            this.lastSentText = text;
+        }
+        catch (err) {
+            this.disabled = true;
+            this.callbacks.warn?.("live status create failed", err);
+        }
+    }
+    async editRunningStatus() {
+        if (!this.messageId || this.disabled || this.finalized || this.runningLimitReached)
+            return;
+        const maxEdits = this.opts.maxEdits ?? DEFAULT_MAX_EDITS;
+        const runningBudget = Math.max(0, maxEdits - 1); // reserve final edit for complete()
+        if (this.editCount >= runningBudget)
+            return;
+        const isLimitNotice = this.editCount === runningBudget - 1;
+        const text = isLimitNotice ? this.formatLimitNotice() : this.formatStatus();
+        const ok = await this.safeEdit(text);
+        if (ok && isLimitNotice)
+            this.runningLimitReached = true;
+    }
+    async safeEdit(text, force = false) {
+        if (!this.messageId || this.disabled)
+            return false;
+        if (!force && this.finalized)
+            return false;
+        if (!force && text === this.lastSentText)
+            return true;
+        try {
+            await this.callbacks.edit(this.messageId, text);
+            this.lastSentText = text;
+            this.editCount++;
+            return true;
+        }
+        catch (err) {
+            this.disabled = true;
+            this.stopTimers();
+            this.callbacks.warn?.("live status edit failed", err);
+            return false;
+        }
+    }
+    formatToolStart(event) {
+        const raw = event.text || event.name || "";
+        const prefix = `${event.name} start`;
+        let detail = raw.startsWith(prefix) ? raw.slice(prefix.length).trim() : raw.trim();
+        if (detail.startsWith(":"))
+            detail = detail.slice(1).trim();
+        return detail ? `${event.name}: ${detail}` : event.name;
+    }
+    formatStatus(includeDisableHint = false) {
+        const maxChars = this.opts.maxChars ?? DEFAULT_MAX_CHARS;
+        const clean = (this.detail || "").replace(/\s+/g, " ").trim();
+        const clipped = clean.length > maxChars ? `${clean.slice(0, Math.max(0, maxChars - 1))}\u2026` : clean;
+        const base = !clipped
+            ? (this.opts.locale === "en" ? `${this.opts.botName} is working` : `${this.opts.botName} \u6b63\u5728\u6267\u884c`)
+            : (this.opts.locale === "en" ? `${this.opts.botName} is working: ${clipped}` : `${this.opts.botName} \u6b63\u5728\u6267\u884c\uff1a${clipped}`);
+        return includeDisableHint && this.opts.disableHint ? `${base}\n${this.opts.disableHint}` : base;
+    }
+    formatLimitNotice() {
+        return this.opts.locale === "en"
+            ? `${this.opts.botName} reached the update limit and is still running`
+            : `${this.opts.botName} \u5df2\u8fbe\u66f4\u65b0\u9650\u5236\uff0c\u6b63\u5728\u6301\u7eed\u6267\u884c\u4e2d`;
+    }
+}

package/dist/message-store.d.ts

@@ -119,6 +119,8 @@ export declare class MessageStore {
     getChairmanBot(chatId: string): string;
     setBotVerbose(botName: string, chatId: string, verbose: boolean): void;
     getBotVerbose(botName: string, chatId: string): boolean;
+    setBotLiveStatus(botName: string, chatId: string, on: boolean): void;
+    getBotLiveStatus(botName: string, chatId: string): boolean;
     setBotMode(botName: string, chatId: string, mode: BotChatMode): void;
     getBotMode(botName: string, chatId: string): BotChatMode;
     setBotFreeDiscussion(botName: string, chatId: string, on: boolean): void;

package/dist/message-store.js

@@ -104,6 +104,7 @@ export class MessageStore {
         bot_name TEXT NOT NULL,
         chat_id TEXT NOT NULL,
         verbose INTEGER NOT NULL DEFAULT 0,
+        live_status INTEGER NOT NULL DEFAULT 1,
         free_discussion INTEGER NOT NULL DEFAULT 0,
         mode TEXT NOT NULL DEFAULT 'normal',
         updated_at INTEGER NOT NULL DEFAULT 0,
@@ -135,6 +136,13 @@ export class MessageStore {
       );
       CREATE INDEX IF NOT EXISTS idx_delivery_outbox_pending ON delivery_outbox(status, created_at);
     `);
+        // Migration: add per-bot live status toggle if missing
+        try {
+            this.db.exec(`ALTER TABLE bot_chat_settings ADD COLUMN live_status INTEGER NOT NULL DEFAULT 1`);
+        }
+        catch {
+            // Column already exists
+        }
         // Migration: add delivery_outbox delivery key columns if missing
         try {
             this.db.exec(`ALTER TABLE delivery_outbox ADD COLUMN delivery_key TEXT NOT NULL DEFAULT ''`);
@@ -694,6 +702,22 @@ export class MessageStore {
     `).get(botName, chatId);
         return !!row?.verbose;
     }
+    setBotLiveStatus(botName, chatId, on) {
+        this.db.prepare(`
+      INSERT INTO bot_chat_settings (bot_name, chat_id, live_status, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT (bot_name, chat_id) DO UPDATE SET
+        live_status = excluded.live_status,
+        updated_at = excluded.updated_at
+    `).run(botName, chatId, on ? 1 : 0, Date.now());
+    }
+    getBotLiveStatus(botName, chatId) {
+        const row = this.db.prepare(`
+      SELECT live_status FROM bot_chat_settings
+      WHERE bot_name = ? AND chat_id = ?
+    `).get(botName, chatId);
+        return row ? row.live_status !== 0 : true;
+    }
     setBotMode(botName, chatId, mode) {
         const freeDiscussion = mode === "free" ? 1 : 0;
         this.db.prepare(`

package/dist/openclaw-client.d.ts

@@ -1,5 +1,17 @@
 import { OpenClawConfig } from "./config.js";
 import { ChatMessage } from "./message-store.js";
+export type ProgressEvent = {
+    kind: "tool";
+    phase: "start" | "end" | "error";
+    name: string;
+    text: string;
+} | {
+    kind: "assistant_note";
+    text: string;
+} | {
+    kind: "lifecycle";
+    text: string;
+};
 export type ChatAttachment = {
     type?: string;
     mimeType?: string;
@@ -26,6 +38,7 @@ export declare class OpenClawClient {
     private toolEventCallbacks;
     private lastToolNamesByItemId;
     private sessionMessageCallbacks;
+    private progressCallbacks;
     /** Sessions where verbose mode should deliver visible transcript text even when mixed with tool blocks. */
     private verboseTranscriptSessions;
     private verboseAssistantTimers;
@@ -138,6 +151,7 @@ export declare class OpenClawClient {
         onSendAttempt?: () => void | Promise<void>;
         /** Called after chat.send RPC succeeds and OpenClaw has accepted the user message. */
         onSubmitted?: (runId: string) => void | Promise<void>;
+        onProgress?: (event: ProgressEvent) => void | Promise<void>;
     }): Promise<string>;
     private shouldInjectBridgeAttachmentHint;
     private bridgeAttachmentHint;
@@ -170,6 +184,7 @@ export declare class OpenClawClient {
         onSendAttempt?: () => void | Promise<void>;
         /** Called after chat.send RPC succeeds and OpenClaw has accepted the combined message. */
         onSubmitted?: (runId: string) => void | Promise<void>;
+        onProgress?: (event: ProgressEvent) => void | Promise<void>;
     }): Promise<string>;
     private formatContextLines;
     private writeContextSyncFile;

package/dist/openclaw-client.js

@@ -29,6 +29,7 @@ export class OpenClawClient {
     toolEventCallbacks = new Map();
     lastToolNamesByItemId = new Map();
     sessionMessageCallbacks = new Map();
+    progressCallbacks = new Map();
     /** Sessions where verbose mode should deliver visible transcript text even when mixed with tool blocks. */
     verboseTranscriptSessions = new Set();
     verboseAssistantTimers = new Map();
@@ -239,11 +240,17 @@ export class OpenClawClient {
                         this.flushVerboseAssistantState(rawKey);
                         this.clearVerboseAssistantState(rawKey);
                     }
-                    if (toolCb && data.kind === "tool" && data.name && (data.phase === "start" || data.phase === "end" || data.phase === "error")) {
+                    if (data.kind === "tool" && data.name && (data.phase === "start" || data.phase === "end" || data.phase === "error")) {
                         const phase = data.phase || "event";
                         const meta = data.meta || data.input || data.args || "";
                         const output = data.output || data.result || data.error || "";
-                        toolCb(`${data.name} ${phase}`.trim(), String(meta || ""), String(output || ""));
+                        if (toolCb)
+                            toolCb(`${data.name} ${phase}`.trim(), String(meta || ""), String(output || ""));
+                        const progressCb = this.progressCallbacks.get(rawKey) || this.progressCallbacks.get(shortKey);
+                        if (progressCb) {
+                            const detail = phase === "start" ? String(meta || "") : String(output || meta || "");
+                            void progressCb({ kind: "tool", phase, name: String(data.name), text: `${data.name} ${phase}${detail ? `: ${detail}` : ""}` });
+                        }
                     }
                 }
                 if (frame.event === "agent" && frame.payload?.stream === "command_output") {
@@ -348,11 +355,12 @@ export class OpenClawClient {
         }
     }
     flushVerboseAssistantState(rawKey) {
-        if (!this.isVerboseTranscriptEnabled(rawKey))
-            return false;
         const shortKey = rawKey.replace(/^agent:[^:]+:/, "");
         const cb = this.sessionMessageCallbacks.get(rawKey) || this.sessionMessageCallbacks.get(shortKey);
-        if (!cb)
+        const progressCb = this.progressCallbacks.get(rawKey) || this.progressCallbacks.get(shortKey);
+        if (!this.isVerboseTranscriptEnabled(rawKey) && !progressCb)
+            return false;
+        if (!cb && !progressCb)
             return false;
         const key = rawKey;
         const latest = this.verboseAssistantLatest.get(key)?.trim() || "";
@@ -368,16 +376,22 @@ export class OpenClawClient {
         if (!toSend)
             return false;
         this.verboseAssistantSent.set(key, latest);
-        cb(toSend, { sourceType: "verbose_transcript" });
+        if (this.isVerboseTranscriptEnabled(rawKey) && cb)
+            cb(toSend, { sourceType: "verbose_transcript" });
+        if (progressCb)
+            void progressCb({ kind: "assistant_note", text: toSend });
         return true;
     }
     handleVerboseAssistantStream(payload) {
         const rawKey = payload?.sessionKey || "";
-        if (!rawKey || !this.isVerboseTranscriptEnabled(rawKey))
+        if (!rawKey)
             return;
         const shortKey = rawKey.replace(/^agent:[^:]+:/, "");
         const cb = this.sessionMessageCallbacks.get(rawKey) || this.sessionMessageCallbacks.get(shortKey);
-        if (!cb)
+        const progressCb = this.progressCallbacks.get(rawKey) || this.progressCallbacks.get(shortKey);
+        if (!this.isVerboseTranscriptEnabled(rawKey) && !progressCb)
+            return;
+        if (!cb && !progressCb)
             return;
         const data = payload.data || {};
         const fullText = typeof data.text === "string" ? data.text : typeof data.deltaText === "string" && data.replace ? data.deltaText : "";
@@ -1090,6 +1104,11 @@ export class OpenClawClient {
             }
             console.log(`[OpenClaw] chat.send runId: ${result.runId} (rpc=${Date.now() - sendStartedAt}ms, attachments=${params.attachments?.length || 0})`);
             await params.onSubmitted?.(result.runId);
+            if (params.onProgress) {
+                this.progressCallbacks.set(sk, params.onProgress);
+                this.progressCallbacks.set(fullSessionKey, params.onProgress);
+                void params.onProgress({ kind: "lifecycle", text: "等待 OpenClaw 回复" });
+            }
             return await this.collectReply(result.runId, params.timeoutMs || 1800000, sk, { emptyFinalAsNoReply: params.emptyFinalAsNoReply, expectedUserText: params.message });
         }
         finally {
@@ -1097,6 +1116,8 @@ export class OpenClawClient {
             // collectReply returns. Keep a short grace window so normal chat replies
             // are not delivered twice via the proactive-message path. Cron/LMA runs
             // are unaffected because they do not go through chatSend.
+            this.progressCallbacks.delete(sk);
+            this.progressCallbacks.delete(fullSessionKey);
             this.releaseSuppressedSessionKeysAfter(suppressedKeys, 30000);
             this.releaseOwnedDeliverySessionKeysAfter(suppressedKeys, 30000);
         }
@@ -1149,6 +1170,7 @@ export class OpenClawClient {
                 emptyFinalAsNoReply: params.emptyFinalAsNoReply,
                 onSendAttempt: params.onSendAttempt,
                 onSubmitted: params.onSubmitted,
+                onProgress: params.onProgress,
             });
         }
         // Build context block + actual message in one chat.send, or write the
@@ -1184,6 +1206,7 @@ export class OpenClawClient {
             emptyFinalAsNoReply: params.emptyFinalAsNoReply,
             onSendAttempt: params.onSendAttempt,
             onSubmitted: params.onSubmitted,
+            onProgress: params.onProgress,
         });
     }
     formatContextLines(messages) {

package/package.json

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