openclaw-lark-multi-agent 1.0.20 → 1.0.22

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";
@@ -14,6 +15,15 @@ const MAX_MERGED_TRIGGER_MESSAGES = Number(process.env.OPENCLAW_LARK_MULTI_AGENT
 const MAX_MERGED_TRIGGER_BYTES = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_MAX_MERGED_TRIGGER_BYTES || 128 * 1024);
 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);
+class UnhealthySessionError extends Error {
+    status;
+    constructor(status) {
+        super(`unhealthy session: ${status}`);
+        this.status = status;
+        this.name = "UnhealthySessionError";
+    }
+}
 /**
  * Manages a single Feishu bot instance.
  *
@@ -261,6 +271,10 @@ export class FeishuBot {
      */
     async drainOnStartup() {
         try {
+            const restoredDeliveries = this.store.resetStaleDeliveries(this.config.name, 5 * 60_000, 5);
+            if (restoredDeliveries.restored > 0 || restoredDeliveries.failed > 0) {
+                console.warn(`[${this.config.name}] Startup delivery recovery: restored=${restoredDeliveries.restored}, failed=${restoredDeliveries.failed}`);
+            }
             const chats = this.store.getAllChatInfo();
             const drainTasks = [];
             for (const chat of chats) {
@@ -273,6 +287,12 @@ export class FeishuBot {
                 // Drain only messages that were explicitly marked as reply triggers.
                 // Context-only messages should not start an OpenClaw run after restart.
                 const pendingTriggerIds = this.store.getPendingTriggerIds(this.config.name, chat.chatId);
+                const pendingDeliveries = this.store.getPendingDeliveries(chat.chatId, this.config.name, 1);
+                if (pendingDeliveries.length > 0) {
+                    drainTasks.push(this.dispatchPendingDeliveries(chat.chatId).catch((err) => {
+                        console.warn(`[${this.config.name}] Startup delivery drain failed for ${chat.chatId.slice(-8)}:`, err.message);
+                    }));
+                }
                 if (pendingTriggerIds.size > 0) {
                     console.log(`[${this.config.name}] Startup drain: ${pendingTriggerIds.size} pending trigger(s) in ${chat.chatName || chat.chatId.slice(-8)}`);
                     // Do not let one slow/stuck chat block startup drain for all other chats.
@@ -350,8 +370,9 @@ export class FeishuBot {
             }
             // --- Extract text content based on message type ---
             let cleanText = "";
+            let rawText = "";
             if (messageType === "text") {
-                const rawText = content.text || "";
+                rawText = content.text || "";
                 cleanText = this.cleanMentions(rawText);
                 // A mention-only text message is still a valid routing trigger. Feishu may
                 // expose mentions as display text like "@万万（Claude）" rather than @_user_xxx,
@@ -427,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
@@ -467,9 +488,12 @@ export class FeishuBot {
                 const isModelCommand = commandName === "/model";
                 const rejectModelAll = chatType !== "p2p" && isModelCommand && routing.isAllMention;
                 if (chatType !== "p2p") {
+                    const groupBotCount = Array.from(FeishuBot.allBots.values()).filter((bot) => bot.store === this.store).length;
+                    const singleBotGroup = groupBotCount === 1;
                     if (isModelCommand) {
                         // Model switching is per-bot. @all is rejected by one coordinator;
-                        // otherwise group /model must explicitly target this bot.
+                        // otherwise group /model must explicitly target this bot. A single-bot
+                        // group treats the sole bot as the implicit target.
                         if (routing.isAllMention) {
                             if (!this.isDiscussionCoordinator())
                                 return;
@@ -478,12 +502,58 @@ export class FeishuBot {
                             if (!routing.isCurrentBotMentioned)
                                 return;
                         }
+                        else if (!singleBotGroup) {
+                            if (!this.isDiscussionCoordinator())
+                                return;
+                        }
+                    }
+                    else if (isChairmanCommand) {
+                        // /chairman @Bot is owned by the mentioned bot itself. This avoids
+                        // requiring a coordinator to parse another bot's mention metadata,
+                        // which can vary across Feishu clients/bridges. Untargeted/status,
+                        // @all, and clear/off remain coordinator-owned group commands.
+                        //
+                        // Target resolution uses both Feishu mention metadata AND a text
+                        // fallback (parsing "@Bot" / "Bot" from the raw message), so a
+                        // /chairman that arrives without mention metadata still routes to
+                        // the intended bot instead of silently failing.
+                        const chairmanArg = this.stripLeadingCommandMentions(this.cleanMentions(rawText)).replace(/^\s*\/chairman\b/i, "").trim().toLowerCase();
+                        const isClearArg = ["off", "clear", "none"].includes(chairmanArg.split(/\s+/)[0] || "");
+                        const hasMentionMeta = (message.mentions || []).some((m) => !this.isAllMentionItem(m));
+                        const targets = this.resolveChairmanTargets(message.mentions || [], cleanText, rawText);
+                        // A pure status query: no clear keyword, no mention metadata, and no
+                        // textual argument at all. Anything else is a set/route attempt.
+                        const isStatusArg = !isClearArg && !hasMentionMeta && chairmanArg.length === 0;
+                        if (isClearArg || isStatusArg) {
+                            // Group-level status/clear: one coordinator handles it.
+                            if (!this.isDiscussionCoordinator())
+                                return;
+                        }
+                        else if (targets.length >= 1) {
+                            // Targets resolved: only the (single) targeted bot acts. If
+                            // multiple distinct targets resolved, the coordinator handles
+                            // the "only one chairman" error once.
+                            const uniqueTargets = Array.from(new Set(targets));
+                            const targetedSelf = uniqueTargets.includes(this.config.name);
+                            if (uniqueTargets.length > 1) {
+                                if (!this.isDiscussionCoordinator())
+                                    return;
+                            }
+                            else if (!targetedSelf) {
+                                return;
+                            }
+                        }
                         else {
-                            return;
+                            // A set attempt whose target could not be resolved at all (missing
+                            // metadata AND no readable name in text): coordinator handles the
+                            // fallback so the user still gets an actionable reply.
+                            if (!this.isDiscussionCoordinator())
+                                return;
                         }
                     }
-                    else if (isChairmanCommand || isLocaleCommand) {
-                        // Group-level settings; one coordinator handles them.
+                    else if (isLocaleCommand && !routing.hasTargetedMention) {
+                        // Untargeted or @all locale is a group-level setting; one coordinator handles it.
+                        // If the user explicitly @s a bot, the targeted bot should execute and answer.
                         if (!this.isDiscussionCoordinator())
                             return;
                     }
@@ -497,8 +567,9 @@ export class FeishuBot {
                         if (!routing.isCurrentBotMentioned)
                             return;
                     }
-                    else if (!routing.isAllMention) {
-                        // Other bridge commands in a group need an explicit target or @all.
+                    else if (!routing.isAllMention && !singleBotGroup) {
+                        // Other bridge commands in a multi-bot group need an explicit target or @all.
+                        // A single-bot group treats the sole bot as the implicit target.
                         return;
                     }
                 }
@@ -521,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    — 显示此帮助信息`,
                         ``,
@@ -583,6 +655,14 @@ export class FeishuBot {
                     return;
                 }
                 if (commandName === "/model") {
+                    if (chatType !== "p2p" && !routing.isAllMention && !routing.hasTargetedMention) {
+                        const groupBotCount = Array.from(FeishuBot.allBots.values()).filter((bot) => bot.store === this.store).length;
+                        if (groupBotCount > 1) {
+                            await this.replyMessage(messageId, "❌ /model 是单 bot 设置，请明确 @ 一个 bot，例如：@Claude /model provider/model-id");
+                            markCommandSynced();
+                            return;
+                        }
+                    }
                     await this.handleModelCommand(chatId, messageId, cleanText.trim());
                     markCommandSynced();
                     return;
@@ -601,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 模式只在群聊中可用");
@@ -665,7 +757,7 @@ export class FeishuBot {
                     return;
                 }
                 if (commandName === "/chairman") {
-                    await this.handleChairmanCommand(chatId, chatType, messageId, message.mentions || [], cleanText.trim());
+                    await this.handleChairmanCommand(chatId, chatType, messageId, message.mentions || [], cleanText.trim(), rawText);
                     markCommandSynced();
                     return;
                 }
@@ -687,7 +779,8 @@ export class FeishuBot {
                     const chairman = this.getChairmanParticipant(chatId);
                     const participants = this.getDiscussionParticipants(chatId);
                     if (participants.length > 0 || chairman) {
-                        discussionManager.startIfAbsent({
+                        const preempted = discussionManager.status(chatId);
+                        const started = discussionManager.startIfAbsent({
                             chatId,
                             rootMessageId: messageId,
                             topic: cleanText,
@@ -705,19 +798,26 @@ export class FeishuBot {
                                 }
                             },
                         });
+                        if (started && preempted) {
+                            await this.sendMessage(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。");
+                            ? "💬 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) {
@@ -735,6 +835,10 @@ export class FeishuBot {
             }
             // Track this message for reaction status updates
             const pending = this.pendingAckMessages.get(chatId) || [];
+            const unhealthy = await this.getUnhealthySessionStatus(chatId);
+            if (unhealthy) {
+                await this.warnUnhealthySessionAndContinue(chatId, messageId, unhealthy);
+            }
             // Anti-loop
             const streak = this.store.getBotStreak(chatId, this.config.name);
             if (streak >= MAX_BOT_STREAK) {
@@ -771,6 +875,78 @@ 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 {
+            const resp = await this.openclawClient.getSessionInfo(sessionKey);
+            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))) {
+                return status;
+            }
+        }
+        catch {
+            // Absence/transient describe failures should not block a new run; chat.send
+            // will create/report the session as usual.
+        }
+        return null;
+    }
+    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 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, "DONE").catch(() => { });
+        }
+        this.pendingAckMessages.set(chatId, remainingAcks);
+        await this.addReaction(messageId, "DONE").catch(() => { });
+        await this.replyMessage(messageId, this.isEn(chatId)
+            ? `⚠️ ${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;
+        const monitoredWork = work.finally(() => { done = true; });
+        const monitor = (async () => {
+            while (!done) {
+                await new Promise((resolve) => setTimeout(resolve, SESSION_HEALTH_POLL_MS));
+                if (done)
+                    break;
+                const unhealthy = await this.getUnhealthySessionStatus(chatId);
+                if (unhealthy) {
+                    await this.stopForUnhealthySession(chatId, messageId, unhealthy);
+                    throw new UnhealthySessionError(unhealthy);
+                }
+            }
+            return undefined;
+        })();
+        try {
+            return await Promise.race([monitoredWork, monitor]);
+        }
+        finally {
+            done = true;
+        }
+    }
     /**
      * Process queued messages for a chat: batch all unsynced messages and send to OpenClaw.
      * Loops until no more unsynced human messages remain.
@@ -798,6 +974,11 @@ export class FeishuBot {
             if (pendingHumanTriggers.length === 0) {
                 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
@@ -850,6 +1031,17 @@ export class FeishuBot {
                     console.warn(`[${this.config.name}] Dropped ${droppedMergedTriggers.length} older pending trigger(s) for ${chatId.slice(-8)} due to merge limits (kept=${mergedTriggers.length}, bytes=${bytes}): ${summaries}`);
                 }
             }
+            const deliveredTriggerIds = mergedTriggers
+                .map((m) => m.id || 0)
+                .filter((id) => id > 0 && this.store.hasDeliveredReply(this.config.name, chatId, id));
+            if (deliveredTriggerIds.length > 0) {
+                console.warn(`[${this.config.name}] Clearing ${deliveredTriggerIds.length} stale delivered pending trigger(s) for ${chatId.slice(-8)}: ${deliveredTriggerIds.join(",")}`);
+                for (const id of deliveredTriggerIds)
+                    this.store.clearPendingTrigger(this.config.name, chatId, id);
+                mergedTriggers = mergedTriggers.filter((m) => !m.id || !deliveredTriggerIds.includes(m.id));
+                if (mergedTriggers.length === 0)
+                    continue;
+            }
             const isNativeCommandTrigger = firstIsNative;
             const lastHuman = mergedTriggers[mergedTriggers.length - 1];
             const triggerId = lastHuman.id || 0;
@@ -915,6 +1107,7 @@ export class FeishuBot {
                 }
             }
             let runAcceptedByOpenClaw = false;
+            let liveStatus;
             try {
                 const releaseActiveDeliveryTarget = lastHuman.messageId ? this.setActiveDeliveryTarget(chatId, triggerId, lastHuman.messageId) : () => { };
                 let reply;
@@ -933,8 +1126,22 @@ 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.openclawClient.chatSendWithContext({
+                    reply = await this.withSessionHealthMonitor(chatId, lastHuman.messageId || "", triggerId, this.openclawClient.chatSendWithContext({
                         sessionKey,
                         unsyncedMessages: contextMsgs,
                         currentMessage: mergedContent,
@@ -958,7 +1165,8 @@ export class FeishuBot {
                             // INSERT OR IGNORE in message_sync.
                             markSubmittedBatch(`submitted:${runId}`);
                         },
-                    });
+                        onProgress: (event) => liveStatus?.progress(event),
+                    }));
                 }
                 finally {
                     // OpenClaw may emit the final assistant session.message just after
@@ -980,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 = [];
@@ -1053,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)
@@ -1063,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
@@ -1088,15 +1307,29 @@ export class FeishuBot {
                 this.pendingAckMessages.set(chatId, remainingAcks);
             }
             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
@@ -1113,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);
@@ -1185,7 +1418,7 @@ export class FeishuBot {
         return mentions.some((m) => this.mentionedBotName(m) === this.config.name);
     }
     isAllMention(rawText, mentions = []) {
-        if (rawText && (rawText.includes("@_all") || rawText.includes("@all") || rawText.includes("@所有人")))
+        if (rawText && /(^|\s)@(?:_all|all|所有人)(?=\s|$)/i.test(rawText))
             return true;
         return mentions.some((m) => this.isAllMentionItem(m));
     }
@@ -1227,7 +1460,7 @@ export class FeishuBot {
         return null;
     }
     escapeRegExp(value) {
-        return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        return value.replace(/[.*+?^${}()|[\]\\-]/g, "\\$&");
     }
     resolveBotName(sender) {
         const openId = sender?.sender_id?.open_id;
@@ -1308,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) {
@@ -1390,12 +1623,6 @@ export class FeishuBot {
             if (this.store.hasRecentOverlappingDelivery(this.config.name, chatId, text, attachmentsJson, 60_000, 8, [sourceType]))
                 return;
         }
-        else if (sourceType === "assistant_visible") {
-            if (this.store.hasRecentSimilarDelivery(this.config.name, chatId, contentHash, 60_000, ["assistant_visible"]))
-                return;
-            if (this.store.hasRecentOverlappingDelivery(this.config.name, chatId, text, attachmentsJson, 60_000, 30, ["assistant_visible"]))
-                return;
-        }
         const deliveryId = this.store.enqueueDelivery({
             sessionKey: this.deliverySessionKey(chatId),
             chatId,
@@ -1473,6 +1700,49 @@ export class FeishuBot {
             .filter((name) => Boolean(name));
         return Array.from(new Set(names));
     }
+    mentionedBotNamesFromChairmanText(...texts) {
+        const normalizedTexts = texts
+            .filter(Boolean)
+            .map((text) => text.replace(/^\s*\/chairman\b/i, "").trim())
+            .filter(Boolean)
+            .map((text) => text.replace(/^@+/, "").replace(/\s+/g, "").toLowerCase());
+        if (normalizedTexts.length === 0)
+            return [];
+        const names = [];
+        const candidates = [this, ...Array.from(FeishuBot.allBots.values()).filter((bot) => bot !== this && bot.store === this.store)];
+        for (const raw of normalizedTexts) {
+            for (const bot of candidates) {
+                const botName = bot.config.name.trim().replace(/\s+/g, "").toLowerCase();
+                const displayNames = [
+                    botName,
+                    `@${botName}`,
+                    `万万（${botName}）`,
+                    `@万万（${botName}）`,
+                    `万万(${botName})`,
+                    `@万万(${botName})`,
+                ];
+                if (displayNames.includes(raw) || new RegExp(`^@?[^()（）]+[（(]${this.escapeRegExp(botName)}[）)]$`, "i").test(raw)) {
+                    names.push(bot.config.name);
+                }
+            }
+        }
+        return Array.from(new Set(names));
+    }
+    /**
+     * Resolve the target bot name(s) for a /chairman command using every signal
+     * available, in priority order:
+     *   1. Feishu mention metadata (app_id / open_id / name).
+     *   2. Text fallback: "@Bot" or "Bot" written in the message body.
+     *
+     * This keeps /chairman working even when a Feishu client or bridge omits
+     * mention metadata. Returns a de-duplicated, order-preserving list.
+     */
+    resolveChairmanTargets(mentions, text, rawText = "") {
+        const fromMeta = this.mentionedBotNames(mentions);
+        if (fromMeta.length > 0)
+            return fromMeta;
+        return this.mentionedBotNamesFromChairmanText(text, rawText);
+    }
     isDiscussionCoordinator() {
         const bots = Array.from(FeishuBot.allBots.values()).filter((bot) => bot.store === this.store);
         if (bots.length === 0)
@@ -1482,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) {
@@ -1549,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) {
@@ -1750,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,
@@ -1758,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,
@@ -1771,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 }));
@@ -1785,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;
     }
     /**
@@ -1860,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") {
@@ -1879,7 +2175,7 @@ export class FeishuBot {
         }
         if (action === "rounds") {
             const n = Number.parseInt(parts[2] || "", 10);
-            if (!Number.isFinite(n)) {
+            if (!Number.isInteger(n) || n < 1 || n > 10) {
                 await this.replyMessage(messageId, "❌ Usage: /discuss rounds <1-10>");
                 return;
             }
@@ -1896,49 +2192,61 @@ 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"));
     }
-    async handleChairmanCommand(chatId, chatType, messageId, mentions, text) {
+    async handleChairmanCommand(chatId, chatType, messageId, mentions, text, rawText = "") {
         if (chatType === "p2p") {
             await this.replyMessage(messageId, "❌ Chairman 只在群聊中可用");
             return;
         }
         const parts = text.split(/\s+/).filter(Boolean);
-        const action = (parts[1] || "status").toLowerCase();
+        const action = (parts[1] || "").toLowerCase();
         if (["off", "clear", "none"].includes(action)) {
             const previous = this.store.getChairmanBot(chatId);
             this.store.clearChairmanBot(chatId);
             await this.replyMessage(messageId, previous ? `✅ 已清除当前群 Chairman（原 ${previous}）` : "✅ 当前群没有 Chairman");
             return;
         }
-        const botNames = this.mentionedBotNames(mentions);
-        if (botNames.length === 0) {
-            const current = this.store.getChairmanBot(chatId);
-            await this.replyMessage(messageId, current
-                ? `👑 当前 Chairman：${current}\n作用：普通消息无人 free 时由 TA 回答；Discuss 模式下负责主持、调停和最终总结。`
-                : "👑 当前没有 Chairman\n用法：/chairman @某个Bot");
+        const resolvedBotNames = this.resolveChairmanTargets(mentions, text, rawText);
+        if (resolvedBotNames.length === 0) {
+            // /chairman is intentionally not a status query. Status lives in /status;
+            // this command is only for switching or clearing the Chairman. Keeping the
+            // two meanings separate prevents failed mention parsing from being masked
+            // as a harmless "current status" response.
+            const groupBots = Array.from(FeishuBot.allBots.values())
+                .filter((bot) => bot.store === this.store)
+                .map((bot) => bot.config.name);
+            const uniqueGroupBots = Array.from(new Set(groupBots));
+            const choices = uniqueGroupBots.length > 0
+                ? uniqueGroupBots.map((name) => `/chairman ${name}`).join("\n")
+                : "/chairman @某个Bot";
+            await this.replyMessage(messageId, `❌ /chairman 只用于设置/切换 Chairman，不再用于状态查询。\n` +
+                `查看当前 Chairman 请用 /status。\n` +
+                `切换请 @ 一个 bot，或直接发（可复制）：\n${choices}\n` +
+                `清除请用：/chairman off`);
             return;
         }
-        if (botNames.length > 1) {
+        if (resolvedBotNames.length > 1) {
             await this.replyMessage(messageId, "❌ 一个群只能设置一个 Chairman。请只 @ 一个 bot。");
             return;
         }
-        const next = botNames[0];
+        const next = resolvedBotNames[0];
         const previous = this.store.getChairmanBot(chatId);
         this.store.setChairmanBot(chatId, next);
         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"));
@@ -2004,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"
@@ -2025,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}`,
@@ -2113,7 +2423,7 @@ export class FeishuBot {
                     chatName: "私聊",
                     members: "",
                     memberNames: "",
-                    ownerBot: this.config.name,
+                    ownerBot: existing?.ownerBot || this.config.name,
                     freeDiscussion: this.store.getChatInfo(chatId)?.freeDiscussion || false,
                     verbose: this.store.getChatInfo(chatId)?.verbose || false,
                     discuss: this.store.getChatInfo(chatId)?.discuss || false,