openclaw-lark-multi-agent 0.1.12 → 0.1.14

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 {

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);
@@ -661,6 +661,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 +693,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 +727,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 +883,105 @@ 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 normalizedPayload = `${text.trim()}|${JSON.stringify(attachments)}`;
+        const contentHash = this.stableHash(normalizedPayload);
+        const finalDeliveryKey = deliveryKey || sourceId;
+        if (!deliveryKey && this.store.hasRecentSimilarDelivery(this.config.name, chatId, contentHash, 60_000))
+            return;
+        const deliveryId = this.store.enqueueDelivery({
+            sessionKey: this.deliverySessionKey(chatId),
+            chatId,
+            botName: this.config.name,
+            sourceType,
+            sourceId,
+            deliveryKey: finalDeliveryKey,
+            contentHash,
+            content: text,
+            attachmentsJson: JSON.stringify(attachments),
+            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,10 +993,10 @@ 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,
@@ -924,8 +1007,11 @@ export class FeishuBot {
             timeoutMs: 1_800_000,
         });
         const parsedReply = this.extractBridgeAttachments(reply);
-        const visibleReply = parsedReply.text.trim();
+        let visibleReply = parsedReply.text.trim();
         const isVisible = visibleReply.length > 0 && visibleReply.toUpperCase() !== "NO_REPLY";
+        if (isVisible && meta) {
+            visibleReply = `${visibleReply}\n\n—— 第 ${meta.round}/${meta.maxRounds} 轮 · ${this.config.name}`;
+        }
         if (isVisible || parsedReply.attachments.length > 0) {
             const storedContent = [visibleReply, ...parsedReply.attachments.map((a) => `[Attachment: ${a.type || "file"} ${a.path}]`)]
                 .filter(Boolean)
@@ -938,12 +1024,7 @@ 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 ? visibleReply : "", parsedReply.attachments);
         }
         return { botName: this.config.name, text: visibleReply, visible: isVisible };
     }

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,14 @@ 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;
+    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,81 @@ 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;
+    }
+    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.js

@@ -173,13 +173,11 @@ export class OpenClawClient {
                     }
                     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);
+                            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);
                     }
                     // Tool calls in assistant messages — skip, using agent item events instead
                     // (session.message toolCall events are batched, not real-time)
@@ -352,7 +350,14 @@ export class OpenClawClient {
                                     });
                                     // Prefer final chat message over accumulated deltas: some providers may
                                     // emit only partial deltas (e.g. "N") while final contains "NO_REPLY".
-                                    finish(chatFinalText || text);
+                                    const latestFinalText = chatFinalText || text;
+                                    if (latestFinalText) {
+                                        finish(latestFinalText);
+                                    }
+                                    else {
+                                        console.warn(`[OpenClaw] collectReply: empty chatFinal fallback ignored; waiting for real text or idle timeout`);
+                                        chatFinalTimer = null;
+                                    }
                                 }, 5000);
                             }
                         }
@@ -369,7 +374,7 @@ export class OpenClawClient {
                                     finish("NO_REPLY");
                                     return;
                                 }
-                                if (!latestFinalText && ev.data?.livenessState !== "working") {
+                                if (!latestFinalText) {
                                     const state = ev.data?.livenessState || "unknown";
                                     const reason = ev.data?.stopReason || "";
                                     const replayInvalid = ev.data?.replayInvalid ? ", replayInvalid" : "";
@@ -379,11 +384,14 @@ export class OpenClawClient {
                                         replayInvalidTimer = setTimeout(() => finish(failureText), 120000);
                                         return;
                                     }
-                                    finish(failureText);
-                                }
-                                else {
-                                    finish(latestFinalText);
+                                    if (ev.data?.livenessState !== "working") {
+                                        finish(failureText);
+                                        return;
+                                    }
+                                    console.warn(`[OpenClaw] empty lifecycle end ignored for runId=${evRunId || runId}; waiting for real text or idle timeout`);
+                                    return;
                                 }
+                                finish(latestFinalText);
                             };
                             // If lifecycle end beats chat final, a short delta like "N" can be a truncated
                             // final reply. Wait for chatFinal before resolving; otherwise suppress lone "N".

package/package.json

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