openclaw-lark-multi-agent 1.0.22 → 1.0.23

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,14 @@ export declare class FeishuBot {
      */
     private resolveChairmanTargets;
     private isDiscussionCoordinator;
+    private static markBotSeenInChat;
+    private markCurrentBotSeenInChat;
+    private isBotAvailableInChat;
     private getDiscussionParticipants;
     private getChairmanParticipant;
     private asDiscussionParticipant;
     private runDiscussionTurn;
+    private sendTextMessage;
     private replyTextMessage;
     private editTextMessage;
     private deleteMessageById;
@@ -137,6 +158,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;
@@ -1140,6 +1191,9 @@ export class FeishuBot {
                     })
                     : 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,
@@ -1259,6 +1313,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,7 +1338,7 @@ export class FeishuBot {
                     }
                 }
                 if (isRuntimeFailure && lastHuman.messageId) {
-                    liveStatus?.dispose();
+                    await liveStatus?.fail().catch(() => { });
                     this.scheduleDelayedFailure(chatId, lastHuman.messageId, visibleReply, triggerId);
                 }
                 else if (!shouldReply && !hasAttachments) {
@@ -1604,6 +1659,10 @@ export class FeishuBot {
     deliverySourceId(kind, text) {
         return `${kind}:${this.stableHash(text)}`;
     }
+    async sendSystemDelivery(chatId, text) {
+        const sourceId = `discussion-system:${Date.now()}:${Math.random().toString(36).slice(2)}`;
+        await this.enqueueAndDispatchDelivery(chatId, "discussion_system", sourceId, text);
+    }
     async enqueueAndDispatchDelivery(chatId, sourceType, sourceId, text, attachments = [], replyToMessageId, deliveryKey) {
         if (!text.trim() && attachments.length === 0)
             return;
@@ -1672,6 +1731,8 @@ export class FeishuBot {
                         this.store.markDeliveryDelivered(item.id);
                 }
                 catch (err) {
+                    if (this.isOutOfChatError(err))
+                        this.markCurrentBotUnavailable(chatId, err);
                     if (item.id)
                         this.store.markDeliveryFailed(item.id);
                     const errorText = `⚠️ 附件发送失败：${this.errorSummary(err)}`;
@@ -1749,17 +1810,42 @@ export class FeishuBot {
             return true;
         return bots[0] === this;
     }
+    static markBotSeenInChat(botName, chatId) {
+        let set = FeishuBot.seenBotChats.get(botName);
+        if (!set) {
+            set = new Set();
+            FeishuBot.seenBotChats.set(botName, set);
+        }
+        set.add(chatId);
+    }
+    markCurrentBotSeenInChat(chatId) {
+        FeishuBot.markBotSeenInChat(this.config.name, chatId);
+        this.store.markBotSeenInChat(this.config.name, chatId);
+    }
+    isBotAvailableInChat(bot, chatId) {
+        // A bot can be globally configured but not actually installed in this Feishu
+        // group. Discuss participants must be restricted to bots that either have
+        // received an event in this chat during this process, or have previously
+        // delivered a message successfully in this chat. Otherwise LMA may generate
+        // "ghost" participants and Feishu will reject delivery with 230002
+        // (Bot/User can NOT be out of the chat).
+        if (this.store.isBotUnavailableInChat(bot.config.name, chatId))
+            return false;
+        return FeishuBot.seenBotChats.get(bot.config.name)?.has(chatId)
+            || this.store.hasBotSeenInChat(bot.config.name, chatId)
+            || this.store.hasAnyDeliveredToChat(bot.config.name, chatId);
+    }
     getDiscussionParticipants(chatId) {
         const chairman = this.store.getChairmanBot(chatId);
         return Array.from(FeishuBot.allBots.values())
-            .filter((bot) => bot.store === this.store && bot.config.name !== chairman && bot.store.getBotMode(bot.config.name, chatId) !== "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 +1857,21 @@ export class FeishuBot {
     async runDiscussionTurn(chatId, prompt, meta) {
         const sessionKey = await this.ensureSession(chatId);
         const releaseProactiveMute = this.openclawClient.muteProactiveDelivery(sessionKey);
+        const liveStatusEnabled = this.store.getBotLiveStatus(this.config.name, chatId) && !this.store.getBotVerbose(this.config.name, chatId);
+        const liveStatus = liveStatusEnabled
+            ? new LiveStatusController({
+                create: (text) => this.sendOrdered(chatId, () => this.sendTextMessage(chatId, text)),
+                edit: (messageId, text) => this.sendOrdered(chatId, () => this.editTextMessage(messageId, text)),
+                warn: (message, err) => console.warn(`[${this.config.name}] ${message}:`, err instanceof Error ? err.message : err),
+            }, {
+                botName: this.config.name,
+                locale: this.isEn(chatId) ? "en" : "zh",
+                disableHint: this.isEn(chatId)
+                    ? `Tip: send /livestatus off to hide this status message`
+                    : `提示：调用 /livestatus off 关闭该状态提示`,
+            })
+            : undefined;
+        liveStatus?.start(meta ? `第 ${meta.round}/${meta.maxRounds} 轮讨论` : "讨论中");
         let reply;
         try {
             reply = await this.openclawClient.chatSendWithContext({
@@ -1781,8 +1882,13 @@ export class FeishuBot {
                 deliver: false,
                 timeoutMs: 1_800_000,
                 emptyFinalAsNoReply: true,
+                onProgress: (event) => { void liveStatus?.progress(event).catch((err) => console.warn(`[${this.config.name}] live status progress failed:`, err instanceof Error ? err.message : err)); },
             });
         }
+        catch (err) {
+            await liveStatus?.fail().catch(() => { });
+            throw err;
+        }
         finally {
             // OpenClaw can emit the final assistant session.message shortly after
             // chatSend/collectReply returns. Keep discussion proactive muted briefly;
@@ -1815,10 +1921,36 @@ export class FeishuBot {
                 content: storedContent,
                 timestamp: Date.now(),
             });
-            await this.enqueueAndDispatchDelivery(chatId, "discussion", `discussion:${Date.now()}:${Math.random().toString(36).slice(2)}`, isVisible ? displayReply : "", parsedReply.attachments);
+            try {
+                await this.enqueueAndDispatchDelivery(chatId, "discussion", `discussion:${Date.now()}:${Math.random().toString(36).slice(2)}`, isVisible ? displayReply : "", parsedReply.attachments);
+            }
+            catch (err) {
+                await liveStatus?.fail().catch(() => { });
+                throw err;
+            }
         }
+        await liveStatus?.complete().catch(() => { });
         return { botName: this.config.name, text: cleanVisibleReply, visible: isVisible };
     }
+    async sendTextMessage(chatId, text) {
+        try {
+            const res = await this.client.im.message.create({
+                params: { receive_id_type: "chat_id" },
+                data: {
+                    receive_id: chatId,
+                    content: JSON.stringify({ text }),
+                    msg_type: "text",
+                },
+            });
+            this.store.clearBotUnavailableInChat(this.config.name, chatId);
+            return res?.data?.message_id || res?.message_id;
+        }
+        catch (err) {
+            if (this.isOutOfChatError(err))
+                this.markCurrentBotUnavailable(chatId, err);
+            throw err;
+        }
+    }
     async replyTextMessage(messageId, text) {
         const res = await this.client.im.message.reply({
             path: { message_id: messageId },
@@ -1868,7 +2000,11 @@ export class FeishuBot {
     }
     extractBridgeAttachments(reply) {
         const attachments = [];
-        const markerPattern = /<LMA_BRIDGE_ATTACHMENTS>([\s\S]*?)<\/LMA_BRIDGE_ATTACHMENTS>/g;
+        // Some models occasionally corrupt the closing tag from
+        // </LMA_BRIDGE_ATTACHMENTS> to </parameter> while preserving the exact JSON
+        // payload. Treat that as a recoverable marker shape; otherwise the whole
+        // marker leaks as user-visible text and attachments are not sent.
+        const markerPattern = /<LMA_BRIDGE_ATTACHMENTS>([\s\S]*?)(?:<\/LMA_BRIDGE_ATTACHMENTS>|<\/parameter>)/g;
         let text = reply.replace(markerPattern, (_match, jsonText) => {
             try {
                 const parsed = JSON.parse(String(jsonText).trim());
@@ -1938,6 +2074,16 @@ export class FeishuBot {
         const msg = data?.msg || data?.message || err?.message || String(err);
         return `${code}${msg}`.slice(0, 800);
     }
+    isOutOfChatError(err) {
+        const data = err?.response?.data || err?.data;
+        const code = data?.code;
+        const msg = data?.msg || data?.message || err?.message || String(err);
+        return Number(code) === 230002 || /Bot\/User can NOT be out of the chat/i.test(String(msg));
+    }
+    markCurrentBotUnavailable(chatId, err) {
+        this.store.markBotUnavailableInChat(this.config.name, chatId, this.errorSummary(err));
+        console.warn(`[${this.config.name}] Marked unavailable in chat ${chatId.slice(-8)} after Feishu out-of-chat error`);
+    }
     stripReadOnlyDocxFields(value) {
         if (Array.isArray(value))
             return value.map((item) => this.stripReadOnlyDocxFields(item));
@@ -2052,10 +2198,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 +2215,13 @@ export class FeishuBot {
                         msg_type: "text",
                     },
                 });
+                this.store.clearBotUnavailableInChat(this.config.name, chatId);
                 return res?.data?.message_id || res?.message_id;
             }
             catch (fallbackErr) {
                 console.warn(`[${this.config.name}] sendMessage text failed:`, JSON.stringify(fallbackErr?.response?.data || fallbackErr?.data || { message: fallbackErr.message }));
+                if (this.isOutOfChatError(fallbackErr))
+                    this.markCurrentBotUnavailable(chatId, fallbackErr);
                 throw fallbackErr;
             }
         }

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/package.json

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