openclaw-lark-multi-agent 1.0.22 → 1.1.0

package/dist/feishu-bot.d.ts

@@ -40,6 +40,8 @@ export declare class FeishuBot {
     private locale;
     private configPath?;
     private static allBots;
+    /** Chats where this bot app has actually received an event in this process. */
+    private static seenBotChats;
     constructor(config: BotConfig, openclawClient: OpenClawClient, store: MessageStore, adminOpenId?: string, configPath?: string);
     private handleMessageRecalled;
     register(): void;
@@ -75,6 +77,20 @@ export declare class FeishuBot {
     private handleMessage;
     private shouldUseLiveStatus;
     private getUnhealthySessionStatus;
+    /**
+     * 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.
+     */
+    private isSessionDeadStatus;
     private warnUnhealthySessionAndContinue;
     private stopForUnhealthySession;
     private withSessionHealthMonitor;
@@ -107,6 +123,7 @@ export declare class FeishuBot {
     private deliverySessionKey;
     private stableHash;
     private deliverySourceId;
+    private sendSystemDelivery;
     private enqueueAndDispatchDelivery;
     private dispatchPendingDeliveries;
     private hasFreeModeBot;
@@ -123,10 +140,20 @@ export declare class FeishuBot {
      */
     private resolveChairmanTargets;
     private isDiscussionCoordinator;
+    private static markBotSeenInChat;
+    private markCurrentBotSeenInChat;
+    private isBotAvailableInChat;
     private getDiscussionParticipants;
     private getChairmanParticipant;
     private asDiscussionParticipant;
     private runDiscussionTurn;
+    private buildLiveStatusCard;
+    /** Minimal escaping so activity text does not break card markdown. */
+    private escapeCardText;
+    private sendLiveStatusCard;
+    private replyLiveStatusCard;
+    private patchLiveStatusCard;
+    private sendTextMessage;
     private replyTextMessage;
     private editTextMessage;
     private deleteMessageById;
@@ -137,6 +164,8 @@ export declare class FeishuBot {
     private inferFeishuFileType;
     private isImagePath;
     private errorSummary;
+    private isOutOfChatError;
+    private markCurrentBotUnavailable;
     private stripReadOnlyDocxFields;
     private createFeishuDocFromMarkdown;
     private sendBridgeAttachment;

package/dist/feishu-bot.js

@@ -16,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) {
@@ -63,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;
@@ -192,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);
@@ -330,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;
@@ -486,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;
@@ -557,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())
@@ -787,25 +809,25 @@ 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)
+                        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。");
                     }
@@ -891,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
@@ -901,6 +922,26 @@ export class FeishuBot {
         }
         return null;
     }
+    /**
+     * 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.`
@@ -934,8 +975,18 @@ export class FeishuBot {
                     break;
                 const unhealthy = await this.getUnhealthySessionStatus(chatId);
                 if (unhealthy) {
-                    await this.stopForUnhealthySession(chatId, messageId, 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;
@@ -1128,18 +1179,19 @@ export class FeishuBot {
                 };
                 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)),
+                        create: (view) => this.sendOrdered(chatId, () => this.replyLiveStatusCard(lastHuman.messageId || "", view, chatId)),
+                        edit: (messageId, view) => this.sendOrdered(chatId, () => this.patchLiveStatusCard(messageId, view, chatId)),
                         warn: (message, err) => console.warn(`[${this.config.name}] ${message}:`, this.errorSummary(err)),
                     }, {
                         botName: this.config.name,
+                        model: this.config.model,
                         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,
@@ -1188,7 +1240,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();
+                    await liveStatus?.noReply().catch(() => { });
                     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 = [];
@@ -1259,6 +1311,7 @@ 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 {
@@ -1283,11 +1336,14 @@ export class FeishuBot {
                     }
                 }
                 if (isRuntimeFailure && lastHuman.messageId) {
-                    liveStatus?.dispose();
+                    await liveStatus?.fail().catch(() => { });
                     this.scheduleDelayedFailure(chatId, lastHuman.messageId, visibleReply, triggerId);
                 }
                 else if (!shouldReply && !hasAttachments) {
-                    liveStatus?.dispose();
+                    // Explicit NO_REPLY (or empty visible text): the model finished without
+                    // producing a user-visible reply. Mark the status card done with a
+                    // "no content" summary instead of leaving it stuck on "正在执行".
+                    await liveStatus?.noReply().catch(() => { });
                 }
                 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
@@ -1604,6 +1660,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;
@@ -1672,6 +1732,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)}`;
@@ -1749,17 +1811,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) !== "mute")
+            .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) {
@@ -1771,6 +1858,19 @@ 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: (view) => this.sendOrdered(chatId, () => this.sendLiveStatusCard(chatId, view)),
+                edit: (messageId, view) => this.sendOrdered(chatId, () => this.patchLiveStatusCard(messageId, view, chatId)),
+                warn: (message, err) => console.warn(`[${this.config.name}] ${message}:`, err instanceof Error ? err.message : err),
+            }, {
+                botName: this.config.name,
+                model: this.config.model,
+                locale: this.isEn(chatId) ? "en" : "zh",
+            })
+            : undefined;
+        liveStatus?.start(meta ? `第 ${meta.round}/${meta.maxRounds} 轮讨论` : "讨论中");
         let reply;
         try {
             reply = await this.openclawClient.chatSendWithContext({
@@ -1781,8 +1881,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;
@@ -1815,10 +1920,127 @@ 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;
+            }
+        }
+        // Mirror the normal path: a NO_REPLY/empty discussion turn should finish the
+        // status card with a "no content" summary, not a plain done summary.
+        if (!isVisible && parsedReply.attachments.length === 0) {
+            await liveStatus?.noReply().catch(() => { });
+        }
+        else {
+            await liveStatus?.complete().catch(() => { });
         }
         return { botName: this.config.name, text: cleanVisibleReply, visible: isVisible };
     }
+    buildLiveStatusCard(view, chatId) {
+        const en = this.isEn(chatId);
+        const elements = [];
+        // Content area. While running: recent activity lines (each prefixed with the
+        // relative time mm:ss since the run started). When finished: a single run
+        // summary line (total tool calls + elapsed) instead of recent messages.
+        if (view.lines.length > 0) {
+            const iconFor = (kind) => kind === "tool_start" ? "▸"
+                : kind === "tool_end" ? "✓"
+                    : kind === "lifecycle" ? "⋯"
+                        : kind === "summary" ? "📊"
+                            : "•";
+            const fmtAt = (sec) => `${Math.floor(sec / 60)}:${String(sec % 60).padStart(2, "0")}`;
+            const content = view.lines
+                .map((l) => {
+                const stamp = l.kind === "summary" ? "" : `\`${fmtAt(l.at)}\` `;
+                return `${stamp}${iconFor(l.kind)} ${this.escapeCardText(l.text)}`;
+            })
+                .join("\n");
+            elements.push({ tag: "markdown", content });
+        }
+        else {
+            elements.push({ tag: "markdown", content: en ? "_working…_" : "_正在启动…_" });
+        }
+        elements.push({ tag: "hr" });
+        // Footer: elapsed time + model name.
+        const footerBits = [];
+        footerBits.push(en ? `⏱ ${view.elapsed}` : `⏱ 已用 ${view.elapsed}`);
+        if (view.model)
+            footerBits.push(`🧠 ${this.escapeCardText(view.model)}`);
+        elements.push({ tag: "markdown", content: `<font color='grey'>${footerBits.join("  ·  ")}</font>` });
+        // Title color reflects state.
+        const template = view.state === "done" ? "green" : view.state === "failed" ? "orange" : "blue";
+        return {
+            schema: "2.0",
+            // update_multi is REQUIRED for im.message.patch to update the card; Feishu
+            // rejects patches on cards that did not declare it before and after.
+            config: { update_multi: true, width_mode: "fill" },
+            header: {
+                title: { tag: "plain_text", content: view.title },
+                template,
+            },
+            body: { elements },
+        };
+    }
+    /** Minimal escaping so activity text does not break card markdown. */
+    escapeCardText(text) {
+        return String(text || "").replace(/</g, "\uff1c").replace(/>/g, "\uff1e");
+    }
+    async sendLiveStatusCard(chatId, view) {
+        try {
+            const res = await this.client.im.message.create({
+                params: { receive_id_type: "chat_id" },
+                data: {
+                    receive_id: chatId,
+                    content: JSON.stringify(this.buildLiveStatusCard(view, chatId)),
+                    msg_type: "interactive",
+                },
+            });
+            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 replyLiveStatusCard(messageId, view, chatId) {
+        const res = await this.client.im.message.reply({
+            path: { message_id: messageId },
+            data: {
+                content: JSON.stringify(this.buildLiveStatusCard(view, chatId)),
+                msg_type: "interactive",
+            },
+        });
+        return res?.data?.message_id || res?.message_id;
+    }
+    async patchLiveStatusCard(messageId, view, chatId) {
+        await this.client.im.message.patch({
+            path: { message_id: messageId },
+            data: { content: JSON.stringify(this.buildLiveStatusCard(view, chatId)) },
+        });
+    }
+    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 },
@@ -1868,7 +2090,12 @@ export class FeishuBot {
     }
     extractBridgeAttachments(reply) {
         const attachments = [];
-        const markerPattern = /<LMA_BRIDGE_ATTACHMENTS>([\s\S]*?)<\/LMA_BRIDGE_ATTACHMENTS>/g;
+        // Some models occasionally corrupt the attachment marker while preserving
+        // the exact JSON payload: the closing tag can become </parameter>, or the
+        // opening "<LMA" prefix can be truncated leaving "_BRIDGE_ATTACHMENTS>".
+        // Treat these as recoverable shapes; otherwise the marker leaks as
+        // user-visible text and attachments are not sent.
+        const markerPattern = /(?:<LMA_BRIDGE_ATTACHMENTS>|_BRIDGE_ATTACHMENTS>)([\s\S]*?)(?:<\/LMA_BRIDGE_ATTACHMENTS>|<\/parameter>)/g;
         let text = reply.replace(markerPattern, (_match, jsonText) => {
             try {
                 const parsed = JSON.parse(String(jsonText).trim());
@@ -1938,6 +2165,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));
@@ -2052,10 +2289,13 @@ 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 {
                 const res = await this.client.im.message.create({
@@ -2066,10 +2306,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;
             }
         }

package/dist/live-status.d.ts

@@ -1,7 +1,29 @@
 import type { ProgressEvent } from "./openclaw-client";
+/** One activity line shown in the card content area. */
+export type LiveStatusLine = {
+    kind: "tool_start" | "tool_end" | "text" | "lifecycle" | "summary";
+    text: string;
+    /** Relative time (seconds since run start) when this line was produced. */
+    at: number;
+};
+/** Structured snapshot the renderer turns into a Feishu interactive card. */
+export type LiveStatusView = {
+    /** Card title, e.g. "Claude 正在执行" / "✅ Claude 已完成". */
+    title: string;
+    /** Activity lines (oldest first); when finished this holds a summary instead. */
+    lines: LiveStatusLine[];
+    /** Footer: elapsed time like "0:42". */
+    elapsed: string;
+    /** Footer: model name, e.g. "phgeek-gw/claude-opus-4.8". */
+    model?: string;
+    /** Terminal state: running / done / failed (lets renderer pick color). */
+    state: "running" | "done" | "failed";
+};
 export type LiveStatusCallbacks = {
-    create: (text: string) => Promise<string | undefined>;
-    edit: (messageId: string, text: string) => Promise<void>;
+    /** Create the status card; returns the new message id. */
+    create: (view: LiveStatusView) => Promise<string | undefined>;
+    /** Patch the existing status card. */
+    edit: (messageId: string, view: LiveStatusView) => Promise<void>;
     warn?: (message: string, err?: unknown) => void;
 };
 export type LiveStatusOptions = {
@@ -9,48 +31,67 @@ export type LiveStatusOptions = {
     locale?: "zh" | "en";
     delayMs?: number;
     maxChars?: number;
-    maxEdits?: number;
-    disableHint?: string;
+    /** Model name shown in the footer. */
+    model?: string;
+    /** Number of recent activity lines kept in the content area. */
+    historySize?: number;
+    /** Footer/auto-refresh cadence in ms. */
+    tickMs?: number;
 };
 export declare class LiveStatusController {
     private readonly callbacks;
     private readonly opts;
     private messageId?;
-    private lastSentText;
-    private detail;
-    /** Number of edits already issued against the live message (excludes create). */
-    private editCount;
+    private lastSentSignature;
+    /** Recent activity lines (most-recent last), capped at historySize. */
+    private lines;
+    private startedAt;
     private createTimer?;
+    private tickTimer?;
     private createPromise?;
     private finalized;
     private disabled;
-    /** True after the running-state budget is spent; future progress is ignored. */
-    private runningLimitReached;
+    private state;
+    /** Total tool calls (tool_start events) seen during the run, for the summary. */
+    private toolCallCount;
+    /** True when finished via noReply(): show a "no content" summary. */
+    private noReplyResult;
     constructor(callbacks: LiveStatusCallbacks, opts: LiveStatusOptions);
     get id(): string | undefined;
     start(initialDetail?: string): void;
     progress(event: ProgressEvent | string): Promise<void>;
-    /**
-     * Finish the live status when the real (final) reply is delivered separately.
-     * The final answer is sent by the normal interactive-card path, so the status
-     * message must NOT be overwritten with the answer (text type does not render
-     * Markdown). Feishu renders message deletion as a visible "recalled a message"
-     * tombstone, so keep the status message and mark it done instead.
-     */
     complete(): Promise<void>;
+    fail(): Promise<void>;
     /**
-     * Finish the live status when the run failed and the error is delivered by the
-     * normal path. Use a neutral/negative marker so it does not contradict the
-     * separately delivered error message.
+     * Finish when the model explicitly produced no reply (NO_REPLY) or an empty
+     * final. Mark the card done but show a "no content" summary instead of the
+     * activity window, so the user understands the run finished without output.
      */
-    fail(): Promise<void>;
+    noReply(): Promise<void>;
     dispose(): void;
+    /**
+     * Intermediate assistant text arrives as incremental fragments (each flush
+     * sends only the newly-added slice). Consecutive fragments with no tool event
+     * in between belong to the same thought, so merge them into ONE line instead
+     * of showing each fragment (or each table row) as a separate message. A tool
+     * event resets this, so the next text starts a fresh line.
+     */
+    private appendText;
+    private normalizeText;
+    private clip;
+    private pushLine;
     private stopTimers;
     private ensureCreatedNow;
     private ensureCreated;
-    private editRunningStatus;
+    /** Refresh the elapsed-time footer periodically even with no new activity. */
+    private startTicker;
     private safeEdit;
-    private formatToolStart;
-    private formatStatus;
-    private formatLimitNotice;
+    /** Dedupe key includes elapsed so the footer timer ticks even without new
+     *  activity, while identical content within the same second is still skipped. */
+    private signature;
+    private isNoReplyText;
+    private formatTool;
+    private formatElapsed;
+    private buildView;
+    private buildSummaryLine;
 }

package/dist/live-status.js

@@ -1,23 +1,29 @@
 const DEFAULT_DELAY_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_DELAY_MS || 800);
 const DEFAULT_MAX_CHARS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_MAX_CHARS || 120);
-// Feishu caps a single message at 20 edits (code=230072 once exhausted). Keep the
-// final edit for the completion marker; running-state updates may consume at most
-// maxEdits - 1, with the last running edit reserved for an explicit limit notice.
-const DEFAULT_MAX_EDITS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_MAX_EDITS || 20);
+// How many recent activity lines to keep in the card content area.
+const DEFAULT_HISTORY = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_HISTORY || 6);
+// How often to refresh the elapsed-time footer even when no new activity arrives,
+// so the "已用时间" keeps advancing. Card patch has no 20-edit cap (unlike text
+// edit), so a modest cadence is safe.
+const DEFAULT_TICK_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_TICK_MS || 3000);
 export class LiveStatusController {
     callbacks;
     opts;
     messageId;
-    lastSentText = "";
-    detail = "";
-    /** Number of edits already issued against the live message (excludes create). */
-    editCount = 0;
+    lastSentSignature = "";
+    /** Recent activity lines (most-recent last), capped at historySize. */
+    lines = [];
+    startedAt = Date.now();
     createTimer;
+    tickTimer;
     createPromise;
     finalized = false;
     disabled = false;
-    /** True after the running-state budget is spent; future progress is ignored. */
-    runningLimitReached = false;
+    state = "running";
+    /** Total tool calls (tool_start events) seen during the run, for the summary. */
+    toolCallCount = 0;
+    /** True when finished via noReply(): show a "no content" summary. */
+    noReplyResult = false;
     constructor(callbacks, opts) {
         this.callbacks = callbacks;
         this.opts = opts;
@@ -26,78 +32,138 @@ export class LiveStatusController {
     start(initialDetail) {
         if (this.disabled || this.finalized || this.createTimer || this.messageId)
             return;
-        this.detail = initialDetail || "";
+        this.startedAt = Date.now();
+        if (initialDetail && initialDetail.trim()) {
+            this.pushLine("lifecycle", initialDetail.trim());
+        }
         this.createTimer = setTimeout(() => {
             this.createTimer = undefined;
             this.createPromise = this.ensureCreated();
         }, this.opts.delayMs ?? DEFAULT_DELAY_MS);
     }
     async progress(event) {
-        if (this.disabled || this.finalized || this.runningLimitReached)
+        if (this.disabled || this.finalized)
             return;
-        // Only tool-call start is meaningful enough to spend one of Feishu's limited
-        // edit slots. Ignore verbose assistant notes, lifecycle ticks, tool end, and
-        // tool error; the final/error answer is delivered by the normal message path.
-        if (typeof event !== "string") {
-            if (event.kind !== "tool" || event.phase !== "start")
+        // Card patch has no 20-edit cap (verified against Feishu im.message.patch),
+        // so we can show a small rolling window of recent activity: tool start, tool
+        // end, and intermediate assistant text each count as one line. We ignore
+        // tool "error" (the error is delivered through the normal message path) and
+        // lifecycle ticks after the first.
+        if (typeof event === "string") {
+            const t = event.trim();
+            if (!t || this.isNoReplyText(t))
+                return;
+            this.appendText(t);
+        }
+        else if (event.kind === "tool") {
+            if (event.phase === "start") {
+                this.toolCallCount++;
+                this.pushLine("tool_start", this.formatTool(event));
+            }
+            else if (event.phase === "end")
+                this.pushLine("tool_end", this.formatTool(event));
+            else
+                return; // tool error -> normal error path
+        }
+        else if (event.kind === "assistant_note") {
+            const t = (event.text || "").trim();
+            if (!t || this.isNoReplyText(t))
                 return;
-            this.detail = this.formatToolStart(event);
+            this.appendText(t);
         }
         else {
-            // String progress is kept for tests/backwards compatibility, but in normal
-            // runtime OpenClaw progress is structured and only tool start passes above.
-            this.detail = event.trim();
+            return; // lifecycle ticks: ignore (footer timer already advances)
         }
-        if (!this.detail)
-            return;
         await this.ensureCreatedNow();
-        await this.editRunningStatus();
+        await this.safeEdit(this.buildView());
     }
-    /**
-     * Finish the live status when the real (final) reply is delivered separately.
-     * The final answer is sent by the normal interactive-card path, so the status
-     * message must NOT be overwritten with the answer (text type does not render
-     * Markdown). Feishu renders message deletion as a visible "recalled a message"
-     * tombstone, so keep the status message and mark it done instead.
-     */
     async complete() {
+        this.state = "done";
         this.finalized = true;
         this.stopTimers();
         if (this.createPromise)
             await this.createPromise.catch(() => { });
         if (!this.messageId || this.disabled)
             return;
-        const doneText = this.opts.locale === "en"
-            ? `\u2705 ${this.opts.botName} done`
-            : `\u2705 ${this.opts.botName} \u5df2\u5b8c\u6210`;
-        await this.safeEdit(doneText, true);
+        await this.safeEdit(this.buildView(), true);
+    }
+    async fail() {
+        this.state = "failed";
+        this.finalized = true;
+        this.stopTimers();
+        if (this.createPromise)
+            await this.createPromise.catch(() => { });
+        if (!this.messageId || this.disabled)
+            return;
+        await this.safeEdit(this.buildView(), true);
     }
     /**
-     * Finish the live status when the run failed and the error is delivered by the
-     * normal path. Use a neutral/negative marker so it does not contradict the
-     * separately delivered error message.
+     * Finish when the model explicitly produced no reply (NO_REPLY) or an empty
+     * final. Mark the card done but show a "no content" summary instead of the
+     * activity window, so the user understands the run finished without output.
      */
-    async fail() {
+    async noReply() {
+        this.state = "done";
+        this.noReplyResult = true;
         this.finalized = true;
         this.stopTimers();
         if (this.createPromise)
             await this.createPromise.catch(() => { });
         if (!this.messageId || this.disabled)
             return;
-        const failedText = this.opts.locale === "en"
-            ? `\u26A0\uFE0F ${this.opts.botName} stopped`
-            : `\u26A0\uFE0F ${this.opts.botName} \u6267\u884c\u4e2d\u65ad`;
-        await this.safeEdit(failedText, true);
+        await this.safeEdit(this.buildView(), true);
     }
     dispose() {
         this.finalized = true;
         this.stopTimers();
     }
+    /**
+     * Intermediate assistant text arrives as incremental fragments (each flush
+     * sends only the newly-added slice). Consecutive fragments with no tool event
+     * in between belong to the same thought, so merge them into ONE line instead
+     * of showing each fragment (or each table row) as a separate message. A tool
+     * event resets this, so the next text starts a fresh line.
+     */
+    appendText(fragment) {
+        const last = this.lines[this.lines.length - 1];
+        if (last && last.kind === "text") {
+            const merged = `${last.text} ${this.normalizeText(fragment)}`.replace(/\s+/g, " ").trim();
+            last.text = this.clip(merged);
+            return;
+        }
+        this.pushLine("text", fragment);
+    }
+    normalizeText(text) {
+        return text.replace(/\s+/g, " ").trim();
+    }
+    clip(text) {
+        const maxChars = this.opts.maxChars ?? DEFAULT_MAX_CHARS;
+        return text.length > maxChars ? `${text.slice(0, Math.max(0, maxChars - 1))}\u2026` : text;
+    }
+    pushLine(kind, text) {
+        const clean = this.normalizeText(text);
+        if (!clean)
+            return;
+        const clipped = this.clip(clean);
+        // Collapse consecutive identical lines (e.g. repeated "等待 OpenClaw").
+        const last = this.lines[this.lines.length - 1];
+        if (last && last.kind === kind && last.text === clipped)
+            return;
+        const at = Math.max(0, Math.floor((Date.now() - this.startedAt) / 1000));
+        this.lines.push({ kind, text: clipped, at });
+        const limit = this.opts.historySize ?? DEFAULT_HISTORY;
+        if (this.lines.length > limit)
+            this.lines = this.lines.slice(this.lines.length - limit);
+    }
     stopTimers() {
         if (this.createTimer) {
             clearTimeout(this.createTimer);
             this.createTimer = undefined;
         }
+        if (this.tickTimer) {
+            clearInterval(this.tickTimer);
+            this.tickTimer = undefined;
+        }
     }
     async ensureCreatedNow() {
         if (this.createTimer) {
@@ -111,45 +177,45 @@ export class LiveStatusController {
     async ensureCreated() {
         if (this.disabled || this.finalized || this.messageId)
             return;
-        const text = this.formatStatus(true);
+        const view = this.buildView();
         try {
-            const id = await this.callbacks.create(text);
+            const id = await this.callbacks.create(view);
             if (!id) {
                 this.disabled = true;
                 return;
             }
             this.messageId = id;
-            this.lastSentText = text;
+            this.lastSentSignature = this.signature(view);
+            this.startTicker();
         }
         catch (err) {
             this.disabled = true;
             this.callbacks.warn?.("live status create failed", err);
         }
     }
-    async editRunningStatus() {
-        if (!this.messageId || this.disabled || this.finalized || this.runningLimitReached)
-            return;
-        const maxEdits = this.opts.maxEdits ?? DEFAULT_MAX_EDITS;
-        const runningBudget = Math.max(0, maxEdits - 1); // reserve final edit for complete()
-        if (this.editCount >= runningBudget)
+    /** Refresh the elapsed-time footer periodically even with no new activity. */
+    startTicker() {
+        if (this.tickTimer || this.disabled || this.finalized)
             return;
-        const isLimitNotice = this.editCount === runningBudget - 1;
-        const text = isLimitNotice ? this.formatLimitNotice() : this.formatStatus();
-        const ok = await this.safeEdit(text);
-        if (ok && isLimitNotice)
-            this.runningLimitReached = true;
+        const tickMs = this.opts.tickMs ?? DEFAULT_TICK_MS;
+        this.tickTimer = setInterval(() => {
+            if (this.finalized || this.disabled || !this.messageId)
+                return;
+            void this.safeEdit(this.buildView());
+        }, tickMs);
+        this.tickTimer.unref?.();
     }
-    async safeEdit(text, force = false) {
+    async safeEdit(view, force = false) {
         if (!this.messageId || this.disabled)
             return false;
         if (!force && this.finalized)
             return false;
-        if (!force && text === this.lastSentText)
+        const sig = this.signature(view);
+        if (!force && sig === this.lastSentSignature)
             return true;
         try {
-            await this.callbacks.edit(this.messageId, text);
-            this.lastSentText = text;
-            this.editCount++;
+            await this.callbacks.edit(this.messageId, view);
+            this.lastSentSignature = sig;
             return true;
         }
         catch (err) {
@@ -159,26 +225,62 @@ export class LiveStatusController {
             return false;
         }
     }
-    formatToolStart(event) {
+    /** Dedupe key includes elapsed so the footer timer ticks even without new
+     *  activity, while identical content within the same second is still skipped. */
+    signature(view) {
+        return `${view.state}|${view.title}|${view.elapsed}|${view.lines.map((l) => `${l.kind}@${l.at}:${l.text}`).join("|")}`;
+    }
+    isNoReplyText(text) {
+        return text.trim().toUpperCase() === "NO_REPLY";
+    }
+    formatTool(event) {
         const raw = event.text || event.name || "";
-        const prefix = `${event.name} start`;
+        const prefix = `${event.name} ${event.phase}`;
         let detail = raw.startsWith(prefix) ? raw.slice(prefix.length).trim() : raw.trim();
         if (detail.startsWith(":"))
             detail = detail.slice(1).trim();
         return detail ? `${event.name}: ${detail}` : event.name;
     }
-    formatStatus(includeDisableHint = false) {
-        const maxChars = this.opts.maxChars ?? DEFAULT_MAX_CHARS;
-        const clean = (this.detail || "").replace(/\s+/g, " ").trim();
-        const clipped = clean.length > maxChars ? `${clean.slice(0, Math.max(0, maxChars - 1))}\u2026` : clean;
-        const base = !clipped
-            ? (this.opts.locale === "en" ? `${this.opts.botName} is working` : `${this.opts.botName} \u6b63\u5728\u6267\u884c`)
-            : (this.opts.locale === "en" ? `${this.opts.botName} is working: ${clipped}` : `${this.opts.botName} \u6b63\u5728\u6267\u884c\uff1a${clipped}`);
-        return includeDisableHint && this.opts.disableHint ? `${base}\n${this.opts.disableHint}` : base;
-    }
-    formatLimitNotice() {
-        return this.opts.locale === "en"
-            ? `${this.opts.botName} reached the update limit and is still running`
-            : `${this.opts.botName} \u5df2\u8fbe\u66f4\u65b0\u9650\u5236\uff0c\u6b63\u5728\u6301\u7eed\u6267\u884c\u4e2d`;
+    formatElapsed() {
+        const totalSec = Math.max(0, Math.floor((Date.now() - this.startedAt) / 1000));
+        const m = Math.floor(totalSec / 60);
+        const s = totalSec % 60;
+        return `${m}:${String(s).padStart(2, "0")}`;
+    }
+    buildView() {
+        const en = this.opts.locale === "en";
+        let title;
+        if (this.state === "done")
+            title = en ? `\u2705 ${this.opts.botName} done` : `\u2705 ${this.opts.botName} \u5df2\u5b8c\u6210`;
+        else if (this.state === "failed")
+            title = en ? `\u26A0\uFE0F ${this.opts.botName} stopped` : `\u26A0\uFE0F ${this.opts.botName} \u6267\u884c\u4e2d\u65ad`;
+        else
+            title = en ? `${this.opts.botName} is working` : `${this.opts.botName} \u6b63\u5728\u6267\u884c`;
+        // When finished, replace the recent-activity window with a run summary
+        // (total tool calls + total time) instead of the last few messages.
+        const lines = this.state === "running"
+            ? [...this.lines]
+            : [this.buildSummaryLine(en)];
+        return {
+            title,
+            lines,
+            elapsed: this.formatElapsed(),
+            model: this.opts.model,
+            state: this.state,
+        };
+    }
+    buildSummaryLine(en) {
+        const elapsed = this.formatElapsed();
+        const at = Math.max(0, Math.floor((Date.now() - this.startedAt) / 1000));
+        if (this.noReplyResult) {
+            const text = en
+                ? `Model returned no content \u00b7 ${this.toolCallCount} tool call${this.toolCallCount === 1 ? "" : "s"} \u00b7 ${elapsed}`
+                : `\u6a21\u578b\u6ca1\u6709\u56de\u590d\u5185\u5bb9 \u00b7 \u5171\u8c03\u7528\u5de5\u5177 ${this.toolCallCount} \u6b21 \u00b7 \u8017\u65f6 ${elapsed}`;
+            return { kind: "summary", text, at };
+        }
+        const text = en
+            ? `${this.toolCallCount} tool call${this.toolCallCount === 1 ? "" : "s"} \u00b7 ${elapsed}`
+            : `\u5171\u8c03\u7528\u5de5\u5177 ${this.toolCallCount} \u6b21 \u00b7 \u8017\u65f6 ${elapsed}`;
+        return { kind: "summary", text, at };
     }
 }

package/dist/message-store.d.ts

@@ -70,6 +70,12 @@ export declare class MessageStore {
     enqueueDelivery(item: Omit<DeliveryOutboxItem, "id" | "status" | "attempts" | "createdAt" | "updatedAt">): number | null;
     getDeliveryBySource(sessionKey: string, sourceType: string, sourceId: string): DeliveryOutboxItem | null;
     getPendingDeliveries(chatId?: string, botName?: string, maxCount?: number): DeliveryOutboxItem[];
+    markBotSeenInChat(botName: string, chatId: string): void;
+    hasBotSeenInChat(botName: string, chatId: string): boolean;
+    markBotUnavailableInChat(botName: string, chatId: string, reason?: string): void;
+    clearBotUnavailableInChat(botName: string, chatId: string): void;
+    isBotUnavailableInChat(botName: string, chatId: string): boolean;
+    hasAnyDeliveredToChat(botName: string, chatId: string): boolean;
     hasRecentSimilarDelivery(botName: string, chatId: string, contentHash: string, windowMs: number, sourceTypes?: string[]): boolean;
     hasRecentOverlappingDelivery(botName: string, chatId: string, content: string, attachmentsJson: string, windowMs: number, minShortLength?: number, sourceTypes?: string[]): boolean;
     resetStaleDeliveries(botName: string, staleMs: number, maxAttempts: number): {

package/dist/message-store.js

@@ -111,6 +111,27 @@ export class MessageStore {
         PRIMARY KEY (bot_name, chat_id)
       );
 
+      -- Durable positive membership signal. Feishu does not reliably expose bot
+      -- members via chat_members, so receiving an event in a chat is the strongest
+      -- proof that this bot app is actually installed in that group.
+      CREATE TABLE IF NOT EXISTS bot_chat_seen (
+        bot_name TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (bot_name, chat_id)
+      );
+
+      -- Durable negative membership cache. Feishu message create returns 230002
+      -- when a bot app is not in a chat; cache that so discussion scheduling and
+      -- later proactive deliveries do not keep generating ghost participants.
+      CREATE TABLE IF NOT EXISTS bot_chat_unavailable (
+        bot_name TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        reason TEXT NOT NULL DEFAULT '',
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (bot_name, chat_id)
+      );
+
       -- Durable delivery ledger for user-visible assistant outputs. All final
       -- text/attachment outputs should be inserted here first and dispatched
       -- once, regardless of whether they came from chat final, proactive
@@ -409,6 +430,42 @@ export class MessageStore {
     `).all(maxCount);
         return rows.map((r) => this.mapDelivery(r));
     }
+    markBotSeenInChat(botName, chatId) {
+        this.db.prepare(`
+      INSERT INTO bot_chat_seen(bot_name, chat_id, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(bot_name, chat_id) DO UPDATE SET updated_at = excluded.updated_at
+    `).run(botName, chatId, Date.now());
+        // If the bot is receiving events from this chat again, it is no longer out
+        // of the chat. This recovers automatically when a bot is re-added to a group.
+        this.clearBotUnavailableInChat(botName, chatId);
+    }
+    hasBotSeenInChat(botName, chatId) {
+        const row = this.db.prepare(`SELECT 1 FROM bot_chat_seen WHERE bot_name = ? AND chat_id = ? LIMIT 1`).get(botName, chatId);
+        return !!row;
+    }
+    markBotUnavailableInChat(botName, chatId, reason = '') {
+        this.db.prepare(`
+      INSERT INTO bot_chat_unavailable(bot_name, chat_id, reason, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(bot_name, chat_id) DO UPDATE SET reason = excluded.reason, updated_at = excluded.updated_at
+    `).run(botName, chatId, reason, Date.now());
+    }
+    clearBotUnavailableInChat(botName, chatId) {
+        this.db.prepare(`DELETE FROM bot_chat_unavailable WHERE bot_name = ? AND chat_id = ?`).run(botName, chatId);
+    }
+    isBotUnavailableInChat(botName, chatId) {
+        const row = this.db.prepare(`SELECT 1 FROM bot_chat_unavailable WHERE bot_name = ? AND chat_id = ? LIMIT 1`).get(botName, chatId);
+        return !!row;
+    }
+    hasAnyDeliveredToChat(botName, chatId) {
+        const row = this.db.prepare(`
+      SELECT 1 FROM delivery_outbox
+      WHERE bot_name = ? AND chat_id = ? AND status = 'delivered'
+      LIMIT 1
+    `).get(botName, chatId);
+        return !!row;
+    }
     hasRecentSimilarDelivery(botName, chatId, contentHash, windowMs, sourceTypes) {
         if (!contentHash)
             return false;

package/dist/openclaw-client.d.ts

@@ -90,6 +90,15 @@ export declare class OpenClawClient {
      * 30-minute safety net only for catastrophic WS disconnection.
      */
     private collectReply;
+    /**
+     * Recoverable agent errors are lifecycle errors that OpenClaw can self-heal
+     * (it auto-compacts and keeps running the same run, then emits a real final).
+     * For these we must not reject collectReply immediately, or the bridge reports
+     * "没有完成回复" while the agent is still working. Currently this covers
+     * context-overflow / prompt-too-large, which OpenClaw recovers from via its
+     * context-overflow-recovery + auto-compaction path.
+     */
+    private isRecoverableAgentError;
     private pickBestCollectedText;
     createSession(params: {
         key: string;

package/dist/openclaw-client.js

@@ -810,13 +810,29 @@ export class OpenClawClient {
                             return;
                         }
                         if (ev.stream === "lifecycle" && ev.data?.phase === "error") {
+                            const errText = String(ev.data?.error || "unknown");
+                            // Some agent errors are recoverable: OpenClaw emits a lifecycle
+                            // error (e.g. "Context overflow: prompt too large") and then
+                            // auto-compacts and KEEPS RUNNING the same run, eventually emitting
+                            // a real final. If we reject immediately the user sees a scary
+                            // "没有完成回复" while the agent is in fact still working. So for
+                            // recoverable errors we defer: record the failure text and keep
+                            // waiting. Subsequent delta/item events reset the idle timer, so a
+                            // real final wins; if the run truly stalls, the idle timeout falls
+                            // back to this text.
+                            if (this.isRecoverableAgentError(errText)) {
+                                pendingRuntimeFailureText = `⚠️ Agent 未正常完成\n原因: ${errText}`;
+                                resetIdleTimer();
+                                console.warn(`[OpenClaw] recoverable lifecycle error for runId=${evRunId || runId}; deferring (agent may auto-recover): ${errText.slice(0, 120)}`);
+                                return;
+                            }
                             clearTimeout(idleTimer);
                             clearInterval(poller);
                             if (chatFinalTimer)
                                 clearTimeout(chatFinalTimer);
                             if (lifecycleEndTimer)
                                 clearTimeout(lifecycleEndTimer);
-                            reject(new Error(`Agent error: ${ev.data?.error || "unknown"}`));
+                            reject(new Error(`Agent error: ${errText}`));
                             return;
                         }
                     }
@@ -824,6 +840,22 @@ export class OpenClawClient {
             }, 50);
         });
     }
+    /**
+     * Recoverable agent errors are lifecycle errors that OpenClaw can self-heal
+     * (it auto-compacts and keeps running the same run, then emits a real final).
+     * For these we must not reject collectReply immediately, or the bridge reports
+     * "没有完成回复" while the agent is still working. Currently this covers
+     * context-overflow / prompt-too-large, which OpenClaw recovers from via its
+     * context-overflow-recovery + auto-compaction path.
+     */
+    isRecoverableAgentError(errText) {
+        const t = (errText || "").toLowerCase();
+        return t.includes("context overflow")
+            || t.includes("prompt too large")
+            || t.includes("context length")
+            || t.includes("too many tokens")
+            || t.includes("maximum context");
+    }
     pickBestCollectedText(chatFinalText, assistantText, chatDeltaText, transcriptAssistantText) {
         if (chatFinalText)
             return chatFinalText;

package/package.json

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