openclaw-lark-multi-agent 1.0.21 → 1.0.23

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";
@@ -15,6 +16,7 @@ const MAX_MERGED_TRIGGER_BYTES = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_MA
 const BRIDGE_ATTACHMENTS_DIR = getBridgeAttachmentsDir();
 const FEISHU_DOCS_DIR = join(getDataDir(), "feishu-docs");
 const SESSION_HEALTH_POLL_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_SESSION_HEALTH_POLL_MS || 5_000);
+const SESSION_HEALTH_CONFIRM_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_SESSION_HEALTH_CONFIRM_MS || 2_000);
 class UnhealthySessionError extends Error {
     status;
     constructor(status) {
@@ -62,6 +64,8 @@ export class FeishuBot {
     locale;
     configPath;
     static allBots = new Map();
+    /** Chats where this bot app has actually received an event in this process. */
+    static seenBotChats = new Map();
     constructor(config, openclawClient, store, adminOpenId, configPath) {
         this.config = config;
         this.openclawClient = openclawClient;
@@ -191,7 +195,17 @@ export class FeishuBot {
                 if (sourceType !== "verbose_transcript" && (parsed.text.trim() || parsed.attachments.length > 0))
                     this.cancelDelayedFailure(chatId);
                 const activeTarget = this.activeDeliveryTargets.get(chatId);
-                await this.enqueueAndDispatchDelivery(chatId, sourceType, this.deliverySourceId(sourceType === "verbose_transcript" ? "verbose" : "proactive", `${Date.now()}:${Math.random()}:${parsed.text.trim()}|${JSON.stringify(parsed.attachments)}`), parsed.text.trim(), parsed.attachments, activeTarget?.messageId, undefined);
+                try {
+                    await this.enqueueAndDispatchDelivery(chatId, sourceType, this.deliverySourceId(sourceType === "verbose_transcript" ? "verbose" : "proactive", `${Date.now()}:${Math.random()}:${parsed.text.trim()}|${JSON.stringify(parsed.attachments)}`), parsed.text.trim(), parsed.attachments, activeTarget?.messageId, undefined);
+                    if (sourceType !== "verbose_transcript" && (parsed.text.trim() || parsed.attachments.length > 0)) {
+                        await activeTarget?.liveStatus?.complete().catch(() => { });
+                    }
+                }
+                catch (err) {
+                    if (sourceType !== "verbose_transcript")
+                        await activeTarget?.liveStatus?.fail().catch(() => { });
+                    throw err;
+                }
             }
             catch (err) {
                 console.error(`[${this.config.name}] Failed to deliver proactive msg:`, err.message);
@@ -329,6 +343,7 @@ export class FeishuBot {
             const message = event.message;
             const sender = event.sender;
             const chatId = message.chat_id;
+            this.markCurrentBotSeenInChat(chatId);
             const chatType = message.chat_type;
             const messageType = message.message_type;
             const messageId = message.message_id;
@@ -447,7 +462,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
@@ -485,6 +500,7 @@ export class FeishuBot {
                 const isChairmanCommand = commandName === "/chairman";
                 const isLocaleCommand = commandName === "/locale";
                 const isModelCommand = commandName === "/model";
+                const isHelpCommand = commandName === "/help";
                 const rejectModelAll = chatType !== "p2p" && isModelCommand && routing.isAllMention;
                 if (chatType !== "p2p") {
                     const groupBotCount = Array.from(FeishuBot.allBots.values()).filter((bot) => bot.store === this.store).length;
@@ -556,6 +572,13 @@ export class FeishuBot {
                         if (!this.isDiscussionCoordinator())
                             return;
                     }
+                    else if (isHelpCommand && !routing.hasTargetedMention) {
+                        // Bare or @all /help in a multi-bot group should never be silent or
+                        // spammy. Let the coordinator answer once instead of requiring users
+                        // to know they must @ a bot before they can discover the command list.
+                        if (!this.isDiscussionCoordinator())
+                            return;
+                    }
                     else if (isDiscussCommand && !routing.hasTargetedMention) {
                         // Untargeted or @all /discuss is group-level; one coordinator handles it.
                         if (!this.isDiscussionCoordinator())
@@ -591,12 +614,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 +703,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 模式只在群聊中可用");
@@ -773,35 +809,37 @@ export class FeishuBot {
                             maxRounds: this.store.getChatInfo(chatId)?.discussMaxRounds || 10,
                             participants,
                             chairman,
-                            sendSystemMessage: async (text) => { await this.sendMessage(chatId, text); },
+                            sendSystemMessage: async (text) => { await this.sendSystemDelivery(chatId, text); },
                             locale: discussionLocale,
                             onComplete: async (event) => {
                                 if (event.reason === "chairman_final") {
                                     this.store.setDiscussMode(event.chatId, false);
-                                    await this.sendMessage(event.chatId, this.isEn(event.chatId)
+                                    await this.sendSystemDelivery(event.chatId, this.isEn(event.chatId)
                                         ? `💬 Discuss ended: Chairman ${event.chairmanName || ""} completed the final summary. Discuss mode has been turned off automatically.`
                                         : `💬 Discuss 已结束：Chairman ${event.chairmanName || ""} 已完成总结，已自动关闭 Discuss 模式。`);
                                 }
                             },
                         });
                         if (started && preempted) {
-                            await this.sendMessage(chatId, this.isEn(chatId)
+                            await this.sendSystemDelivery(chatId, this.isEn(chatId)
                                 ? `💬 New topic received; stopped the previous Discuss session and started a new one. Previous topic: ${preempted.topic.slice(0, 80)}`
                                 : `💬 收到新话题，已停止上一轮 Discuss 并开启新讨论。上一话题：${preempted.topic.slice(0, 80)}`);
                         }
                     }
                     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。");
+                        await this.sendSystemDelivery(chatId, this.isEn(chatId)
+                            ? "💬 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 +859,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 +897,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 {
@@ -867,9 +913,8 @@ export class FeishuBot {
             const status = String(resp?.session?.status || "").toLowerCase();
             if (!status)
                 return null;
-            if (["killed", "kill", "dead", "crashed", "crash", "failed", "failure", "error", "errored", "invalid"].some((bad) => status.includes(bad))) {
+            if (this.isSessionDeadStatus(status))
                 return status;
-            }
         }
         catch {
             // Absence/transient describe failures should not block a new run; chat.send
@@ -877,24 +922,48 @@ export class FeishuBot {
         }
         return null;
     }
-    async recoverFromUnhealthySession(chatId, messageId, insertedId, status) {
+    /**
+     * Distinguish SESSION death from RUN failure. `sessions.describe` reports the
+     * status of the most recent run, not whether the session is usable. A run can
+     * end as `aborted`/`error`/`failed`/`timeout` (e.g. an LLM idle timeout) while
+     * the session itself stays perfectly usable for the next message — confirmed in
+     * the wild: LMA reported "killed" but `/status` immediately showed running.
+     *
+     * Only treat the session as dead for statuses that mean the session itself is
+     * gone and a new run cannot start without /reset. Use word-boundary matching so
+     * a run-level "error" substring never trips this. Run-level failures are NOT
+     * surfaced here: the work promise will either return the (possibly empty) reply
+     * or throw, and that is handled by the normal delivery/error path.
+     */
+    isSessionDeadStatus(status) {
+        const s = status.toLowerCase();
+        // Session-level death tokens only. Notably excludes aborted/error/errored/
+        // failed/failure/timeout, which are run-level outcomes on a live session.
+        const deadTokens = ["killed", "dead", "crashed", "destroyed", "terminated", "gone"];
+        return deadTokens.some((tok) => new RegExp(`(^|[^a-z])${tok}([^a-z]|$)`).test(s));
+    }
+    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,8 +975,18 @@ export class FeishuBot {
                     break;
                 const unhealthy = await this.getUnhealthySessionStatus(chatId);
                 if (unhealthy) {
-                    await this.recoverFromUnhealthySession(chatId, messageId, insertedId, unhealthy);
-                    throw new UnhealthySessionError(unhealthy);
+                    // Session status can briefly report killed/aborted while the final
+                    // response is still racing back to the bridge. Confirm once before
+                    // surfacing a user-visible failure, otherwise users can see both a
+                    // successful reply and a misleading "session became unhealthy" notice.
+                    await new Promise((resolve) => setTimeout(resolve, SESSION_HEALTH_CONFIRM_MS));
+                    if (done)
+                        break;
+                    const confirmedUnhealthy = await this.getUnhealthySessionStatus(chatId);
+                    if (confirmedUnhealthy) {
+                        await this.stopForUnhealthySession(chatId, messageId, confirmedUnhealthy);
+                        throw new UnhealthySessionError(confirmedUnhealthy);
+                    }
                 }
             }
             return undefined;
@@ -946,12 +1025,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 +1158,7 @@ export class FeishuBot {
                 }
             }
             let runAcceptedByOpenClaw = false;
+            let liveStatus;
             try {
                 const releaseActiveDeliveryTarget = lastHuman.messageId ? this.setActiveDeliveryTarget(chatId, triggerId, lastHuman.messageId) : () => { };
                 let reply;
@@ -1098,6 +1177,23 @@ 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 回复");
+                const activeTargetForStatus = this.activeDeliveryTargets.get(chatId);
+                if (activeTargetForStatus?.triggerId === triggerId && liveStatus)
+                    activeTargetForStatus.liveStatus = liveStatus;
                 try {
                     reply = await this.withSessionHealthMonitor(chatId, lastHuman.messageId || "", triggerId, this.openclawClient.chatSendWithContext({
                         sessionKey,
@@ -1123,6 +1219,7 @@ export class FeishuBot {
                             // INSERT OR IGNORE in message_sync.
                             markSubmittedBatch(`submitted:${runId}`);
                         },
+                        onProgress: (event) => liveStatus?.progress(event),
                     }));
                 }
                 finally {
@@ -1145,6 +1242,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 = [];
@@ -1215,10 +1313,16 @@ export class FeishuBot {
                 if ((shouldReply || hasAttachments) && lastHuman.messageId && !isRuntimeFailure) {
                     if (triggerId && this.store.hasDeliveredReply(this.config.name, chatId, triggerId)) {
                         console.warn(`[${this.config.name}] Reply already delivered, skip duplicate for ${chatId.slice(-8)} msgId=${triggerId}`);
+                        await liveStatus?.complete().catch(() => { });
                     }
                     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 +1332,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) {
+                    await liveStatus?.fail().catch(() => { });
                     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 +1363,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 +1401,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 +1596,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) {
@@ -1540,6 +1659,10 @@ export class FeishuBot {
     deliverySourceId(kind, text) {
         return `${kind}:${this.stableHash(text)}`;
     }
+    async sendSystemDelivery(chatId, text) {
+        const sourceId = `discussion-system:${Date.now()}:${Math.random().toString(36).slice(2)}`;
+        await this.enqueueAndDispatchDelivery(chatId, "discussion_system", sourceId, text);
+    }
     async enqueueAndDispatchDelivery(chatId, sourceType, sourceId, text, attachments = [], replyToMessageId, deliveryKey) {
         if (!text.trim() && attachments.length === 0)
             return;
@@ -1608,6 +1731,8 @@ export class FeishuBot {
                         this.store.markDeliveryDelivered(item.id);
                 }
                 catch (err) {
+                    if (this.isOutOfChatError(err))
+                        this.markCurrentBotUnavailable(chatId, err);
                     if (item.id)
                         this.store.markDeliveryFailed(item.id);
                     const errorText = `⚠️ 附件发送失败：${this.errorSummary(err)}`;
@@ -1685,17 +1810,42 @@ export class FeishuBot {
             return true;
         return bots[0] === this;
     }
+    static markBotSeenInChat(botName, chatId) {
+        let set = FeishuBot.seenBotChats.get(botName);
+        if (!set) {
+            set = new Set();
+            FeishuBot.seenBotChats.set(botName, set);
+        }
+        set.add(chatId);
+    }
+    markCurrentBotSeenInChat(chatId) {
+        FeishuBot.markBotSeenInChat(this.config.name, chatId);
+        this.store.markBotSeenInChat(this.config.name, chatId);
+    }
+    isBotAvailableInChat(bot, chatId) {
+        // A bot can be globally configured but not actually installed in this Feishu
+        // group. Discuss participants must be restricted to bots that either have
+        // received an event in this chat during this process, or have previously
+        // delivered a message successfully in this chat. Otherwise LMA may generate
+        // "ghost" participants and Feishu will reject delivery with 230002
+        // (Bot/User can NOT be out of the chat).
+        if (this.store.isBotUnavailableInChat(bot.config.name, chatId))
+            return false;
+        return FeishuBot.seenBotChats.get(bot.config.name)?.has(chatId)
+            || this.store.hasBotSeenInChat(bot.config.name, chatId)
+            || this.store.hasAnyDeliveredToChat(bot.config.name, chatId);
+    }
     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" && this.isBotAvailableInChat(bot, chatId))
             .map((bot) => this.asDiscussionParticipant(bot, chatId));
     }
     getChairmanParticipant(chatId) {
         const chairman = this.store.getChairmanBot(chatId);
         if (!chairman)
             return undefined;
-        const bot = Array.from(FeishuBot.allBots.values()).find((candidate) => candidate.store === this.store && candidate.config.name === chairman);
+        const bot = Array.from(FeishuBot.allBots.values()).find((candidate) => candidate.store === this.store && candidate.config.name === chairman && this.isBotAvailableInChat(candidate, chatId));
         return bot ? this.asDiscussionParticipant(bot, chatId) : undefined;
     }
     asDiscussionParticipant(bot, chatId) {
@@ -1707,6 +1857,21 @@ export class FeishuBot {
     async runDiscussionTurn(chatId, prompt, meta) {
         const sessionKey = await this.ensureSession(chatId);
         const releaseProactiveMute = this.openclawClient.muteProactiveDelivery(sessionKey);
+        const liveStatusEnabled = this.store.getBotLiveStatus(this.config.name, chatId) && !this.store.getBotVerbose(this.config.name, chatId);
+        const liveStatus = liveStatusEnabled
+            ? new LiveStatusController({
+                create: (text) => this.sendOrdered(chatId, () => this.sendTextMessage(chatId, text)),
+                edit: (messageId, text) => this.sendOrdered(chatId, () => this.editTextMessage(messageId, text)),
+                warn: (message, err) => console.warn(`[${this.config.name}] ${message}:`, err instanceof Error ? err.message : 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(meta ? `第 ${meta.round}/${meta.maxRounds} 轮讨论` : "讨论中");
         let reply;
         try {
             reply = await this.openclawClient.chatSendWithContext({
@@ -1717,8 +1882,13 @@ export class FeishuBot {
                 deliver: false,
                 timeoutMs: 1_800_000,
                 emptyFinalAsNoReply: true,
+                onProgress: (event) => { void liveStatus?.progress(event).catch((err) => console.warn(`[${this.config.name}] live status progress failed:`, err instanceof Error ? err.message : err)); },
             });
         }
+        catch (err) {
+            await liveStatus?.fail().catch(() => { });
+            throw err;
+        }
         finally {
             // OpenClaw can emit the final assistant session.message shortly after
             // chatSend/collectReply returns. Keep discussion proactive muted briefly;
@@ -1751,36 +1921,90 @@ export class FeishuBot {
                 content: storedContent,
                 timestamp: Date.now(),
             });
-            await this.enqueueAndDispatchDelivery(chatId, "discussion", `discussion:${Date.now()}:${Math.random().toString(36).slice(2)}`, isVisible ? displayReply : "", parsedReply.attachments);
+            try {
+                await this.enqueueAndDispatchDelivery(chatId, "discussion", `discussion:${Date.now()}:${Math.random().toString(36).slice(2)}`, isVisible ? displayReply : "", parsedReply.attachments);
+            }
+            catch (err) {
+                await liveStatus?.fail().catch(() => { });
+                throw err;
+            }
         }
+        await liveStatus?.complete().catch(() => { });
         return { botName: this.config.name, text: cleanVisibleReply, visible: isVisible };
     }
+    async sendTextMessage(chatId, text) {
+        try {
+            const res = await this.client.im.message.create({
+                params: { receive_id_type: "chat_id" },
+                data: {
+                    receive_id: chatId,
+                    content: JSON.stringify({ text }),
+                    msg_type: "text",
+                },
+            });
+            this.store.clearBotUnavailableInChat(this.config.name, chatId);
+            return res?.data?.message_id || res?.message_id;
+        }
+        catch (err) {
+            if (this.isOutOfChatError(err))
+                this.markCurrentBotUnavailable(chatId, err);
+            throw err;
+        }
+    }
+    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) {
         const attachments = [];
-        const markerPattern = /<LMA_BRIDGE_ATTACHMENTS>([\s\S]*?)<\/LMA_BRIDGE_ATTACHMENTS>/g;
+        // Some models occasionally corrupt the closing tag from
+        // </LMA_BRIDGE_ATTACHMENTS> to </parameter> while preserving the exact JSON
+        // payload. Treat that as a recoverable marker shape; otherwise the whole
+        // marker leaks as user-visible text and attachments are not sent.
+        const markerPattern = /<LMA_BRIDGE_ATTACHMENTS>([\s\S]*?)(?:<\/LMA_BRIDGE_ATTACHMENTS>|<\/parameter>)/g;
         let text = reply.replace(markerPattern, (_match, jsonText) => {
             try {
                 const parsed = JSON.parse(String(jsonText).trim());
@@ -1850,6 +2074,16 @@ export class FeishuBot {
         const msg = data?.msg || data?.message || err?.message || String(err);
         return `${code}${msg}`.slice(0, 800);
     }
+    isOutOfChatError(err) {
+        const data = err?.response?.data || err?.data;
+        const code = data?.code;
+        const msg = data?.msg || data?.message || err?.message || String(err);
+        return Number(code) === 230002 || /Bot\/User can NOT be out of the chat/i.test(String(msg));
+    }
+    markCurrentBotUnavailable(chatId, err) {
+        this.store.markBotUnavailableInChat(this.config.name, chatId, this.errorSummary(err));
+        console.warn(`[${this.config.name}] Marked unavailable in chat ${chatId.slice(-8)} after Feishu out-of-chat error`);
+    }
     stripReadOnlyDocxFields(value) {
         if (Array.isArray(value))
             return value.map((item) => this.stripReadOnlyDocxFields(item));
@@ -1956,7 +2190,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 +2198,16 @@ export class FeishuBot {
                     msg_type: "interactive",
                 },
             });
+            this.store.clearBotUnavailableInChat(this.config.name, chatId);
+            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 }));
+            if (this.isOutOfChatError(err))
+                this.markCurrentBotUnavailable(chatId, err);
             // 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,9 +2215,13 @@ export class FeishuBot {
                         msg_type: "text",
                     },
                 });
+                this.store.clearBotUnavailableInChat(this.config.name, chatId);
+                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 }));
+                if (this.isOutOfChatError(fallbackErr))
+                    this.markCurrentBotUnavailable(chatId, fallbackErr);
                 throw fallbackErr;
             }
         }
@@ -1991,7 +2233,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 +2308,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 +2344,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 +2396,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 +2464,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 +2486,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}`,