openclaw-lark-multi-agent 0.1.14 → 1.0.0

package/README.md

@@ -32,10 +32,13 @@ All of them connect to the same OpenClaw Gateway while keeping sessions, queues,
 - Local SQLite message store for context, trigger tracking, and duplicate prevention
 - `pending_triggers` queue so restart recovery does not replay every context message
 - `delivered_replies` table so one trigger message gets at most one delivered reply per bot
+- Durable delivery outbox for assistant-visible output, with stable delivery keys, atomic claim-before-send dispatch, and short-window duplicate suppression
+- Message recall handling: recalled queued/pending user messages are removed before they reach OpenClaw and excluded from future context
 - Feishu image download and OpenClaw multimodal attachment forwarding
 - Bridge attachment marker protocol for generated files/images/documents
 - Feishu CardKit v2 Markdown rendering, including native table elements for pipe tables
 - Bridge-level slash commands and escaped OpenClaw slash commands
+- `/discuss` mode for barrier-style multi-bot group discussion, including per-round markers and no-reply status notices
 - Linux systemd installer with separate runtime and state directories
 
 ## Architecture
@@ -228,6 +231,7 @@ Bridge-level commands use a single slash and are handled by this project:
 - `/free` — toggle this bot's Free mode in the current group chat
 - `/mute` — toggle this bot's mute mode in the current group chat
 - `/mode` — show this bot's current mode in the current chat
+- `/discuss on|off|status|stop|rounds N` — control group-level multi-bot discussion mode
 
 OpenClaw-level slash commands can be sent by escaping with a double slash:
 
@@ -294,7 +298,54 @@ the mention-only message is treated as a trigger and is combined with the previo
 
 Bot messages do not trigger other bots unless they mention them. The anti-loop guard is counted per bot per chat: other bots' replies do not consume the current bot's streak budget, and a human message resets the streak.
 
-`/free` is not a full multi-agent discussion scheduler. Notes for a future explicit `/discuss` mode live in [`docs/ideas/discussion-mode.md`](docs/ideas/discussion-mode.md).
+### `/discuss` mode
+
+`/discuss` is an explicit group-level multi-agent discussion scheduler. It is separate from Free mode:
+
+- `/free` controls whether a single bot may answer plain human messages.
+- `/discuss on` lets one coordinator take over plain human messages and run all Free-mode bots in barrier-style rounds.
+- Targeted mentions still fall through to normal routing, so `@GPT hello` works even while discuss mode is enabled.
+- Each participant receives the same round prompt and does not see other participants' replies from the current round until the next round.
+- Each visible discussion reply is annotated with a round marker such as `—— 第 2/3 轮 · Claude`.
+- If some participants return `NO_REPLY` or an empty reply, the coordinator sends a lightweight status notice such as `💬 第 3/3 轮：Qwen、Gemini 无新增回复`.
+- When the configured maximum round count is reached, the coordinator sends a completion notice.
+
+Commands:
+
+```text
+/discuss on
+/discuss off
+/discuss status
+/discuss stop
+/discuss rounds 3
+```
+
+## Delivery outbox and duplicate prevention
+
+All user-visible assistant outputs go through the local `delivery_outbox` before being sent to Feishu. This includes normal chat final replies, proactive `session.message` replies, delayed runtime-error notices, provider-error notices, discussion replies, and attachment marker deliveries.
+
+The outbox provides several protections:
+
+- stable trigger-based delivery keys such as `trigger:<message_row_id>`;
+- `UNIQUE(bot_name, chat_id, delivery_key)` to prevent duplicate deliveries for the same logical output;
+- `pending -> delivering -> delivered/failed` claim-before-send dispatch to avoid concurrent resend races;
+- short-window content-hash dedupe for proactive-only outputs;
+- short-window containment dedupe for cases where `chat final` contains an intermediate note plus final answer while proactive contains only the final answer;
+- attachment-aware dedupe so file/image/document deliveries are not accidentally collapsed with text-only replies.
+
+This keeps normal replies, subagent/proactive completions, discussion messages, delayed runtime failures, provider errors, and generated attachments on one consistent delivery path.
+
+## Message recall
+
+The bridge subscribes to Feishu `im.message.recalled_v1` events. When a user recalls a message that is still pending or queued:
+
+1. the original message remains in the local `messages` ledger for audit;
+2. the message is recorded in `recalled_messages`;
+3. matching `pending_triggers` for each bot are removed;
+4. pending local reaction acknowledgements are removed;
+5. future context sync excludes the recalled message.
+
+Version 1 behavior intentionally does **not** abort an OpenClaw run that has already started processing the recalled message, and it does not recall bot replies that were already sent. The first goal is to make recall reliable for queued/not-yet-processed messages.
 
 
 ## Markdown, tables, and attachments
@@ -316,6 +367,8 @@ SQLite state lives in the configured data directory. Important tables:
 - `sync_state` — per-bot/per-chat sync cursor
 - `pending_triggers` — messages that should actively trigger a bot run
 - `delivered_replies` — delivered response markers for idempotency
+- `delivery_outbox` — durable user-visible delivery ledger with claim/dedupe state
+- `recalled_messages` — recalled user messages excluded from pending work and future context
 - `processed_events` — Feishu event de-duplication
 - `bot_chat_settings` — per-bot/per-chat settings such as verbose mode
 

package/README.zh-CN.md

@@ -32,10 +32,13 @@ Lark/飞书里每个机器人都有自己的 App 身份，但 OpenClaw 通常在
 - 本地 SQLite 消息存储，用于上下文、触发队列和重复投递防护
 - `pending_triggers` 队列，避免重启后把所有历史上下文都重新发给 OpenClaw
 - `delivered_replies` 表，保证同一个触发消息每个 bot 最多投递一次回复
+- 持久化 delivery outbox：所有用户可见输出先入库，再通过稳定 key、原子 claim 和短窗口去重后投递
+- 消息撤回处理：已撤回且仍在排队/待处理的用户消息会从 pending 队列移除，并从后续上下文中排除
 - 支持飞书图片下载，并以 OpenClaw multimodal attachment 形式转发
 - Bridge attachment marker 协议，用于发送生成的文件、图片和文档
 - Feishu CardKit v2 Markdown 渲染，并把 pipe table 转成原生 table 组件
 - 桥接层 slash command + 转义后的 OpenClaw slash command
+- `/discuss` 多 bot 结构化讨论模式，支持轮次标注和无新增回复提示
 - Linux systemd 安装脚本，运行产物和状态目录分离
 
 ## 架构
@@ -228,6 +231,7 @@ openclaw-lark-multi-agent install-windows-service
 - `/free` — 开关当前 bot 在当前群聊里的 Free 模式
 - `/mute` — 开关当前 bot 在当前群聊里的 mute 模式
 - `/mode` — 查看当前 bot 在当前聊天里的模式
+- `/discuss on|off|status|stop|rounds N` — 控制群级多 bot 讨论模式
 
 如果你想把 slash command 直接发给 OpenClaw，可以用双斜杠转义：
 
@@ -294,8 +298,55 @@ Free 模式是 per-bot 且保守的：
 
 bot 发出的消息默认不会触发其他 bot，除非明确 @。anti-loop 防护按 bot + chat 单独计算：其他 bot 的发言不会消耗当前 bot 的额度，人类发言会重置计数。
 
-`/free` 不是完整的多 Agent 讨论调度器。未来独立 `/discuss` 模式的设计草案在 [`docs/ideas/discussion-mode.md`](docs/ideas/discussion-mode.md)。
 
+## `/discuss` 讨论模式
+
+`/discuss` 是显式的群级多智能体讨论调度器，和 Free 模式分工不同：
+
+- `/free` 控制单个 bot 是否可以响应普通人类消息。
+- `/discuss on` 让一个 coordinator 接管普通人类消息，并按 barrier-style round 调度所有 Free 模式 bot。
+- 定向 @ 仍然走普通路由，所以 discuss 开启时 `@GPT hello` 仍会只触发 GPT。
+- 每个参与 bot 在同一轮拿到相同 prompt，本轮内看不到其他 bot 的回复，下一轮才会看到上一轮结果。
+- 每条可见讨论回复会自动追加轮次标注，例如 `—— 第 2/3 轮 · Claude`。
+- 如果某些 bot 返回 `NO_REPLY` 或空回复，coordinator 会发送轻量提示，例如 `💬 第 3/3 轮：Qwen、Gemini 无新增回复`。
+- 达到配置轮数后，coordinator 会发送讨论完成提示。
+
+命令：
+
+```text
+/discuss on
+/discuss off
+/discuss status
+/discuss stop
+/discuss rounds 3
+```
+
+## Delivery outbox 与重复投递防护
+
+所有用户可见 assistant 输出都会先进入本地 `delivery_outbox`，再统一投递到飞书。覆盖普通 chat final、proactive `session.message`、延迟 runtime error、provider error、discussion 回复和附件 marker。
+
+outbox 提供：
+
+- 稳定 trigger key，例如 `trigger:<message_row_id>`；
+- `UNIQUE(bot_name, chat_id, delivery_key)` 防止同一逻辑输出重复投递；
+- `pending -> delivering -> delivered/failed` 原子 claim，避免并发重复发送；
+- proactive-only 输出的短窗口 content hash 去重；
+- chat final 包含“中间说明 + 最终答案”、proactive 只包含“最终答案”时的短窗口包含关系去重；
+- 附件感知去重，避免把带文件/图片/文档的输出和纯文本误合并。
+
+这样普通回复、subagent/proactive 回传、讨论消息、延迟错误、provider 错误和生成附件都走同一条可靠投递链路。
+
+## 消息撤回
+
+桥接层订阅飞书 `im.message.recalled_v1` 事件。用户撤回一条仍在 pending/排队中的消息时：
+
+1. 原始消息仍保留在 `messages` 表，便于审计；
+2. 撤回记录写入 `recalled_messages`；
+3. 删除各 bot 对应的 `pending_triggers`；
+4. 移除本地 pending reaction ack；
+5. 后续同步上下文时排除这条撤回消息。
+
+v1 行为边界：如果消息已经进入 OpenClaw 正在处理，暂不 abort；如果 bot 回复已经发出，也不自动撤回 bot 回复。第一版目标是可靠取消“尚未处理/排队中”的撤回消息。
 
 ## Markdown、表格和附件
 

package/dist/discussion-manager.js

@@ -92,10 +92,27 @@ export class DiscussionManager {
                 replies[value.botName] = value.error ? `[ERROR] ${value.error}` : value.text.trim();
             }
             current.completedRounds.push({ round: current.currentRound, replies });
+            const noReplyNames = participants
+                .map((participant) => participant.name)
+                .filter((name) => {
+                const text = (replies[name] || "").trim();
+                return !text || text.toUpperCase() === "NO_REPLY";
+            });
+            const errorNames = participants
+                .map((participant) => participant.name)
+                .filter((name) => (replies[name] || "").trim().startsWith("[ERROR]"));
             const allNoReply = participants.every((participant) => {
                 const text = (replies[participant.name] || "").trim();
                 return !text || text.toUpperCase() === "NO_REPLY" || text.startsWith("[ERROR]");
             });
+            if (sendSystemMessage && !allNoReply && (noReplyNames.length > 0 || errorNames.length > 0)) {
+                const parts = [];
+                if (noReplyNames.length > 0)
+                    parts.push(`${noReplyNames.join("、")} 无新增回复`);
+                if (errorNames.length > 0)
+                    parts.push(`${errorNames.join("、")} 出错`);
+                await sendSystemMessage(`💬 第 ${current.currentRound}/${current.maxRounds} 轮：${parts.join("；")}`).catch(() => { });
+            }
             if (allNoReply) {
                 current.status = "completed";
                 this.sessions.delete(current.chatId);

package/dist/feishu-bot.d.ts

@@ -34,6 +34,7 @@ export declare class FeishuBot {
     private adminOpenId;
     private static allBots;
     constructor(config: BotConfig, openclawClient: OpenClawClient, store: MessageStore, adminOpenId?: string);
+    private handleMessageRecalled;
     register(): void;
     /**
      * Get the session key for a specific chat.

package/dist/feishu-bot.js

@@ -56,8 +56,33 @@ export class FeishuBot {
         });
         this.eventDispatcher = new lark.EventDispatcher({}).register({
             "im.message.receive_v1": this.handleMessage.bind(this),
+            "im.message.recalled_v1": this.handleMessageRecalled.bind(this),
         });
     }
+    async handleMessageRecalled(data) {
+        console.log(`[${this.config.name}] Message recalled event:`, JSON.stringify(data));
+        const messageId = data?.message_id;
+        const chatId = data?.chat_id;
+        if (!messageId || !chatId)
+            return;
+        const rowId = this.store.getMessageId(messageId);
+        this.store.markMessageRecalled(messageId, chatId, Number(data?.recall_time) || Date.now(), data?.recall_type || '');
+        if (!rowId)
+            return;
+        this.store.clearPendingTrigger(this.config.name, chatId, rowId);
+        const pendingAcks = this.pendingAckMessages.get(chatId) || [];
+        const remainingAcks = [];
+        for (const ack of pendingAcks) {
+            if (ack.rowId === rowId) {
+                await this.removeReaction(ack.messageId, ack.emoji).catch(() => { });
+            }
+            else {
+                remainingAcks.push(ack);
+            }
+        }
+        this.pendingAckMessages.set(chatId, remainingAcks);
+        console.log(`[${this.config.name}] Recalled message ${messageId} row=${rowId}; pending trigger canceled if present`);
+    }
     register() {
         FeishuBot.allBots.set(this.config.appId, this);
     }
@@ -503,6 +528,8 @@ export class FeishuBot {
             }
             // --- Discuss mode: group-level multi-bot round scheduler. It takes over
             // plain human messages so normal Free mode does not duplicate Round 1.
+            // Targeted mentions must fall through to normal routing so @GPT still
+            // works while discuss mode is enabled.
             if (chatType !== "p2p" && !isBot && this.store.getChatInfo(chatId)?.discuss) {
                 const mentions = message.mentions || [];
                 const hasTargetedMention = mentions.some((m) => !this.isAllMentionItem(m));
@@ -924,11 +951,16 @@ export class FeishuBot {
     async enqueueAndDispatchDelivery(chatId, sourceType, sourceId, text, attachments = [], replyToMessageId, deliveryKey) {
         if (!text.trim() && attachments.length === 0)
             return;
-        const normalizedPayload = `${text.trim()}|${JSON.stringify(attachments)}`;
+        const attachmentsJson = JSON.stringify(attachments);
+        const normalizedPayload = `${text.trim()}|${attachmentsJson}`;
         const contentHash = this.stableHash(normalizedPayload);
         const finalDeliveryKey = deliveryKey || sourceId;
-        if (!deliveryKey && this.store.hasRecentSimilarDelivery(this.config.name, chatId, contentHash, 60_000))
-            return;
+        if (!deliveryKey) {
+            if (this.store.hasRecentSimilarDelivery(this.config.name, chatId, contentHash, 60_000))
+                return;
+            if (this.store.hasRecentOverlappingDelivery(this.config.name, chatId, text, attachmentsJson, 60_000, 8))
+                return;
+        }
         const deliveryId = this.store.enqueueDelivery({
             sessionKey: this.deliverySessionKey(chatId),
             chatId,
@@ -938,7 +970,7 @@ export class FeishuBot {
             deliveryKey: finalDeliveryKey,
             contentHash,
             content: text,
-            attachmentsJson: JSON.stringify(attachments),
+            attachmentsJson,
             replyToMessageId: replyToMessageId || "",
         });
         if (deliveryId === null)
@@ -998,22 +1030,36 @@ export class FeishuBot {
     }
     async runDiscussionTurn(chatId, prompt, meta) {
         const sessionKey = await this.ensureSession(chatId);
-        const reply = await this.openclawClient.chatSendWithContext({
-            sessionKey,
-            unsyncedMessages: [],
-            currentMessage: prompt,
-            currentSenderName: "Discussion Scheduler",
-            deliver: false,
-            timeoutMs: 1_800_000,
-        });
+        const releaseProactiveMute = this.openclawClient.muteProactiveDelivery(sessionKey);
+        let reply;
+        try {
+            reply = await this.openclawClient.chatSendWithContext({
+                sessionKey,
+                unsyncedMessages: [],
+                currentMessage: prompt,
+                currentSenderName: "Discussion Scheduler",
+                deliver: false,
+                timeoutMs: 1_800_000,
+            });
+        }
+        finally {
+            // OpenClaw can emit the final assistant session.message shortly after
+            // chatSend/collectReply returns. Keep discussion proactive muted briefly;
+            // the discussion coordinator already owns user-visible delivery.
+            releaseProactiveMute(120_000);
+        }
         const parsedReply = this.extractBridgeAttachments(reply);
-        let visibleReply = parsedReply.text.trim();
-        const isVisible = visibleReply.length > 0 && visibleReply.toUpperCase() !== "NO_REPLY";
+        const rawVisibleReply = parsedReply.text.trim();
+        const discussionMarkerPattern = /\n*—— 第 \d+\/\d+ 轮 · .+$/;
+        const cleanVisibleReply = rawVisibleReply.replace(discussionMarkerPattern, "").trim();
+        let displayReply = cleanVisibleReply;
+        const isVisible = cleanVisibleReply.length > 0 && cleanVisibleReply.toUpperCase() !== "NO_REPLY";
         if (isVisible && meta) {
-            visibleReply = `${visibleReply}\n\n—— 第 ${meta.round}/${meta.maxRounds} 轮 · ${this.config.name}`;
+            const roundMarker = `—— 第 ${meta.round}/${meta.maxRounds} 轮 · ${this.config.name}`;
+            displayReply = `${displayReply}\n\n${roundMarker}`;
         }
         if (isVisible || parsedReply.attachments.length > 0) {
-            const storedContent = [visibleReply, ...parsedReply.attachments.map((a) => `[Attachment: ${a.type || "file"} ${a.path}]`)]
+            const storedContent = [displayReply, ...parsedReply.attachments.map((a) => `[Attachment: ${a.type || "file"} ${a.path}]`)]
                 .filter(Boolean)
                 .join("\n");
             this.store.insert({
@@ -1024,9 +1070,9 @@ export class FeishuBot {
                 content: storedContent,
                 timestamp: Date.now(),
             });
-            await this.enqueueAndDispatchDelivery(chatId, "discussion", `discussion:${Date.now()}:${Math.random().toString(36).slice(2)}`, isVisible ? visibleReply : "", parsedReply.attachments);
+            await this.enqueueAndDispatchDelivery(chatId, "discussion", `discussion:${Date.now()}:${Math.random().toString(36).slice(2)}`, isVisible ? displayReply : "", parsedReply.attachments);
         }
-        return { botName: this.config.name, text: visibleReply, visible: isVisible };
+        return { botName: this.config.name, text: cleanVisibleReply, visible: isVisible };
     }
     async replyMessage(messageId, text) {
         // Use Feishu CardKit v2 markdown component for full Markdown rendering.

package/dist/message-store.d.ts

@@ -51,6 +51,8 @@ export declare class MessageStore {
      */
     insert(msg: ChatMessage): number;
     getMessageId(messageId: string): number | null;
+    markMessageRecalled(messageId: string, chatId: string, recalledAt?: number, recallType?: string): void;
+    isMessageRecalled(messageId: string): boolean;
     markPendingTrigger(botName: string, chatId: string, messageRowId: number): void;
     getPendingTriggerIds(botName: string, chatId: string): Set<number>;
     clearPendingTriggers(botName: string, chatId: string, upToId: number): void;
@@ -61,6 +63,7 @@ export declare class MessageStore {
     getDeliveryBySource(sessionKey: string, sourceType: string, sourceId: string): DeliveryOutboxItem | null;
     getPendingDeliveries(chatId?: string, botName?: string, maxCount?: number): DeliveryOutboxItem[];
     hasRecentSimilarDelivery(botName: string, chatId: string, contentHash: string, windowMs: number): boolean;
+    hasRecentOverlappingDelivery(botName: string, chatId: string, content: string, attachmentsJson: string, windowMs: number, minShortLength?: number): boolean;
     claimDelivery(id: number): boolean;
     markDeliveryDelivered(id: number): void;
     markDeliveryFailed(id: number): void;

package/dist/message-store.js

@@ -51,6 +51,16 @@ export class MessageStore {
         PRIMARY KEY (bot_name, message_id)
       );
 
+      -- Tracks recalled human messages. Recalled messages are kept in the raw
+      -- message ledger for audit, but excluded from future OpenClaw context and
+      -- pending trigger processing.
+      CREATE TABLE IF NOT EXISTS recalled_messages (
+        message_id TEXT PRIMARY KEY,
+        chat_id TEXT NOT NULL,
+        recalled_at INTEGER NOT NULL,
+        recall_type TEXT NOT NULL DEFAULT ''
+      );
+
       -- Tracks messages that should actively trigger a bot reply.
       -- Other unsynced messages remain local context and are sent only when a trigger arrives.
       CREATE TABLE IF NOT EXISTS pending_triggers (
@@ -225,6 +235,17 @@ export class MessageStore {
         const row = this.db.prepare(`SELECT id FROM messages WHERE message_id = ?`).get(messageId);
         return row?.id || null;
     }
+    markMessageRecalled(messageId, chatId, recalledAt = Date.now(), recallType = '') {
+        this.db.prepare(`
+      INSERT INTO recalled_messages (message_id, chat_id, recalled_at, recall_type)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(message_id) DO UPDATE SET chat_id = excluded.chat_id, recalled_at = excluded.recalled_at, recall_type = excluded.recall_type
+    `).run(messageId, chatId, recalledAt, recallType || '');
+    }
+    isMessageRecalled(messageId) {
+        const row = this.db.prepare(`SELECT 1 FROM recalled_messages WHERE message_id = ?`).get(messageId);
+        return !!row;
+    }
     markPendingTrigger(botName, chatId, messageRowId) {
         this.db.prepare(`
       INSERT OR IGNORE INTO pending_triggers (bot_name, chat_id, message_row_id)
@@ -304,6 +325,29 @@ export class MessageStore {
     `).get(botName, chatId, contentHash, Date.now() - windowMs);
         return !!row;
     }
+    hasRecentOverlappingDelivery(botName, chatId, content, attachmentsJson, windowMs, minShortLength = 8) {
+        const normalized = content.trim();
+        if (normalized.length < minShortLength)
+            return false;
+        const rows = this.db.prepare(`
+      SELECT content, attachments_json FROM delivery_outbox
+      WHERE bot_name = ? AND chat_id = ? AND created_at >= ? AND status IN ('pending', 'delivering', 'delivered')
+      ORDER BY created_at DESC
+      LIMIT 20
+    `).all(botName, chatId, Date.now() - windowMs);
+        for (const row of rows) {
+            if ((row.attachments_json || '[]') !== attachmentsJson)
+                continue;
+            const existing = String(row.content || '').trim();
+            if (existing.length < minShortLength)
+                continue;
+            const shorter = existing.length <= normalized.length ? existing : normalized;
+            const longer = existing.length <= normalized.length ? normalized : existing;
+            if (shorter.length >= minShortLength && longer.includes(shorter))
+                return true;
+        }
+        return false;
+    }
     claimDelivery(id) {
         const result = this.db.prepare(`
       UPDATE delivery_outbox SET status = 'delivering', attempts = attempts + 1, updated_at = ? WHERE id = ? AND status = 'pending'
@@ -350,9 +394,10 @@ export class MessageStore {
     `).get(botName, chatId);
         const lastId = row?.last_synced_msg_id || 0;
         const rows = this.db.prepare(`
-      SELECT * FROM messages
-      WHERE chat_id = ? AND id > ?
-      ORDER BY timestamp ASC
+      SELECT messages.* FROM messages
+      LEFT JOIN recalled_messages ON recalled_messages.message_id = messages.message_id
+      WHERE messages.chat_id = ? AND messages.id > ? AND recalled_messages.message_id IS NULL
+      ORDER BY messages.timestamp ASC
       LIMIT ?
     `).all(chatId, lastId, maxCount);
         return rows.map((r) => ({

package/dist/openclaw-client.d.ts

@@ -25,12 +25,16 @@ export declare class OpenClawClient {
     private sessionMessageCallbacks;
     /** Session keys that should be re-subscribed on reconnect */
     private subscribedKeys;
-    /** Session keys with active/recent chatSend — suppress proactive message delivery */
+    /** Session keys with active/recent chatSend — proactive is forwarded and deduped by outbox. */
     private suppressedSessions;
     private suppressedSessionTimers;
+    /** Session keys whose proactive messages must be dropped by the bridge (e.g. discussion scheduler owns delivery). */
+    private mutedProactiveSessions;
+    private mutedProactiveSessionCounts;
     constructor(config: OpenClawConfig);
     connect(): Promise<void>;
     private _doConnect;
+    private handleProactiveSessionMessage;
     private scheduleReconnect;
     private rpc;
     /**
@@ -71,6 +75,9 @@ export declare class OpenClawClient {
     abortChat(sessionKey: string, runId: string): Promise<any>;
     private suppressSessionKeys;
     private releaseSuppressedSessionKeysAfter;
+    private addMutedProactiveKey;
+    private releaseMutedProactiveKey;
+    muteProactiveDelivery(sessionKey: string): (delayMs?: number) => void;
     chatSend(params: {
         sessionKey: string;
         message: string;

package/dist/openclaw-client.js

@@ -23,9 +23,12 @@ export class OpenClawClient {
     sessionMessageCallbacks = new Map();
     /** Session keys that should be re-subscribed on reconnect */
     subscribedKeys = new Set();
-    /** Session keys with active/recent chatSend — suppress proactive message delivery */
+    /** Session keys with active/recent chatSend — proactive is forwarded and deduped by outbox. */
     suppressedSessions = new Set();
     suppressedSessionTimers = new Map();
+    /** Session keys whose proactive messages must be dropped by the bridge (e.g. discussion scheduler owns delivery). */
+    mutedProactiveSessions = new Set();
+    mutedProactiveSessionCounts = new Map();
     constructor(config) {
         this.config = config;
     }
@@ -140,45 +143,7 @@ export class OpenClawClient {
                     // Try both raw key and without agent:main: prefix
                     const shortKey = rawKey.replace(/^agent:[^:]+:/, "");
                     const msg = frame.payload.message || frame.payload;
-                    const role = msg.role;
-                    const content = msg.content;
-                    // Proactive assistant text messages (suppress during active chatSend).
-                    // Cron/session-targeted runs often emit structured content arrays rather
-                    // than a plain string. Extract only visible text parts and ignore thinking
-                    // / tool blocks so the bridge can deliver final cron results via the bot.
-                    let proactiveText = "";
-                    if (role === "assistant") {
-                        if (typeof content === "string") {
-                            proactiveText = content;
-                        }
-                        else if (Array.isArray(content)) {
-                            const hasToolBlock = content.some((part) => {
-                                const type = String(part?.type || "").toLowerCase();
-                                return type === "toolcall" || type === "tool_call" || type === "tooluse" || type === "tool_use" || type === "toolresult" || type === "tool_result";
-                            });
-                            // Do not deliver mixed text+toolCall assistant messages through
-                            // the proactive final-text path; those are usually intermediate
-                            // reasoning/status during a tool loop. Tool calls are still
-                            // delivered via the verbose channel from agent item events when
-                            // /verbose is enabled. Cron final messages arrive as text-only
-                            // (optionally with thinking).
-                            if (!hasToolBlock) {
-                                proactiveText = content
-                                    .filter((part) => part?.type === "text" && typeof part.text === "string")
-                                    .map((part) => part.text)
-                                    .join("\n")
-                                    .trim();
-                            }
-                        }
-                    }
-                    if (proactiveText) {
-                        if (this.suppressedSessions.has(rawKey) || this.suppressedSessions.has(shortKey)) {
-                            console.log(`[OpenClaw] Forwarding proactive msg for ${shortKey} during active chatSend; delivery outbox will dedupe`);
-                        }
-                        const cb = this.sessionMessageCallbacks.get(rawKey) || this.sessionMessageCallbacks.get(shortKey);
-                        if (cb)
-                            cb(proactiveText);
-                    }
+                    this.handleProactiveSessionMessage(rawKey, msg);
                     // Tool calls in assistant messages — skip, using agent item events instead
                     // (session.message toolCall events are batched, not real-time)
                 }
@@ -210,6 +175,53 @@ export class OpenClawClient {
             });
         });
     }
+    handleProactiveSessionMessage(rawKey, msg) {
+        const shortKey = rawKey.replace(/^agent:[^:]+:/, "");
+        const role = msg.role;
+        const content = msg.content;
+        // Proactive assistant text messages. Cron/session-targeted runs often emit
+        // structured content arrays rather than a plain string. Extract only visible
+        // text parts and ignore thinking/tool blocks so the bridge can deliver final
+        // cron results via the bot.
+        let proactiveText = "";
+        if (role === "assistant") {
+            if (typeof content === "string") {
+                proactiveText = content;
+            }
+            else if (Array.isArray(content)) {
+                const hasToolBlock = content.some((part) => {
+                    const type = String(part?.type || "").toLowerCase();
+                    return type === "toolcall" || type === "tool_call" || type === "tooluse" || type === "tool_use" || type === "toolresult" || type === "tool_result";
+                });
+                // Do not deliver mixed text+toolCall assistant messages through
+                // the proactive final-text path; those are usually intermediate
+                // reasoning/status during a tool loop. Tool calls are still
+                // delivered via the verbose channel from agent item events when
+                // /verbose is enabled. Cron final messages arrive as text-only
+                // (optionally with thinking).
+                if (!hasToolBlock) {
+                    proactiveText = content
+                        .filter((part) => part?.type === "text" && typeof part.text === "string")
+                        .map((part) => part.text)
+                        .join("\n")
+                        .trim();
+                }
+            }
+        }
+        if (!proactiveText)
+            return false;
+        if (this.mutedProactiveSessions.has(rawKey) || this.mutedProactiveSessions.has(shortKey)) {
+            console.log(`[OpenClaw] Dropping proactive msg for ${shortKey}; delivery is owned by the caller`);
+            return false;
+        }
+        if (this.suppressedSessions.has(rawKey) || this.suppressedSessions.has(shortKey)) {
+            console.log(`[OpenClaw] Forwarding proactive msg for ${shortKey} during active chatSend; delivery outbox will dedupe`);
+        }
+        const cb = this.sessionMessageCallbacks.get(rawKey) || this.sessionMessageCallbacks.get(shortKey);
+        if (cb)
+            cb(proactiveText);
+        return Boolean(cb);
+    }
     scheduleReconnect() {
         const delay = this.reconnectDelay;
         this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
@@ -492,6 +504,42 @@ export class OpenClawClient {
             this.suppressedSessionTimers.set(key, timer);
         }
     }
+    addMutedProactiveKey(key) {
+        const count = this.mutedProactiveSessionCounts.get(key) || 0;
+        this.mutedProactiveSessionCounts.set(key, count + 1);
+        this.mutedProactiveSessions.add(key);
+    }
+    releaseMutedProactiveKey(key) {
+        const count = this.mutedProactiveSessionCounts.get(key) || 0;
+        if (count <= 1) {
+            this.mutedProactiveSessionCounts.delete(key);
+            this.mutedProactiveSessions.delete(key);
+        }
+        else {
+            this.mutedProactiveSessionCounts.set(key, count - 1);
+        }
+    }
+    muteProactiveDelivery(sessionKey) {
+        const shortKey = sessionKey.startsWith("agent:main:") ? sessionKey.slice("agent:main:".length) : sessionKey;
+        const fullKey = `agent:main:${shortKey}`;
+        const keys = [shortKey, fullKey];
+        for (const key of keys)
+            this.addMutedProactiveKey(key);
+        let released = false;
+        return (delayMs = 0) => {
+            if (released)
+                return;
+            released = true;
+            const release = () => {
+                for (const key of keys)
+                    this.releaseMutedProactiveKey(key);
+            };
+            if (delayMs > 0)
+                setTimeout(release, delayMs);
+            else
+                release();
+        };
+    }
     async chatSend(params) {
         const sk = params.sessionKey;
         const fullSessionKey = `agent:main:${sk}`;
@@ -619,6 +667,8 @@ export class OpenClawClient {
             clearTimeout(timer);
         this.suppressedSessionTimers.clear();
         this.suppressedSessions.clear();
+        this.mutedProactiveSessions.clear();
+        this.mutedProactiveSessionCounts.clear();
         if (this.ws) {
             this.ws.close();
             this.ws = null;

package/package.json

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