openclaw-lark-multi-agent 0.1.13 → 0.1.15

package/dist/discussion-manager.d.ts

@@ -20,7 +20,10 @@ type DiscussionSession = {
 };
 export type DiscussionParticipant = {
     name: string;
-    runDiscussionTurn(chatId: string, prompt: string): Promise<ReplyResult>;
+    runDiscussionTurn(chatId: string, prompt: string, meta?: {
+        round: number;
+        maxRounds: number;
+    }): Promise<ReplyResult>;
 };
 export declare class DiscussionManager {
     private sessions;

package/dist/discussion-manager.js

@@ -70,7 +70,7 @@ export class DiscussionManager {
             const prompt = this.buildPrompt(session);
             const results = await Promise.allSettled(participants.map(async (participant) => {
                 try {
-                    return await participant.runDiscussionTurn(session.chatId, prompt);
+                    return await participant.runDiscussionTurn(session.chatId, prompt, { round: session.currentRound, maxRounds: session.maxRounds });
                 }
                 catch (err) {
                     return {
@@ -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

@@ -29,6 +29,8 @@ export declare class FeishuBot {
     private queueRuns;
     /** Per-chat serial send queue to guarantee message order */
     private sendQueue;
+    /** Per-chat delayed runtime failure notifications, canceled if a real reply arrives. */
+    private delayedFailureTimers;
     private adminOpenId;
     private static allBots;
     constructor(config: BotConfig, openclawClient: OpenClawClient, store: MessageStore, adminOpenId?: string);
@@ -77,6 +79,14 @@ export declare class FeishuBot {
     private stripLeadingCommandMentions;
     private buildMarkdownCard;
     private formatUserVisibleError;
+    private isRuntimeFailureText;
+    private cancelDelayedFailure;
+    private scheduleDelayedFailure;
+    private deliverySessionKey;
+    private stableHash;
+    private deliverySourceId;
+    private enqueueAndDispatchDelivery;
+    private dispatchPendingDeliveries;
     private isDiscussionCoordinator;
     private getDiscussionParticipants;
     private runDiscussionTurn;

package/dist/feishu-bot.js

@@ -34,6 +34,8 @@ export class FeishuBot {
     queueRuns = new Map();
     /** Per-chat serial send queue to guarantee message order */
     sendQueue = new Map();
+    /** Per-chat delayed runtime failure notifications, canceled if a real reply arrives. */
+    delayedFailureTimers = new Map();
     adminOpenId;
     static allBots = new Map();
     constructor(config, openclawClient, store, adminOpenId) {
@@ -114,11 +116,9 @@ export class FeishuBot {
             try {
                 console.log(`[${this.config.name}] Proactive message for ${chatId.slice(-8)}`);
                 const parsed = this.extractBridgeAttachments(text);
-                if (parsed.text.trim())
-                    await this.sendMessage(chatId, parsed.text);
-                for (const attachment of parsed.attachments) {
-                    await this.sendBridgeAttachment(chatId, attachment);
-                }
+                if (parsed.text.trim() || parsed.attachments.length > 0)
+                    this.cancelDelayedFailure(chatId);
+                await this.enqueueAndDispatchDelivery(chatId, "assistant_visible", this.deliverySourceId("proactive", `${Date.now()}:${Math.random()}:${parsed.text.trim()}|${JSON.stringify(parsed.attachments)}`), parsed.text.trim(), parsed.attachments);
             }
             catch (err) {
                 console.error(`[${this.config.name}] Failed to deliver proactive msg:`, err.message);
@@ -503,6 +503,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));
@@ -661,6 +663,7 @@ export class FeishuBot {
                 this.store.markSynced(this.config.name, chatId, maxId);
                 this.store.clearPendingTriggers(this.config.name, chatId, maxId);
                 const shouldReply = trimmedReply.length > 0 && !explicitNoReply;
+                const isRuntimeFailure = shouldReply && this.isRuntimeFailureText(trimmedReply);
                 // Record bot reply only if it is user-visible/context-worthy.
                 if (shouldReply || hasAttachments) {
                     const storedContent = [visibleReply, ...parsedReply.attachments.map((a) => `[Attachment: ${a.type || "file"} ${a.path}]`)]
@@ -692,32 +695,19 @@ export class FeishuBot {
                 }
                 // Reply to the last human message on Feishu (ordered after tool msgs)
                 // Skip empty replies and explicit NO_REPLY responses
-                if ((shouldReply || hasAttachments) && lastHuman.messageId) {
+                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}`);
                     }
                     else {
-                        await this.sendOrdered(chatId, async () => {
-                            if (shouldReply) {
-                                try {
-                                    await this.replyMessage(lastHuman.messageId, visibleReply);
-                                }
-                                catch (err) {
-                                    // Reply can fail for historical messages sent before this bot joined the chat
-                                    // (Feishu 230002: Bot/User can NOT be out of the chat). Fall back to a normal
-                                    // chat message so queue processing still completes.
-                                    console.warn(`[${this.config.name}] replyMessage failed, fallback to sendMessage:`, err.message);
-                                    await this.sendMessage(chatId, visibleReply);
-                                }
-                            }
-                            for (const attachment of parsedReply.attachments) {
-                                await this.sendBridgeAttachment(chatId, attachment);
-                            }
-                            if (triggerId)
-                                this.store.markDeliveredReply(this.config.name, chatId, triggerId, lastHuman.messageId);
-                        });
+                        await this.enqueueAndDispatchDelivery(chatId, "assistant_visible", this.deliverySourceId("visible", `${(shouldReply ? visibleReply : "").trim()}|${JSON.stringify(parsedReply.attachments)}`), shouldReply ? visibleReply : "", parsedReply.attachments, lastHuman.messageId, `trigger:${triggerId}`);
+                        if (triggerId)
+                            this.store.markDeliveredReply(this.config.name, chatId, triggerId, lastHuman.messageId);
                     }
                 }
+                if (isRuntimeFailure && lastHuman.messageId) {
+                    this.scheduleDelayedFailure(chatId, lastHuman.messageId, visibleReply, triggerId);
+                }
                 console.log(`[${this.config.name}] [${new Date().toISOString()}] ${shouldReply || hasAttachments ? 'Replied' : 'Skipped (empty/NO_REPLY)'} (${reply.length} chars, attachments=${parsedReply.attachments.length})`);
                 // Replace ack reactions with DONE only for trigger messages actually
                 // processed in this run. Queued messages that arrived mid-run keep their
@@ -739,16 +729,12 @@ export class FeishuBot {
                 console.error(`[${this.config.name}] processQueue error:`, err);
                 const errorText = this.formatUserVisibleError(err);
                 if (lastHuman.messageId) {
-                    await this.sendOrdered(chatId, async () => {
-                        try {
-                            await this.replyMessage(lastHuman.messageId, errorText);
-                        }
-                        catch {
-                            await this.sendMessage(chatId, errorText);
-                        }
+                    await this.enqueueAndDispatchDelivery(chatId, "provider_error", `trigger:${triggerId}:provider-error`, errorText, [], lastHuman.messageId, `trigger:${triggerId}:provider-error`)
+                        .then(() => {
                         if (triggerId)
                             this.store.markDeliveredReply(this.config.name, chatId, triggerId, lastHuman.messageId);
-                    }).catch(() => { });
+                    })
+                        .catch(() => { });
                 }
                 if (triggerId) {
                     // The run failed after OpenClaw/provider rejected it. Notify the user
@@ -899,6 +885,110 @@ export class FeishuBot {
         }
         return `⚠️ ${this.config.name} 这次没有完成回复。\n原因：${reason}`;
     }
+    isRuntimeFailureText(text) {
+        return text.startsWith("⚠️ Agent 未正常完成") || /\n原因:\s*rpc\b/.test(text);
+    }
+    cancelDelayedFailure(chatId) {
+        const timer = this.delayedFailureTimers.get(chatId);
+        if (timer)
+            clearTimeout(timer);
+        this.delayedFailureTimers.delete(chatId);
+    }
+    scheduleDelayedFailure(chatId, replyToMessageId, text, triggerId) {
+        this.cancelDelayedFailure(chatId);
+        const timer = setTimeout(() => {
+            this.delayedFailureTimers.delete(chatId);
+            void this.enqueueAndDispatchDelivery(chatId, "delayed_error", `trigger:${triggerId}:delayed-error`, text, [], replyToMessageId, `trigger:${triggerId}:delayed-error`)
+                .then(() => {
+                if (triggerId)
+                    this.store.markDeliveredReply(this.config.name, chatId, triggerId, replyToMessageId);
+            })
+                .catch((err) => {
+                console.warn(`[${this.config.name}] delayed failure delivery failed:`, err.message);
+            });
+        }, 60_000);
+        this.delayedFailureTimers.set(chatId, timer);
+    }
+    deliverySessionKey(chatId) {
+        return this.getSessionKey(chatId);
+    }
+    stableHash(text) {
+        let hash = 2166136261;
+        for (let i = 0; i < text.length; i++) {
+            hash ^= text.charCodeAt(i);
+            hash = Math.imul(hash, 16777619);
+        }
+        return (hash >>> 0).toString(36);
+    }
+    deliverySourceId(kind, text) {
+        return `${kind}:${this.stableHash(text)}`;
+    }
+    async enqueueAndDispatchDelivery(chatId, sourceType, sourceId, text, attachments = [], replyToMessageId, deliveryKey) {
+        if (!text.trim() && attachments.length === 0)
+            return;
+        const attachmentsJson = JSON.stringify(attachments);
+        const normalizedPayload = `${text.trim()}|${attachmentsJson}`;
+        const contentHash = this.stableHash(normalizedPayload);
+        const finalDeliveryKey = deliveryKey || sourceId;
+        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,
+            botName: this.config.name,
+            sourceType,
+            sourceId,
+            deliveryKey: finalDeliveryKey,
+            contentHash,
+            content: text,
+            attachmentsJson,
+            replyToMessageId: replyToMessageId || "",
+        });
+        if (deliveryId === null)
+            return;
+        await this.dispatchPendingDeliveries(chatId, replyToMessageId);
+    }
+    async dispatchPendingDeliveries(chatId, replyToMessageId) {
+        const pending = this.store.getPendingDeliveries(chatId, this.config.name, 50);
+        for (const item of pending) {
+            await this.sendOrdered(chatId, async () => {
+                try {
+                    if (!item.id || !this.store.claimDelivery(item.id))
+                        return;
+                    const attachments = JSON.parse(item.attachmentsJson || "[]");
+                    if (item.content.trim()) {
+                        const replyTarget = item.replyToMessageId || replyToMessageId;
+                        const shouldReplyToSource = replyTarget && (item.sourceType === "assistant_visible" || item.sourceType === "provider_error" || item.sourceType === "delayed_error");
+                        if (shouldReplyToSource) {
+                            try {
+                                await this.replyMessage(replyTarget, item.content);
+                            }
+                            catch (err) {
+                                console.warn(`[${this.config.name}] replyMessage failed, fallback to sendMessage:`, err.message);
+                                await this.sendMessage(chatId, item.content);
+                            }
+                        }
+                        else {
+                            await this.sendMessage(chatId, item.content);
+                        }
+                    }
+                    for (const attachment of attachments)
+                        await this.sendBridgeAttachment(chatId, attachment);
+                    if (item.id)
+                        this.store.markDeliveryDelivered(item.id);
+                }
+                catch (err) {
+                    if (item.id)
+                        this.store.markDeliveryFailed(item.id);
+                    throw err;
+                }
+            });
+        }
+    }
     isDiscussionCoordinator() {
         const bots = Array.from(FeishuBot.allBots.values()).filter((bot) => bot.store === this.store);
         if (bots.length === 0)
@@ -910,24 +1000,41 @@ export class FeishuBot {
             .filter((bot) => bot.store === this.store && bot.store.getBotMode(bot.config.name, chatId) === "free")
             .map((bot) => ({
             name: bot.config.name,
-            runDiscussionTurn: async (_chatId, prompt) => bot.runDiscussionTurn(chatId, prompt),
+            runDiscussionTurn: async (_chatId, prompt, meta) => bot.runDiscussionTurn(chatId, prompt, meta),
         }));
     }
-    async runDiscussionTurn(chatId, prompt) {
+    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);
-        const 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) {
+            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({
@@ -938,14 +1045,9 @@ export class FeishuBot {
                 content: storedContent,
                 timestamp: Date.now(),
             });
-            await this.sendOrdered(chatId, async () => {
-                if (isVisible)
-                    await this.sendMessage(chatId, visibleReply);
-                for (const attachment of parsedReply.attachments)
-                    await this.sendBridgeAttachment(chatId, attachment);
-            });
+            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

@@ -25,6 +25,23 @@ export interface ChatMessage {
     content: string;
     timestamp: number;
 }
+export interface DeliveryOutboxItem {
+    id?: number;
+    sessionKey: string;
+    chatId: string;
+    botName: string;
+    sourceType: string;
+    sourceId: string;
+    deliveryKey: string;
+    contentHash: string;
+    content: string;
+    attachmentsJson: string;
+    replyToMessageId: string;
+    status: "pending" | "delivering" | "delivered" | "failed";
+    attempts: number;
+    createdAt: number;
+    updatedAt: number;
+}
 export declare class MessageStore {
     private db;
     constructor(dbPath?: string);
@@ -40,6 +57,15 @@ export declare class MessageStore {
     clearPendingTrigger(botName: string, chatId: string, messageRowId: number): void;
     hasDeliveredReply(botName: string, chatId: string, triggerMessageRowId: number): boolean;
     markDeliveredReply(botName: string, chatId: string, triggerMessageRowId: number, replyMessageId?: string): void;
+    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[];
+    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;
+    private mapDelivery;
     /**
      * Get messages that haven't been synced to a bot's session yet.
      * Returns messages ordered by timestamp ascending.

package/dist/message-store.js

@@ -82,7 +82,74 @@ export class MessageStore {
         updated_at INTEGER NOT NULL DEFAULT 0,
         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
+      -- session.message, subagent announce, or delayed error handling.
+      CREATE TABLE IF NOT EXISTS delivery_outbox (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_key TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        bot_name TEXT NOT NULL,
+        source_type TEXT NOT NULL,
+        source_id TEXT NOT NULL,
+        delivery_key TEXT NOT NULL DEFAULT '',
+        content_hash TEXT NOT NULL DEFAULT '',
+        content TEXT NOT NULL DEFAULT '',
+        attachments_json TEXT NOT NULL DEFAULT '[]',
+        reply_to_message_id TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'pending',
+        attempts INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        UNIQUE(bot_name, chat_id, delivery_key),
+        UNIQUE(session_key, source_type, source_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_delivery_outbox_pending ON delivery_outbox(status, created_at);
+    `);
+        // Migration: add delivery_outbox delivery key columns if missing
+        try {
+            this.db.exec(`ALTER TABLE delivery_outbox ADD COLUMN delivery_key TEXT NOT NULL DEFAULT ''`);
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec(`ALTER TABLE delivery_outbox ADD COLUMN content_hash TEXT NOT NULL DEFAULT ''`);
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec(`ALTER TABLE delivery_outbox ADD COLUMN reply_to_message_id TEXT NOT NULL DEFAULT ''`);
+        }
+        catch {
+            // Column already exists
+        }
+        // Backfill stable keys for rows created by earlier outbox experiments before
+        // creating indexes that reference the new columns.
+        this.db.exec(`
+      UPDATE delivery_outbox
+      SET delivery_key = source_id
+      WHERE delivery_key IS NULL OR delivery_key = '';
     `);
+        try {
+            this.db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_delivery_outbox_key ON delivery_outbox(bot_name, chat_id, delivery_key)`);
+        }
+        catch {
+            // Existing duplicate experimental rows can prevent index creation in dev DB.
+            // Fresh DBs still get the table-level UNIQUE constraint; dirty DBs still use
+            // source unique + short-window content hash until cleaned.
+        }
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_delivery_outbox_content ON delivery_outbox(bot_name, chat_id, content_hash, created_at)`);
+        // Migration: add delivery_outbox reply target if missing
+        try {
+            this.db.exec(`ALTER TABLE delivery_outbox ADD COLUMN reply_to_message_id TEXT NOT NULL DEFAULT ''`);
+        }
+        catch {
+            // Column already exists
+        }
         // Migration: add verbose column if missing
         try {
             this.db.exec(`ALTER TABLE chat_info ADD COLUMN verbose INTEGER NOT NULL DEFAULT 0`);
@@ -197,6 +264,104 @@ export class MessageStore {
       VALUES (?, ?, ?, ?, ?)
     `).run(botName, chatId, triggerMessageRowId, Date.now(), replyMessageId);
     }
+    enqueueDelivery(item) {
+        const now = Date.now();
+        const result = this.db.prepare(`
+      INSERT OR IGNORE INTO delivery_outbox
+        (session_key, chat_id, bot_name, source_type, source_id, delivery_key, content_hash, content, attachments_json, reply_to_message_id, status, attempts, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', 0, ?, ?)
+    `).run(item.sessionKey, item.chatId, item.botName, item.sourceType, item.sourceId, item.deliveryKey, item.contentHash, item.content, item.attachmentsJson, item.replyToMessageId || '', now, now);
+        return result.changes ? Number(result.lastInsertRowid) : null;
+    }
+    getDeliveryBySource(sessionKey, sourceType, sourceId) {
+        const row = this.db.prepare(`
+      SELECT * FROM delivery_outbox
+      WHERE session_key = ? AND source_type = ? AND source_id = ?
+    `).get(sessionKey, sourceType, sourceId);
+        return row ? this.mapDelivery(row) : null;
+    }
+    getPendingDeliveries(chatId, botName, maxCount = 20) {
+        if (chatId && botName) {
+            const rows = this.db.prepare(`
+        SELECT * FROM delivery_outbox
+        WHERE status = 'pending' AND chat_id = ? AND bot_name = ?
+        ORDER BY created_at ASC LIMIT ?
+      `).all(chatId, botName, maxCount);
+            return rows.map((r) => this.mapDelivery(r));
+        }
+        const rows = this.db.prepare(`
+      SELECT * FROM delivery_outbox WHERE status = 'pending' ORDER BY created_at ASC LIMIT ?
+    `).all(maxCount);
+        return rows.map((r) => this.mapDelivery(r));
+    }
+    hasRecentSimilarDelivery(botName, chatId, contentHash, windowMs) {
+        if (!contentHash)
+            return false;
+        const row = this.db.prepare(`
+      SELECT 1 FROM delivery_outbox
+      WHERE bot_name = ? AND chat_id = ? AND content_hash = ? AND created_at >= ? AND status IN ('pending', 'delivering', 'delivered')
+      LIMIT 1
+    `).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'
+    `).run(Date.now(), id);
+        return result.changes === 1;
+    }
+    markDeliveryDelivered(id) {
+        this.db.prepare(`
+      UPDATE delivery_outbox SET status = 'delivered', updated_at = ? WHERE id = ?
+    `).run(Date.now(), id);
+    }
+    markDeliveryFailed(id) {
+        this.db.prepare(`
+      UPDATE delivery_outbox SET status = 'failed', updated_at = ? WHERE id = ?
+    `).run(Date.now(), id);
+    }
+    mapDelivery(row) {
+        return {
+            id: row.id,
+            sessionKey: row.session_key,
+            chatId: row.chat_id,
+            botName: row.bot_name,
+            sourceType: row.source_type,
+            sourceId: row.source_id,
+            deliveryKey: row.delivery_key || row.source_id,
+            contentHash: row.content_hash || '',
+            content: row.content || '',
+            attachmentsJson: row.attachments_json || '[]',
+            replyToMessageId: row.reply_to_message_id || '',
+            status: row.status,
+            attempts: row.attempts || 0,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
     /**
      * Get messages that haven't been synced to a bot's session yet.
      * Returns messages ordered by timestamp ascending.

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,47 +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] Suppressing proactive msg for ${shortKey} (active chatSend)`);
-                        }
-                        else {
-                            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)
                 }
@@ -212,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);
@@ -494,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}`;
@@ -621,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.13",
+  "version": "0.1.15",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {