openclaw-lark-multi-agent 1.4.2 → 1.4.4

package/dist/feishu-bot.js

@@ -19,6 +19,8 @@ const BRIDGE_ATTACHMENTS_DIR = getBridgeAttachmentsDir();
 const FEISHU_DOCS_DIR = join(getDataDir(), "feishu-docs");
 const SESSION_HEALTH_POLL_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_SESSION_HEALTH_POLL_MS || 5_000);
 const SESSION_HEALTH_CONFIRM_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_SESSION_HEALTH_CONFIRM_MS || 2_000);
+const DELIVERY_MAX_ATTEMPTS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_DELIVERY_MAX_ATTEMPTS || 5);
+const DELIVERY_RETRY_BASE_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_DELIVERY_RETRY_BASE_MS || 1_000);
 // Auto-retry: when a reply looks truncated/incomplete, ask the same session
 // whether it finished. If it did not, let it continue; loop until it confirms
 // completion or the retry budget is spent. Off by setting AUTO_RETRY=0.
@@ -88,6 +90,13 @@ export class FeishuBot {
     sendQueue = new Map();
     /** Per-chat delayed runtime failure notifications, canceled if a real reply arrives. */
     delayedFailureTimers = new Map();
+    /** Ephemeral model footer overrides used by final-message wrappers. Keeping
+     * replyMessage/sendMessage two-argument APIs avoids contaminating ordinary
+     * command/error/card sends with model attribution. */
+    replyModelFooters = new Map();
+    sendModelFooters = new Map();
+    /** Per-chat durable outbox retry timer. */
+    deliveryRetryTimers = new Map();
     /** Last time a real assistant-visible reply was successfully handed to the delivery pipeline. */
     lastRealDeliveryAt = new Map();
     /** Per-chat: whether we've already sent the high-context alert this cycle. */
@@ -230,7 +239,7 @@ export class FeishuBot {
                     this.cancelDelayedFailure(chatId);
                 const activeTarget = this.activeDeliveryTargets.get(chatId);
                 try {
-                    await this.enqueueAndDispatchDelivery(chatId, sourceType, this.deliverySourceId(sourceType === "verbose_transcript" ? "verbose" : "proactive", `${Date.now()}:${Math.random()}:${parsed.text.trim()}|${JSON.stringify(parsed.attachments)}`), parsed.text.trim(), parsed.attachments, activeTarget?.messageId, undefined);
+                    await this.enqueueAndDispatchDelivery(chatId, sourceType, this.deliverySourceId(sourceType === "verbose_transcript" ? "verbose" : "proactive", `${Date.now()}:${Math.random()}:${parsed.text.trim()}|${JSON.stringify(parsed.attachments)}`), parsed.text.trim(), parsed.attachments, activeTarget?.messageId, activeTarget ? `trigger:${activeTarget.triggerId}` : undefined, sourceType === "verbose_transcript" ? undefined : this.config.model);
                     if (sourceType !== "verbose_transcript" && (parsed.text.trim() || parsed.attachments.length > 0)) {
                         await activeTarget?.liveStatus?.complete().catch(() => { });
                     }
@@ -318,9 +327,9 @@ export class FeishuBot {
      */
     async drainOnStartup() {
         try {
-            const restoredDeliveries = this.store.resetStaleDeliveries(this.config.name, 5 * 60_000, 5);
-            if (restoredDeliveries.restored > 0 || restoredDeliveries.failed > 0) {
-                console.warn(`[${this.config.name}] Startup delivery recovery: restored=${restoredDeliveries.restored}, failed=${restoredDeliveries.failed}`);
+            const restoredDeliveries = this.store.resetDeliveringOnStartup(this.config.name);
+            if (restoredDeliveries > 0) {
+                console.warn(`[${this.config.name}] Startup delivery recovery: restored=${restoredDeliveries}`);
             }
             const chats = this.store.getAllChatInfo();
             const drainTasks = [];
@@ -1342,7 +1351,18 @@ export class FeishuBot {
                     // submitted far enough that auto-replaying risks duplicate delivery.
                     // The user can resend a new message if they want to retry.
                     markSubmittedBatch("empty-returned");
-                    await liveStatus?.noReply().catch(() => { });
+                    // The proactive session.message path can already have delivered the
+                    // real answer on this trigger's shared live-status card while the
+                    // chat-final collector returns an empty string. In that race, a late
+                    // noReply() patch would overwrite the answer with the idle summary.
+                    const existingAnswer = this.store.getDeliveryByKey(this.config.name, chatId, `trigger:${triggerId}`);
+                    const answerAlreadyOwned = this.deliveryOwnsVisiblePayload(existingAnswer);
+                    if (answerAlreadyOwned) {
+                        console.log(`[${this.config.name}] Empty-final cleanup skipped; trigger ${triggerId} already has an answer delivery`);
+                    }
+                    else {
+                        await liveStatus?.noReply().catch(() => { });
+                    }
                     console.warn(`[${this.config.name}] Empty reply for ${chatId.slice(-8)} trigger=${triggerId}; not replaying submitted message(s)`);
                     const pendingAcks = this.pendingAckMessages.get(chatId) || [];
                     const remainingAcks = [];
@@ -1417,11 +1437,10 @@ export class FeishuBot {
                     }
                     else {
                         try {
-                            // Final answer always goes through the normal interactive-card
-                            // delivery path so Markdown renders correctly. The live status is a
-                            // SEPARATE message: once the final reply is enqueued, mark the
-                            // status message done.
-                            await this.enqueueAndDispatchDelivery(chatId, "assistant_visible", this.deliverySourceId("visible", `${(shouldReply ? visibleReply : "").trim()}|${JSON.stringify(parsedReply.attachments)}`), shouldReply ? visibleReply : "", parsedReply.attachments, lastHuman.messageId, `trigger:${triggerId}`);
+                            // Keep live status and final answer as separate messages. The final
+                            // answer is created at completion time so it remains at the bottom
+                            // even when the user inserted more messages during the run.
+                            await this.enqueueAndDispatchDelivery(chatId, "assistant_visible", this.deliverySourceId("visible", `${triggerId}|${(shouldReply ? visibleReply : "").trim()}|${JSON.stringify(parsedReply.attachments)}`), shouldReply ? visibleReply : "", parsedReply.attachments, lastHuman.messageId, `trigger:${triggerId}`, this.config.model);
                             await liveStatus?.complete();
                             // Mark every merged trigger as delivered so retries/restarts do
                             // not re-process any of them.
@@ -1444,10 +1463,44 @@ export class FeishuBot {
                     this.scheduleDelayedFailure(chatId, lastHuman.messageId, visibleReply, triggerId);
                 }
                 else if (!shouldReply && !hasAttachments) {
-                    // Explicit NO_REPLY (or empty visible text): the model finished without
-                    // producing a user-visible reply. Mark the status card done with a
-                    // "no content" summary instead of leaving it stuck on "正在执行".
-                    await liveStatus?.noReply().catch(() => { });
+                    // A proactive session.message may already own this trigger and carry
+                    // the real answer while collectReply returns empty/NO_REPLY. Never
+                    // overwrite that same card with a 💤 summary.
+                    const existingAnswer = this.store.getDeliveryByKey(this.config.name, chatId, `trigger:${triggerId}`);
+                    const answerAlreadyOwned = this.deliveryOwnsVisiblePayload(existingAnswer);
+                    if (answerAlreadyOwned) {
+                        console.log(`[${this.config.name}] NO_REPLY cleanup skipped; trigger ${triggerId} already has an answer delivery`);
+                    }
+                    else {
+                        // Explicit NO_REPLY/empty final also uses the durable cleanup outbox
+                        // when a card exists, so a previously-disabled card gets one terminal
+                        // patch attempt instead of remaining stuck on "正在执行".
+                        const noReplyMeta = await liveStatus?.prepareTerminalDelivery(true);
+                        if (noReplyMeta) {
+                            const cleanupId = this.store.enqueueDelivery({
+                                sessionKey: this.deliverySessionKey(chatId),
+                                chatId,
+                                botName: this.config.name,
+                                sourceType: "no_reply_status_cleanup",
+                                sourceId: `no-reply:${triggerId}:${noReplyMeta.messageId}`,
+                                deliveryKey: `trigger:${triggerId}:no-reply-status`,
+                                contentHash: "",
+                                content: "",
+                                attachmentsJson: "[]",
+                                replyToMessageId: lastHuman.messageId || "",
+                                deliveryMode: "patch_live_status",
+                                targetMessageId: noReplyMeta.messageId,
+                                deliveryMetaJson: JSON.stringify(noReplyMeta),
+                                textDelivered: true,
+                                cleanupPending: true,
+                            });
+                            if (cleanupId)
+                                await this.dispatchPendingDeliveries(chatId, lastHuman.messageId);
+                        }
+                        else {
+                            await liveStatus?.noReply().catch(() => { });
+                        }
+                    }
                 }
                 console.log(`[${this.config.name}] [${new Date().toISOString()}] ${shouldReply || hasAttachments ? 'Replied' : 'Skipped (empty/NO_REPLY)'} (${reply.length} chars, attachments=${parsedReply.attachments.length})`);
                 // Replace ack reactions with DONE only for trigger messages actually
@@ -1649,14 +1702,53 @@ export class FeishuBot {
         }
         return s;
     }
-    buildMarkdownCard(text) {
+    buildMarkdownCard(text, model) {
+        const elements = buildFeishuCardElements(text);
+        if (model?.trim()) {
+            elements.push({ tag: "hr" });
+            elements.push({
+                tag: "markdown",
+                content: `<font color='grey'>🧠 ${this.escapeCardText(model.trim())}</font>`,
+            });
+        }
         return {
             schema: "2.0",
             config: { wide_screen_mode: true },
-            body: {
-                elements: buildFeishuCardElements(text),
-            },
+            body: { elements },
+        };
+    }
+    deliveryOwnsVisiblePayload(item) {
+        if (!item || item.status === "failed")
+            return false;
+        if (item.content.trim())
+            return true;
+        try {
+            const attachments = JSON.parse(item.attachmentsJson || "[]");
+            return Array.isArray(attachments) && attachments.length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    completionSummary(meta, emoji = "✅") {
+        const en = meta.locale === "en";
+        return en
+            ? `${emoji} ${meta.toolCalls} tool call${meta.toolCalls === 1 ? "" : "s"} · ⏱ ${meta.elapsed}`
+            : `${emoji} 累计${meta.toolCalls} 次工具调用 · ⏱ 耗时${meta.elapsed}`;
+    }
+    /** Best-effort terminal cleanup for status-only rows and legacy v1.4.3
+     * outbox entries that once targeted the live-status card. */
+    async patchLiveStatusDoneSummary(messageId, meta, chatId) {
+        const view = {
+            title: meta.locale === "en" ? `✅ ${this.config.name} done` : `✅ ${this.config.name} 已完成`,
+            lines: [],
+            elapsed: meta.elapsed,
+            model: meta.model,
+            toolCalls: meta.toolCalls,
+            noReply: Boolean(meta.noReply),
+            state: "done",
         };
+        await this.patchLiveStatusCard(messageId, view, chatId);
     }
     formatUserVisibleError(err) {
         const raw = err instanceof Error ? err.message : String(err);
@@ -1711,16 +1803,14 @@ export class FeishuBot {
      * Heuristic: does this reply look truncated / cut off mid-task? Used as the
      * SOLE auto-retry trigger — if true, we ask the session a one-line “done?” probe.
      *
-     * Signals (any one is enough):
-     *   1. Unbalanced code fence — almost certainly cut off mid code block.
-     *   2. Trailing clause-joining punctuation (comma/colon/semicolon/、) — a
-     *      sentence was left hanging.
-     *   3. A dangling connector / lead-in (“然后”, “接下来”, “let me”, “and”…).
-     *   4. Ends without ANY sentence-ending punctuation / closer (no terminal
-     *      punctuation, closing bracket/quote, code fence, or wrap-up emoji).
-     *      Per Stephen: a reply that ends with no punctuation at all is also
-     *      treated as likely unfinished. A false positive only costs one cheap,
-     *      invisible confirmation probe; the session itself is the real arbiter.
+     * Signals are intentionally HIGH PRECISION. A reply is suspicious only when:
+     *   1. Its Markdown/code structure is visibly unclosed; or
+     *   2. It ends on punctuation/words that grammatically demand continuation.
+     *
+     * Merely lacking a final punctuation mark is NOT enough. Short answers,
+     * headings, model lists, paths, hashes, commands, English labels, and normal
+     * chat prose routinely end without punctuation; treating all of them as
+     * truncated caused obvious false-positive confirmation probes.
      */
     looksTruncated(text) {
         const t = (text || "").trim();
@@ -1730,21 +1820,19 @@ export class FeishuBot {
         const fences = (t.match(/```/g) || []).length;
         if (fences % 2 === 1)
             return true;
-        // (2a) Trailing clause-joining punctuation: a sentence was left hanging.
-        if (/[，,：:、;；]\s*$/u.test(t))
+        // (2a) A terminal comma/semicolon/、 strongly suggests an unfinished clause.
+        // A colon is only suspicious when it is a real prose lead-in near the end;
+        // URLs, times, drive letters, key:value and headings commonly end in colons.
+        if (/[，,、;；]\s*$/u.test(t))
             return true;
-        // (2b) Ends on an explicit continuation cue / lead-in.
-        if (/(接下来|然后|首先|现在我|让我|下一步|我先|我来|我接着|接着|稍等|let me|now i|next|first|\b(?:and|then|so|to|the|a)\b)\s*$/iu.test(t))
+        if (!/\b(?:https?|ftp):\/\/\S*$/iu.test(t)
+            && /[：:]\s*$/u.test(t)
+            && /(?:如下|包括|例如|原因|步骤|结论|结果|注意|namely|including|such as|because|steps?|results?|notes?)\s*[：:]\s*$/iu.test(t))
             return true;
-        // (2c) Ends without ANY sentence-ending punctuation / closer. A finished
-        //      reply normally ends with terminal punctuation, a closing bracket/
-        //      quote, a code fence, or a wrap-up emoji; if none of those are present
-        //      the reply was most likely cut off mid-sentence. (Stephen: “结尾没有
-        //      任何标点符号也算疑似未结束”.)
-        const endOk = /[。！？.!?…)\]」』】）"'`”’~～—✨✅👍🙏🎉🙌]\s*$/u.test(t)
-            || /```\s*$/.test(t)
-            || /[}\]]\s*$/.test(t);
-        if (!endOk)
+        // (2b) Explicit continuation cues only. Keep this narrow: generic sentence
+        // starters like “我先/我来/first/the/a” are valid standalone captions and
+        // were the largest source of false positives.
+        if (/(接下来|然后|下一步|我接着|接着|稍等|let me|next)\s*$/iu.test(t))
             return true;
         return false;
     }
@@ -1979,13 +2067,16 @@ export class FeishuBot {
         const sourceId = `discussion-system:${Date.now()}:${Math.random().toString(36).slice(2)}`;
         await this.enqueueAndDispatchDelivery(chatId, "discussion_system", sourceId, text);
     }
-    async enqueueAndDispatchDelivery(chatId, sourceType, sourceId, text, attachments = [], replyToMessageId, deliveryKey) {
+    async enqueueAndDispatchDelivery(chatId, sourceType, sourceId, text, attachments = [], replyToMessageId, deliveryKey, finalReplyModel) {
         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;
+        const deliveryMetaJson = finalReplyModel?.trim()
+            ? JSON.stringify({ model: finalReplyModel.trim() })
+            : "{}";
         if (sourceType === "verbose_transcript") {
             if (this.store.hasRecentSimilarDelivery(this.config.name, chatId, contentHash, 60_000, ["verbose_transcript"]))
                 return;
@@ -2009,62 +2100,239 @@ export class FeishuBot {
             content: text,
             attachmentsJson,
             replyToMessageId: replyToMessageId || "",
+            deliveryMode: "send",
+            targetMessageId: "",
+            deliveryMetaJson,
         });
-        if (deliveryId === null)
+        if (deliveryId === null) {
+            // Another path already owns this stable logical delivery (commonly the
+            // proactive callback racing the chat-final path). Never show the full
+            // answer again on a second card. The original outbox row remains the sole
+            // owner of text delivery; a different newly-frozen card is only collapsed.
+            const existing = this.store.getDeliveryByKey(this.config.name, chatId, finalDeliveryKey);
+            // A failed owner must not permanently poison a logical trigger. Re-enqueue
+            // the payload under a deterministic recovery key so a later authoritative
+            // delivery gets a fresh retry budget.
+            if (existing?.status === "failed" && !existing.textDelivered && text.trim()) {
+                if (existing.content.trim() === text.trim()) {
+                    this.store.requeueFailedDelivery(existing.id);
+                }
+                else {
+                    const recoveryKey = `${finalDeliveryKey}:recovery:${contentHash}`;
+                    this.store.enqueueDelivery({
+                        sessionKey: this.deliverySessionKey(chatId), chatId, botName: this.config.name,
+                        sourceType: `${sourceType}_recovery`, sourceId: `${sourceId}:recovery`,
+                        deliveryKey: recoveryKey, contentHash, content: text, attachmentsJson: "[]",
+                        replyToMessageId: replyToMessageId || "",
+                        deliveryMode: "send",
+                        targetMessageId: "",
+                        deliveryMetaJson,
+                    });
+                }
+            }
+            // The chat-final result is authoritative over an earlier proactive event.
+            // If proactive claimed the trigger key with different text, persist a
+            // deterministic correction row that patches the same card after it.
+            if (sourceId.startsWith("visible:") && existing?.sourceId.startsWith("proactive:")
+                && text.trim() && existing.content.trim() !== text.trim()) {
+                const correctionKey = `${finalDeliveryKey}:authoritative:${contentHash}`;
+                this.store.enqueueDelivery({
+                    sessionKey: this.deliverySessionKey(chatId), chatId, botName: this.config.name,
+                    sourceType: "assistant_visible_authoritative", sourceId: `${sourceId}:authoritative`,
+                    deliveryKey: correctionKey, contentHash, content: text, attachmentsJson: "[]",
+                    replyToMessageId: replyToMessageId || "",
+                    deliveryMode: "send",
+                    targetMessageId: "",
+                    deliveryMetaJson,
+                });
+            }
+            // A competing final may add attachments that the first owner did not see.
+            // Persist only the missing attachments in their own stable attachment row
+            // instead of silently dropping them or duplicating the final text.
+            const existingAttachments = (() => {
+                try {
+                    return JSON.parse(existing?.attachmentsJson || "[]");
+                }
+                catch {
+                    return [];
+                }
+            })();
+            const supplementalRows = this.store.listDeliveriesByKeyPrefix(this.config.name, chatId, `${finalDeliveryKey}:attachments:`);
+            const deliveredSupplementalKeys = new Set();
+            const incomingAttachmentKeys = new Set(attachments.map((a) => JSON.stringify(a)));
+            for (const row of supplementalRows) {
+                try {
+                    const rowAttachments = JSON.parse(row.attachmentsJson || "[]");
+                    const rowKeys = rowAttachments.map((a) => JSON.stringify(a));
+                    if (row.status === "failed") {
+                        // Revive a failed supplemental row when the same attachment is
+                        // explicitly presented again; its deterministic key would otherwise
+                        // make INSERT OR IGNORE suppress every future retry.
+                        if (rowKeys.some((key) => incomingAttachmentKeys.has(key))) {
+                            this.store.requeueFailedDelivery(row.id);
+                            for (const key of rowKeys)
+                                deliveredSupplementalKeys.add(key);
+                        }
+                        continue;
+                    }
+                    for (const key of rowKeys)
+                        deliveredSupplementalKeys.add(key);
+                }
+                catch { /* malformed legacy row: ignore and keep processing */ }
+            }
+            const existingKeys = new Set([
+                ...existingAttachments.map((a) => JSON.stringify(a)),
+                ...deliveredSupplementalKeys,
+            ]);
+            const missingAttachments = attachments.filter((a) => !existingKeys.has(JSON.stringify(a)));
+            if (missingAttachments.length > 0) {
+                const missingJson = JSON.stringify(missingAttachments);
+                this.store.enqueueDelivery({
+                    sessionKey: this.deliverySessionKey(chatId),
+                    chatId,
+                    botName: this.config.name,
+                    sourceType: `${sourceType}_attachments`,
+                    sourceId: `${sourceId}:attachments:${this.stableHash(missingJson)}`,
+                    deliveryKey: `${finalDeliveryKey}:attachments:${this.stableHash(missingJson)}`,
+                    contentHash: this.stableHash(`|${missingJson}`),
+                    content: "",
+                    attachmentsJson: missingJson,
+                    replyToMessageId: replyToMessageId || "",
+                    deliveryMode: "send",
+                    targetMessageId: "",
+                    deliveryMetaJson: "{}",
+                });
+            }
+            // Dispatch recovery/correction/supplement rows together in creation order.
+            await this.dispatchPendingDeliveries(chatId, replyToMessageId);
             return;
+        }
         await this.dispatchPendingDeliveries(chatId, replyToMessageId);
         if (sourceType === "assistant_visible" && (text.trim() || attachments.length > 0) && text.trim().toUpperCase() !== "NO_REPLY" && !this.isRuntimeFailureText(text.trim())) {
             this.lastRealDeliveryAt.set(chatId, Date.now());
         }
     }
+    scheduleDeliveryRetry(chatId, attempt) {
+        if (this.deliveryRetryTimers.has(chatId))
+            return;
+        const delay = Math.min(30_000, DELIVERY_RETRY_BASE_MS * Math.max(1, 2 ** Math.max(0, attempt - 1)));
+        const timer = setTimeout(() => {
+            this.deliveryRetryTimers.delete(chatId);
+            void this.dispatchPendingDeliveries(chatId).catch((err) => {
+                console.warn(`[${this.config.name}] scheduled delivery retry failed for ${chatId.slice(-8)}:`, this.errorSummary(err));
+            });
+        }, delay);
+        timer.unref?.();
+        this.deliveryRetryTimers.set(chatId, timer);
+    }
     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 {
+        let retryScheduled = false;
+        while (true) {
+            const pending = this.store.getPendingDeliveries(chatId, this.config.name, 50);
+            if (pending.length === 0)
+                break;
+            for (const item of pending) {
+                await this.sendOrdered(chatId, async () => {
                     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 === "verbose_transcript" || item.sourceType === "provider_error" || item.sourceType === "delayed_error");
-                        if (shouldReplyToSource) {
+                    let failureStage = "text";
+                    try {
+                        const attachments = JSON.parse(item.attachmentsJson || "[]");
+                        // Final text is always sent as a NEW message. Never patch it into the
+                        // older live-status card: user messages inserted during the run must
+                        // stay above the eventual final answer, not below it.
+                        if (item.content.trim() && !item.textDelivered) {
+                            const replyTarget = item.replyToMessageId || replyToMessageId;
+                            const shouldReplyToSource = Boolean(replyTarget) && (item.sourceType.startsWith("assistant_visible")
+                                || item.sourceType === "verbose_transcript"
+                                || item.sourceType === "provider_error"
+                                || item.sourceType === "delayed_error");
+                            let finalModel;
                             try {
-                                await this.replyMessage(replyTarget, item.content);
+                                const meta = JSON.parse(item.deliveryMetaJson || "{}");
+                                finalModel = typeof meta.model === "string" && meta.model.trim() ? meta.model.trim() : undefined;
+                            }
+                            catch { /* legacy/malformed metadata: send without model footer */ }
+                            if (shouldReplyToSource) {
+                                try {
+                                    await this.replyFinalMessage(replyTarget, item.content, finalModel);
+                                }
+                                catch {
+                                    await this.sendFinalMessage(chatId, item.content, finalModel);
+                                }
+                            }
+                            else {
+                                await this.sendFinalMessage(chatId, item.content, finalModel);
                             }
-                            catch (err) {
-                                console.warn(`[${this.config.name}] replyMessage failed, fallback to sendMessage:`, err.message);
-                                await this.sendMessage(chatId, item.content);
+                            // Rows created by v1.4.3 may still target a live-status card. Preserve
+                            // restart compatibility: send their text as a new message, then
+                            // collapse the old status card in the cleanup stage below.
+                            if (item.deliveryMode === "patch_live_status" && item.targetMessageId) {
+                                this.store.markDeliveryTextDeliveredWithCleanup(item.id);
+                            }
+                            else {
+                                this.store.markDeliveryTextDelivered(item.id);
                             }
                         }
-                        else {
-                            await this.sendMessage(chatId, item.content);
+                        // Attachments are independent from status-card cleanup. An unpatchable
+                        // or deleted status card must never block otherwise-sendable files.
+                        failureStage = "attachment";
+                        const cursor = Math.max(0, item.attachmentCursor || 0);
+                        for (let i = cursor; i < attachments.length; i++) {
+                            await this.sendBridgeAttachment(chatId, attachments[i]);
+                            this.store.markDeliveryAttachmentCursor(item.id, i + 1);
+                        }
+                        // Cleanup last, after all payload is visible. Cleanup-only rows and
+                        // attachment-only finals enter here as a separately retryable stage.
+                        const refreshedBeforeCleanup = this.store.getDeliveryByKey(item.botName, item.chatId, item.deliveryKey);
+                        const needsCleanup = Boolean(refreshedBeforeCleanup?.cleanupPending)
+                            || (!item.content.trim() && item.deliveryMode === "patch_live_status" && Boolean(item.targetMessageId));
+                        if (needsCleanup && item.targetMessageId) {
+                            failureStage = "cleanup";
+                            const meta = JSON.parse(item.deliveryMetaJson || "{}");
+                            await this.patchLiveStatusDoneSummary(item.targetMessageId, meta, chatId);
+                            this.store.markDeliveryCleanupPending(item.id, false);
                         }
-                    }
-                    for (const attachment of attachments)
-                        await this.sendBridgeAttachment(chatId, attachment);
-                    if (item.id)
                         this.store.markDeliveryDelivered(item.id);
-                }
-                catch (err) {
-                    if (this.isOutOfChatError(err))
-                        this.markCurrentBotUnavailable(chatId, err);
-                    if (item.id)
-                        this.store.markDeliveryFailed(item.id);
-                    const errorText = `⚠️ 附件发送失败：${this.errorSummary(err)}`;
-                    const replyTarget = item.replyToMessageId || replyToMessageId;
-                    try {
-                        if (replyTarget)
-                            await this.replyMessage(replyTarget, errorText);
-                        else
-                            await this.sendMessage(chatId, errorText);
                     }
-                    catch (notifyErr) {
-                        console.warn(`[${this.config.name}] Failed to notify attachment delivery error:`, this.errorSummary(notifyErr));
+                    catch (err) {
+                        if (this.isOutOfChatError(err))
+                            this.markCurrentBotUnavailable(chatId, err);
+                        const willRetry = this.store.retryDelivery(item.id, DELIVERY_MAX_ATTEMPTS);
+                        if (willRetry) {
+                            retryScheduled = true;
+                            console.warn(`[${this.config.name}] delivery ${item.id} ${failureStage} failed (attempt ${item.attempts + 1}/${DELIVERY_MAX_ATTEMPTS}); retry scheduled:`, this.errorSummary(err));
+                            this.scheduleDeliveryRetry(chatId, item.attempts + 1);
+                            return;
+                        }
+                        // Cleanup is cosmetic once text/attachments are visible. Exhausting
+                        // cleanup retries must not turn a successful answer into a scary
+                        // user-facing failure.
+                        if (failureStage === "cleanup") {
+                            this.store.markDeliveryDelivered(item.id);
+                            console.warn(`[${this.config.name}] status-card cleanup abandoned after ${DELIVERY_MAX_ATTEMPTS} attempts:`, this.errorSummary(err));
+                            return;
+                        }
+                        this.store.markDeliveryFailed(item.id);
+                        const label = failureStage === "attachment" ? "附件发送失败" : "最终回复发送失败";
+                        const errorText = `⚠️ ${label}（已重试 ${DELIVERY_MAX_ATTEMPTS} 次）：${this.errorSummary(err)}`;
+                        const replyTarget = item.replyToMessageId || replyToMessageId;
+                        try {
+                            if (replyTarget)
+                                await this.replyMessage(replyTarget, errorText);
+                            else
+                                await this.sendMessage(chatId, errorText);
+                        }
+                        catch (notifyErr) {
+                            console.warn(`[${this.config.name}] Failed to notify terminal delivery error:`, this.errorSummary(notifyErr));
+                        }
                     }
-                    throw err;
-                }
-            });
+                });
+            }
+            // Drain subsequent pages immediately after successful batches. If any row
+            // was returned to pending, honor its backoff timer instead of hot-looping.
+            if (pending.length < 50 || retryScheduled)
+                break;
         }
     }
     hasFreeModeBot(chatId) {
@@ -2236,7 +2504,7 @@ export class FeishuBot {
                 timestamp: Date.now(),
             });
             try {
-                await this.enqueueAndDispatchDelivery(chatId, "discussion", `discussion:${Date.now()}:${Math.random().toString(36).slice(2)}`, isVisible ? displayReply : "", parsedReply.attachments);
+                await this.enqueueAndDispatchDelivery(chatId, "discussion", `discussion:${Date.now()}:${Math.random().toString(36).slice(2)}`, isVisible ? displayReply : "", parsedReply.attachments, undefined, undefined, this.config.model);
             }
             catch (err) {
                 await liveStatus?.fail().catch(() => { });
@@ -2260,9 +2528,11 @@ export class FeishuBot {
         // the finished card does not take up much screen space.
         if (view.state === "done") {
             const statusEmoji = view.noReply ? "💤" : "✅";
-            const summary = en
-                ? `${statusEmoji} ${view.toolCalls} tool call${view.toolCalls === 1 ? "" : "s"} · ⏱ ${view.elapsed}`
-                : `${statusEmoji} 累计${view.toolCalls} 次工具调用 · ⏱ 耗时${view.elapsed}`;
+            const summary = this.completionSummary({
+                toolCalls: view.toolCalls,
+                elapsed: view.elapsed,
+                locale: en ? "en" : "zh",
+            }, statusEmoji);
             return {
                 schema: "2.0",
                 config: { update_multi: true, width_mode: "fill" },
@@ -2293,12 +2563,10 @@ export class FeishuBot {
             elements.push({ tag: "markdown", content: en ? "_working…_" : "_正在启动…_" });
         }
         elements.push({ tag: "hr" });
-        // Footer: elapsed time + model name.
-        const footerBits = [];
-        footerBits.push(en ? `⏱ ${view.elapsed}` : `⏱ 已用 ${view.elapsed}`);
-        if (view.model)
-            footerBits.push(`🧠 ${this.escapeCardText(view.model)}`);
-        elements.push({ tag: "markdown", content: `<font color='grey'>${footerBits.join("  ·  ")}</font>` });
+        // Running/failed status owns timing; model attribution belongs to the final
+        // reply card so the two messages have clear, non-duplicated responsibilities.
+        const footer = en ? `⏱ ${view.elapsed}` : `⏱ 已用 ${view.elapsed}`;
+        elements.push({ tag: "markdown", content: `<font color='grey'>${footer}</font>` });
         const template = view.state === "failed" ? "orange" : "blue";
         return {
             schema: "2.0",
@@ -2459,9 +2727,21 @@ export class FeishuBot {
     async deleteMessageById(messageId) {
         await this.client.im.v1.message.delete({ path: { message_id: messageId } });
     }
+    async replyFinalMessage(messageId, text, model) {
+        if (!model?.trim())
+            return this.replyMessage(messageId, text);
+        this.replyModelFooters.set(messageId, model.trim());
+        try {
+            return await this.replyMessage(messageId, text);
+        }
+        finally {
+            this.replyModelFooters.delete(messageId);
+        }
+    }
     async replyMessage(messageId, text) {
         // Use Feishu CardKit v2 markdown component for full Markdown rendering.
-        const card = this.buildMarkdownCard(text);
+        const model = this.replyModelFooters.get(messageId);
+        const card = this.buildMarkdownCard(text, model);
         try {
             const res = await this.client.im.message.reply({
                 path: { message_id: messageId },
@@ -2473,11 +2753,12 @@ export class FeishuBot {
             return res?.data?.message_id || res?.message_id;
         }
         catch {
-            // Fallback to plain text if card fails
+            // Fallback to plain text if card fails; retain model attribution.
+            const fallbackText = model?.trim() ? `${text}\n\n🧠 ${model.trim()}` : text;
             const res = await this.client.im.message.reply({
                 path: { message_id: messageId },
                 data: {
-                    content: JSON.stringify({ text }),
+                    content: JSON.stringify({ text: fallbackText }),
                     msg_type: "text",
                 },
             });
@@ -2751,13 +3032,12 @@ export class FeishuBot {
             catch (err) {
                 console.warn(`[${this.config.name}] Feishu doc conversion failed, falling back to file attachment:`, this.errorSummary(err));
                 const caption = attachment.caption?.trim();
-                await this.sendMessage(chatId, `${caption ? `${caption}\n` : ""}飞书文档创建失败，已改为 Markdown 文件附件发送。`);
                 await this.sendBridgeFileAttachment(chatId, filePath);
+                await this.sendMessage(chatId, `${caption ? `${caption}\n` : ""}飞书文档创建失败，已改为 Markdown 文件附件发送。`);
                 return;
             }
         }
-        if (attachment.caption?.trim())
-            await this.sendMessage(chatId, attachment.caption.trim());
+        const caption = attachment.caption?.trim();
         if (type === "image") {
             if (statSync(filePath).size > 10 * 1024 * 1024)
                 throw new Error(`Image too large (>10MB): ${filePath}`);
@@ -2775,9 +3055,13 @@ export class FeishuBot {
                     msg_type: "image",
                 },
             });
+            if (caption)
+                await this.sendMessage(chatId, caption);
             return;
         }
         await this.sendBridgeFileAttachment(chatId, filePath);
+        if (caption)
+            await this.sendMessage(chatId, caption);
     }
     async sendBridgeFileAttachment(chatId, filePath) {
         const uploaded = await this.client.im.file.create({
@@ -2802,8 +3086,20 @@ export class FeishuBot {
     /**
      * Send a proactive message to a chat (not a reply).
      */
+    async sendFinalMessage(chatId, text, model) {
+        if (!model?.trim())
+            return this.sendMessage(chatId, text);
+        this.sendModelFooters.set(chatId, model.trim());
+        try {
+            return await this.sendMessage(chatId, text);
+        }
+        finally {
+            this.sendModelFooters.delete(chatId);
+        }
+    }
     async sendMessage(chatId, text) {
-        const card = this.buildMarkdownCard(text);
+        const model = this.sendModelFooters.get(chatId);
+        const card = this.buildMarkdownCard(text, model);
         try {
             const res = await this.client.im.message.create({
                 params: { receive_id_type: "chat_id" },
@@ -2820,13 +3116,14 @@ export class FeishuBot {
             console.warn(`[${this.config.name}] sendMessage interactive failed:`, JSON.stringify(err?.response?.data || err?.data || { message: err.message }));
             if (this.isOutOfChatError(err))
                 this.markCurrentBotUnavailable(chatId, err);
-            // Fallback to plain text
+            // Fallback to plain text; retain model attribution.
             try {
+                const fallbackText = model?.trim() ? `${text}\n\n🧠 ${model.trim()}` : text;
                 const res = await this.client.im.message.create({
                     params: { receive_id_type: "chat_id" },
                     data: {
                         receive_id: chatId,
-                        content: JSON.stringify({ text }),
+                        content: JSON.stringify({ text: fallbackText }),
                         msg_type: "text",
                     },
                 });