openclaw-lark-multi-agent 1.4.3 → 1.4.5

package/dist/feishu-bot.js

@@ -9,7 +9,6 @@ import { basename, extname, join, resolve } from "path";
 import { getBridgeAttachmentsDir, getDataDir } from "./paths.js";
 import { buildFeishuCardElements } from "./markdown.js";
 import { discussionManager } from "./discussion-manager.js";
-import { resolveSessionFilePath, toolTrimCompactFile } from "./session-file-compactor.js";
 const require = createRequire(import.meta.url);
 const LMA_VERSION = require("../package.json").version;
 const MAX_BOT_STREAK = 10;
@@ -42,9 +41,13 @@ function steerInjectionPrefix(en) {
         || "[New message inserted by the user mid-task; please handle it together with the current task]";
     return en ? enText : zh;
 }
-// How many of the most-recent tool calls (and their results) tool-trim keeps
-// intact — recent tool calls may still be relevant to the agent's next step.
-function toolTrimKeepRecent() { return Number(process.env.OPENCLAW_LARK_MULTI_AGENT_TOOLTRIM_KEEP_RECENT || 3); }
+// Emergency transcript trim used only when semantic compaction cannot run.
+// The Gateway owns the transcript store (JSONL before 2026.8, SQLite after it),
+// so LMA must use sessions.compact instead of mutating storage directly.
+function compactFallbackMaxLines() {
+    const value = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_COMPACT_FALLBACK_MAX_LINES || 200);
+    return Number.isFinite(value) ? Math.max(20, Math.floor(value)) : 200;
+}
 // After a reply is delivered, if context usage reaches this percent, send the
 // user a one-time alert to compact. 0 disables the alert.
 function contextAlertPct() { return Number(process.env.OPENCLAW_LARK_MULTI_AGENT_CONTEXT_ALERT_PCT || 80); }
@@ -90,14 +93,26 @@ 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. */
     contextAlerted = new Map();
-    /** Active chatSend trigger target so final replies and proactive session.message share one delivery key. */
+    /** Active pre-admission target for the current chat operation. */
     activeDeliveryTargets = new Map();
+    /** Stable targets for concurrent runs in one chat. A steer admission can
+     * become an ordinary run while another run remains active. */
+    deliveryTargetsByRun = new Map();
+    /** Provisional native-steer correlations keyed by durable message row. If the
+     * message falls back to a normal run, cancel these before submission so a
+     * later identical steer cannot consume the stale observer/correlation. */
+    pendingSteerCleanups = new Map();
     adminOpenId;
     locale;
     configPath;
@@ -220,7 +235,10 @@ export class FeishuBot {
             }
         }
         catch (err) {
+            // Session/model setup is authoritative. Propagate policy/capability errors
+            // so the queue can notify the user and never continue on the wrong model.
             console.warn(`[${this.config.name}] ensureSession error:`, err.message);
+            throw err;
         }
         this.initializedSessions.add(sessionKey);
         // Subscribe to session events (proactive messages + tool calls)
@@ -232,19 +250,21 @@ export class FeishuBot {
                 const parsed = this.extractBridgeAttachments(text);
                 if (sourceType !== "verbose_transcript" && (parsed.text.trim() || parsed.attachments.length > 0))
                     this.cancelDelayedFailure(chatId);
-                const activeTarget = this.activeDeliveryTargets.get(chatId);
-                let finalStatusMeta;
+                const runTarget = meta?.runId ? this.deliveryTargetsByRun.get(this.deliveryRunTargetKey(chatId, meta.runId)) : undefined;
+                const candidateTarget = this.activeDeliveryTargets.get(chatId);
+                const activeTarget = runTarget || (candidateTarget && (!candidateTarget.runId || !meta?.runId || candidateTarget.runId === meta.runId)
+                    ? candidateTarget
+                    : undefined);
                 try {
+                    await this.enqueueAndDispatchDelivery(chatId, sourceType, this.deliverySourceId(sourceType === "verbose_transcript" ? "verbose" : "proactive", `${Date.now()}:${Math.random()}:${parsed.text.trim()}|${JSON.stringify(parsed.attachments)}`), parsed.text.trim(), parsed.attachments, activeTarget?.messageId, activeTarget ? `trigger:${activeTarget.triggerId}` : undefined, sourceType === "verbose_transcript" ? undefined : this.config.model);
                     if (sourceType !== "verbose_transcript" && (parsed.text.trim() || parsed.attachments.length > 0)) {
-                        finalStatusMeta = await activeTarget?.liveStatus?.prepareTerminalDelivery(false);
-                    }
-                    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, finalStatusMeta);
-                    if (!finalStatusMeta && sourceType !== "verbose_transcript" && (parsed.text.trim() || parsed.attachments.length > 0)) {
                         await activeTarget?.liveStatus?.complete().catch(() => { });
+                        if (meta?.runId && runTarget)
+                            this.releaseRunDeliveryTargetAfter(chatId, meta.runId, 30_000);
                     }
                 }
                 catch (err) {
-                    if (!finalStatusMeta && sourceType !== "verbose_transcript")
+                    if (sourceType !== "verbose_transcript")
                         await activeTarget?.liveStatus?.fail().catch(() => { });
                     throw err;
                 }
@@ -922,44 +942,81 @@ export class FeishuBot {
                 // Wrap the message so the agent knows it is a NEW user message inserted
                 // mid-task. The live-status line and reactions still key off the original.
                 const steerWrapped = `${steerInjectionPrefix(this.isEn(chatId))}\n${cleanText}`;
+                // Register the consumption observer before submitting so a fast
+                // session.message cannot race past the Feishu reaction transition.
+                await this.addReaction(messageId, "Typing").catch(() => { });
+                pending.push({ messageId, emoji: "Typing", rowId: insertedId });
+                this.pendingAckMessages.set(chatId, pending);
+                const norm = cleanText.replace(/\s+/g, " ").trim();
+                const stopWatchingConsumption = this.openclawClient.onSteerConsumed(sessionKeyForSteer, steerWrapped, (consumedText) => {
+                    const cn = (consumedText || "").replace(/\s+/g, " ").trim();
+                    if (cn !== norm && !cn.includes(norm))
+                        return false;
+                    // Only transcript commitment/consumption transfers durable custody.
+                    // Until this point the local pending trigger remains the fallback for
+                    // detached dispatch rejection or an admission that never consumed.
+                    if (insertedId > 0) {
+                        this.store.clearPendingTrigger(this.config.name, chatId, insertedId);
+                        this.pendingSteerCleanups.delete(insertedId);
+                    }
+                    void this.removeReaction(messageId, "Typing").catch(() => { });
+                    void this.addReaction(messageId, "Get").catch(() => { });
+                    const acks = this.pendingAckMessages.get(chatId) || [];
+                    for (const a of acks)
+                        if (a.messageId === messageId)
+                            a.emoji = "Get";
+                    this.pendingAckMessages.set(chatId, acks);
+                    return true;
+                });
+                const previousActiveTarget = this.activeDeliveryTargets.get(chatId);
+                // Install the new Feishu delivery target before admission. OpenClaw may
+                // race from "old run still active" to "dispatch a new run" while
+                // handling queueMode=steer, and that new run can emit events before the
+                // RPC response reaches LMA. Either outcome now routes to this message.
+                const releaseSteerDeliveryTarget = this.setActiveDeliveryTarget(chatId, insertedId, messageId);
+                const provisionalTarget = this.activeDeliveryTargets.get(chatId);
                 const steer = await this.openclawClient.steer(sessionKeyForSteer, steerWrapped, cleanText).catch(() => ({ status: "unavailable" }));
                 if (steer.status === "steered") {
-                    // Accepted into the active run's steer queue, but NOT yet consumed by
-                    // the model. Show "Typing" (awaiting insertion) now; flip to "Get" only
-                    // when the model actually consumes it at a tool-call boundary (a
-                    // matching sessionUser event), which also renders it on the live-status
-                    // card in correct time order.
-                    await this.addReaction(messageId, "Typing").catch(() => { });
-                    pending.push({ messageId, emoji: "Typing", rowId: insertedId });
-                    this.pendingAckMessages.set(chatId, pending);
-                    const norm = cleanText.replace(/\s+/g, " ").trim();
-                    this.openclawClient.onSteerConsumed(sessionKeyForSteer, (consumedText) => {
-                        const cn = (consumedText || "").replace(/\s+/g, " ").trim();
-                        if (cn !== norm && !cn.includes(norm))
-                            return false; // not ours; keep waiting
-                        // Flip Typing -> Get now that the model has actually read it.
-                        void this.removeReaction(messageId, "Typing").catch(() => { });
-                        void this.addReaction(messageId, "Get").catch(() => { });
-                        const acks = this.pendingAckMessages.get(chatId) || [];
-                        for (const a of acks)
-                            if (a.messageId === messageId)
-                                a.emoji = "Get";
-                        this.pendingAckMessages.set(chatId, acks);
-                        return true; // one-shot: matched, remove this callback
-                    });
-                    console.log(`[${this.config.name}] Agent busy for ${chatId.slice(-8)}, STEERED (awaiting consumption): "${cleanText.substring(0, 50)}..."`);
-                    // The message is already in DB with a pending trigger. Clear that
-                    // trigger so it is NOT re-run as a separate follow-up batch after the
-                    // current run ends — it has already been injected into this run.
-                    if (insertedId > 0)
-                        this.store.clearPendingTrigger(this.config.name, chatId, insertedId);
+                    if (insertedId > 0) {
+                        this.pendingSteerCleanups.set(insertedId, () => {
+                            stopWatchingConsumption();
+                            if ("cancelPending" in steer)
+                                steer.cancelPending?.();
+                        });
+                    }
+                    if (provisionalTarget && steer.runId) {
+                        provisionalTarget.runId = steer.runId;
+                        this.bindRunDeliveryTarget(chatId, steer.runId, provisionalTarget);
+                        this.releaseRunDeliveryTargetAfter(chatId, steer.runId, 30 * 60_000);
+                    }
+                    // A steer admission may become an ordinary new run. Keep its run-bound
+                    // reply target long enough for a real tool-heavy run; stale targets are
+                    // harmless because later runIds no longer match.
+                    releaseSteerDeliveryTarget(30 * 60_000);
+                    // RPC acknowledgment is provisional. Keep the durable pending trigger
+                    // until session.message confirms consumption; otherwise the normal
+                    // queue drains it after the current run.
+                    console.log(`[${this.config.name}] Agent busy for ${chatId.slice(-8)}, steer accepted (awaiting transcript consumption): "${cleanText.substring(0, 50)}..."`);
                     return;
                 }
-                // Could not steer (no active run raced to idle, rejected, or plugin
-                // unavailable): fall back to the original behavior — queue and wait.
-                await this.addReaction(messageId, "Typing").catch(() => { });
-                pending.push({ messageId, emoji: "Typing", rowId: insertedId });
-                this.pendingAckMessages.set(chatId, pending);
+                // Native steer was not accepted. Restore the previous run's routing
+                // target and keep the already-created trigger/reaction for normal drain.
+                stopWatchingConsumption();
+                if ("cancelPending" in steer)
+                    steer.cancelPending?.();
+                const currentTarget = this.activeDeliveryTargets.get(chatId);
+                if (currentTarget && currentTarget.token === provisionalTarget?.token) {
+                    if (currentTarget.timer)
+                        clearTimeout(currentTarget.timer);
+                    this.activeDeliveryTargets.delete(chatId);
+                    if (previousActiveTarget) {
+                        const releaseRestoredTarget = this.setActiveDeliveryTarget(chatId, previousActiveTarget.triggerId, previousActiveTarget.messageId);
+                        const restored = this.activeDeliveryTargets.get(chatId);
+                        if (restored)
+                            restored.liveStatus = previousActiveTarget.liveStatus;
+                        releaseRestoredTarget();
+                    }
+                }
                 console.log(`[${this.config.name}] Agent busy for ${chatId.slice(-8)} (steer=${steer.status}), queuing: "${cleanText.substring(0, 50)}..."`);
                 return; // Message is in DB, will be picked up when agent finishes
             }
@@ -1189,6 +1246,16 @@ export class FeishuBot {
             const runStartStopEpoch = this.stopEpoch.get(chatId) || 0;
             const mergedContent = mergedTriggers.map((m) => m.content).join("\n");
             const mergedTriggerIds = mergedTriggers.map((m) => m.id || 0).filter(Boolean);
+            // These rows are now taking the ordinary queue path. Remove any stale
+            // provisional native-steer correlation before chat.send so a later
+            // identical steer cannot acknowledge the wrong Feishu message.
+            for (const id of mergedTriggerIds) {
+                const cleanup = this.pendingSteerCleanups.get(id);
+                if (cleanup) {
+                    cleanup();
+                    this.pendingSteerCleanups.delete(id);
+                }
+            }
             const droppedTriggerIds = droppedMergedTriggers.map((m) => m.id || 0).filter(Boolean);
             const mergedTriggerIdSet = new Set(mergedTriggerIds);
             const completedTriggerIdSet = new Set([...droppedTriggerIds, ...mergedTriggerIds]);
@@ -1237,7 +1304,28 @@ export class FeishuBot {
             }
             const processedMessages = [...contextMsgs, ...mergedTriggers].filter((m) => m.id);
             const queueStartedAt = Date.now();
-            const sessionKey = await this.ensureSession(chatId);
+            let sessionKey;
+            try {
+                sessionKey = await this.ensureSession(chatId);
+            }
+            catch (err) {
+                // Model policy/capability failures happen before chat.send. Clear the
+                // busy marker, report the actionable error, and retire only this batch
+                // so the chat cannot remain wedged indefinitely.
+                this.busyChats.set(chatId, 0);
+                const errorText = this.formatUserVisibleError(err);
+                if (lastHuman.messageId) {
+                    await this.enqueueAndDispatchDelivery(chatId, "provider_error", `trigger:${triggerId}:session-setup-error`, errorText, [], lastHuman.messageId, `trigger:${triggerId}:session-setup-error`).catch(() => { });
+                }
+                for (const id of mergedTriggerIds)
+                    this.store.clearPendingTrigger(this.config.name, chatId, id);
+                this.store.markMessagesSynced(this.config.name, chatId, mergedTriggerIds, `${this.config.name}:${chatId}:${triggerId}:session-setup-failed`);
+                if (mergedTriggerIds.length > 0)
+                    this.store.markSynced(this.config.name, chatId, Math.max(...mergedTriggerIds));
+                const pendingAcks = this.pendingAckMessages.get(chatId) || [];
+                this.pendingAckMessages.set(chatId, pendingAcks.filter((ack) => !completedTriggerIdSet.has(ack.rowId)));
+                break;
+            }
             console.log(`[${this.config.name}] Sending ${mergedTriggers.length} trigger(s) as 1 run to OpenClaw for ${chatId.slice(-8)} (context=${contextMsgs.length}, dropped=${droppedTriggerIds.length})`);
             // Update reactions: queued messages → sent (GET/了解)
             const pendingAcks = this.pendingAckMessages.get(chatId) || [];
@@ -1303,6 +1391,12 @@ export class FeishuBot {
                         },
                         onSubmitted: (runId) => {
                             runAcceptedByOpenClaw = true;
+                            const target = this.activeDeliveryTargets.get(chatId);
+                            if (target?.triggerId === triggerId) {
+                                target.runId = runId;
+                                this.bindRunDeliveryTarget(chatId, runId, target);
+                                this.releaseRunDeliveryTargetAfter(chatId, runId, 30 * 60_000);
+                            }
                             // Refine state for logs/idempotent sync rows when OpenClaw returns
                             // a runId. markSubmittedBatch is idempotent due to local flags and
                             // INSERT OR IGNORE in message_sync.
@@ -1435,21 +1529,12 @@ export class FeishuBot {
                         await liveStatus?.complete().catch(() => { });
                     }
                     else {
-                        let finalStatusMeta;
                         try {
-                            // If a live-status card exists, freeze it and persist enough
-                            // metadata in the outbox to turn THIS SAME card into the final
-                            // answer. Fast replies / disabled status / create failures have no
-                            // card and transparently use the existing new-message path.
-                            // Text answers become the card body. Attachment-only results still
-                            // freeze the card so the outbox can durably collapse it to a done
-                            // summary (including disabled-but-existing cards).
-                            if ((shouldReply && visibleReply.trim()) || hasAttachments) {
-                                finalStatusMeta = await liveStatus?.prepareTerminalDelivery(false);
-                            }
-                            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}`, finalStatusMeta);
-                            if (!finalStatusMeta)
-                                await liveStatus?.complete();
+                            // 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.
                             for (const id of mergedTriggerIds)
@@ -1461,11 +1546,7 @@ export class FeishuBot {
                             // enqueueAndDispatchDelivery already sent a user-visible delivery
                             // failure. Do not fall through to the generic provider-error path;
                             // that creates a second misleading "bot did not complete" message.
-                            // If the card was not frozen for merged final delivery, retain the
-                            // normal interrupted status. A prepared card has already been
-                            // patched/fallen back by the durable dispatcher.
-                            if (!finalStatusMeta)
-                                await liveStatus?.fail().catch(() => { });
+                            await liveStatus?.fail().catch(() => { });
                             console.warn(`[${this.config.name}] assistant delivery failed after notification:`, this.errorSummary(err));
                         }
                     }
@@ -1714,13 +1795,19 @@ 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) {
@@ -1738,33 +1825,12 @@ export class FeishuBot {
     }
     completionSummary(meta, emoji = "✅") {
         const en = meta.locale === "en";
-        const core = en
+        return en
             ? `${emoji} ${meta.toolCalls} tool call${meta.toolCalls === 1 ? "" : "s"} · ⏱ ${meta.elapsed}`
             : `${emoji} 累计${meta.toolCalls} 次工具调用 · ⏱ 耗时${meta.elapsed}`;
-        return meta.model ? `${core} · 🧠 ${this.escapeCardText(meta.model)}` : core;
     }
-    /** Final answer card used to replace the running live-status card in place. */
-    buildFinalAnswerCard(text, meta) {
-        const elements = buildFeishuCardElements(text);
-        elements.push({ tag: "hr" });
-        elements.push({
-            tag: "markdown",
-            content: `<font color='grey'>${this.completionSummary(meta)}</font>`,
-        });
-        return {
-            schema: "2.0",
-            config: { update_multi: true, width_mode: "fill" },
-            body: { elements },
-        };
-    }
-    async patchFinalAnswerCard(messageId, text, meta, _chatId) {
-        await this.client.im.message.patch({
-            path: { message_id: messageId },
-            data: { content: JSON.stringify(this.buildFinalAnswerCard(text, meta)) },
-        });
-    }
-    /** Best-effort cleanup when a final-card patch was too large/failed and the
-     * answer had to be delivered as a separate message. */
+    /** 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} 已完成`,
@@ -2039,18 +2105,48 @@ export class FeishuBot {
             clearTimeout(timer);
         this.delayedFailureTimers.delete(chatId);
     }
+    deliveryRunTargetKey(chatId, runId) {
+        return `${chatId}\u0000${runId}`;
+    }
+    bindRunDeliveryTarget(chatId, runId, target) {
+        if (!runId)
+            return;
+        const key = this.deliveryRunTargetKey(chatId, runId);
+        const previous = this.deliveryTargetsByRun.get(key);
+        if (previous?.timer)
+            clearTimeout(previous.timer);
+        this.deliveryTargetsByRun.set(key, {
+            triggerId: target.triggerId,
+            messageId: target.messageId,
+            liveStatus: target.liveStatus,
+        });
+    }
+    releaseRunDeliveryTargetAfter(chatId, runId, delayMs) {
+        const key = this.deliveryRunTargetKey(chatId, runId);
+        const target = this.deliveryTargetsByRun.get(key);
+        if (!target)
+            return;
+        if (target.timer)
+            clearTimeout(target.timer);
+        const timer = setTimeout(() => {
+            if (this.deliveryTargetsByRun.get(key)?.timer === timer)
+                this.deliveryTargetsByRun.delete(key);
+        }, delayMs);
+        timer.unref?.();
+        target.timer = timer;
+    }
     setActiveDeliveryTarget(chatId, triggerId, messageId) {
         const existing = this.activeDeliveryTargets.get(chatId);
         if (existing?.timer)
             clearTimeout(existing.timer);
         const token = Symbol(`${chatId}:${triggerId}`);
         this.activeDeliveryTargets.set(chatId, { triggerId, messageId, token });
-        return () => {
+        return (delayMs = 60_000) => {
             const timer = setTimeout(() => {
                 const current = this.activeDeliveryTargets.get(chatId);
                 if (current?.token === token)
                     this.activeDeliveryTargets.delete(chatId);
-            }, 60_000);
+            }, delayMs);
             const current = this.activeDeliveryTargets.get(chatId);
             if (current?.token === token)
                 current.timer = timer;
@@ -2094,58 +2190,27 @@ 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, liveStatusFinal) {
+    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 enqueueDurableStatusCleanup = async (meta, suffix) => {
-            const cleanupId = this.store.enqueueDelivery({
-                sessionKey: this.deliverySessionKey(chatId),
-                chatId,
-                botName: this.config.name,
-                sourceType: `${sourceType}_status_cleanup`,
-                sourceId: `${sourceId}:status-cleanup:${suffix}:${meta.messageId}`,
-                deliveryKey: `${finalDeliveryKey}:status-cleanup:${suffix}:${meta.messageId}`,
-                contentHash: "",
-                content: "",
-                attachmentsJson: "[]",
-                replyToMessageId: replyToMessageId || "",
-                deliveryMode: "patch_live_status",
-                targetMessageId: meta.messageId,
-                deliveryMetaJson: JSON.stringify(meta),
-                textDelivered: true,
-                cleanupPending: true,
-            });
-            if (cleanupId)
-                await this.dispatchPendingDeliveries(chatId, replyToMessageId);
-        };
-        const finishDedupedStatus = async () => {
-            if (!liveStatusFinal)
-                return;
-            await enqueueDurableStatusCleanup(liveStatusFinal, "content-dedupe");
-        };
+        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"])) {
-                await finishDedupedStatus();
+            if (this.store.hasRecentSimilarDelivery(this.config.name, chatId, contentHash, 60_000, ["verbose_transcript"]))
                 return;
-            }
-            if (this.store.hasRecentOverlappingDelivery(this.config.name, chatId, text, attachmentsJson, 60_000, 8, ["verbose_transcript"])) {
-                await finishDedupedStatus();
+            if (this.store.hasRecentOverlappingDelivery(this.config.name, chatId, text, attachmentsJson, 60_000, 8, ["verbose_transcript"]))
                 return;
-            }
         }
         else if (!deliveryKey) {
-            if (this.store.hasRecentSimilarDelivery(this.config.name, chatId, contentHash, 60_000, [sourceType])) {
-                await finishDedupedStatus();
+            if (this.store.hasRecentSimilarDelivery(this.config.name, chatId, contentHash, 60_000, [sourceType]))
                 return;
-            }
-            if (this.store.hasRecentOverlappingDelivery(this.config.name, chatId, text, attachmentsJson, 60_000, 8, [sourceType])) {
-                await finishDedupedStatus();
+            if (this.store.hasRecentOverlappingDelivery(this.config.name, chatId, text, attachmentsJson, 60_000, 8, [sourceType]))
                 return;
-            }
         }
         const deliveryId = this.store.enqueueDelivery({
             sessionKey: this.deliverySessionKey(chatId),
@@ -2158,9 +2223,9 @@ export class FeishuBot {
             content: text,
             attachmentsJson,
             replyToMessageId: replyToMessageId || "",
-            deliveryMode: liveStatusFinal ? "patch_live_status" : "send",
-            targetMessageId: liveStatusFinal?.messageId || "",
-            deliveryMetaJson: liveStatusFinal ? JSON.stringify(liveStatusFinal) : "{}",
+            deliveryMode: "send",
+            targetMessageId: "",
+            deliveryMetaJson,
         });
         if (deliveryId === null) {
             // Another path already owns this stable logical delivery (commonly the
@@ -2182,9 +2247,9 @@ export class FeishuBot {
                         sourceType: `${sourceType}_recovery`, sourceId: `${sourceId}:recovery`,
                         deliveryKey: recoveryKey, contentHash, content: text, attachmentsJson: "[]",
                         replyToMessageId: replyToMessageId || "",
-                        deliveryMode: liveStatusFinal ? "patch_live_status" : "send",
-                        targetMessageId: liveStatusFinal?.messageId || "",
-                        deliveryMetaJson: liveStatusFinal ? JSON.stringify(liveStatusFinal) : "{}",
+                        deliveryMode: "send",
+                        targetMessageId: "",
+                        deliveryMetaJson,
                     });
                 }
             }
@@ -2199,11 +2264,9 @@ export class FeishuBot {
                     sourceType: "assistant_visible_authoritative", sourceId: `${sourceId}:authoritative`,
                     deliveryKey: correctionKey, contentHash, content: text, attachmentsJson: "[]",
                     replyToMessageId: replyToMessageId || "",
-                    deliveryMode: liveStatusFinal || existing.targetMessageId ? "patch_live_status" : "send",
-                    targetMessageId: liveStatusFinal?.messageId || existing.targetMessageId,
-                    deliveryMetaJson: liveStatusFinal?.messageId
-                        ? JSON.stringify(liveStatusFinal)
-                        : existing.deliveryMetaJson,
+                    deliveryMode: "send",
+                    targetMessageId: "",
+                    deliveryMetaJson,
                 });
             }
             // A competing final may add attachments that the first owner did not see.
@@ -2265,34 +2328,6 @@ export class FeishuBot {
             }
             // Dispatch recovery/correction/supplement rows together in creation order.
             await this.dispatchPendingDeliveries(chatId, replyToMessageId);
-            // A correction/recovery row can intentionally patch the newly-frozen card.
-            // Never enqueue a compact cleanup for that same card afterwards: it would
-            // overwrite the authoritative answer that was just patched into place.
-            const competingRows = this.store.listDeliveriesByKeyPrefix(this.config.name, chatId, `${finalDeliveryKey}:`);
-            const finalCardOwnsVisiblePayload = Boolean(liveStatusFinal) && [existing, ...competingRows]
-                .some((row) => row?.targetMessageId === liveStatusFinal.messageId && this.deliveryOwnsVisiblePayload(row));
-            if (liveStatusFinal && existing?.targetMessageId !== liveStatusFinal.messageId && !finalCardOwnsVisiblePayload) {
-                const cleanupJson = JSON.stringify(liveStatusFinal);
-                const cleanupId = this.store.enqueueDelivery({
-                    sessionKey: this.deliverySessionKey(chatId),
-                    chatId,
-                    botName: this.config.name,
-                    sourceType: `${sourceType}_status_cleanup`,
-                    sourceId: `${sourceId}:status-cleanup:${liveStatusFinal.messageId}`,
-                    deliveryKey: `${finalDeliveryKey}:status-cleanup:${liveStatusFinal.messageId}`,
-                    contentHash: "",
-                    content: "",
-                    attachmentsJson: "[]",
-                    replyToMessageId: replyToMessageId || "",
-                    deliveryMode: "patch_live_status",
-                    targetMessageId: liveStatusFinal.messageId,
-                    deliveryMetaJson: cleanupJson,
-                    textDelivered: true,
-                    cleanupPending: true,
-                });
-                if (cleanupId)
-                    await this.dispatchPendingDeliveries(chatId, replyToMessageId);
-            }
             return;
         }
         await this.dispatchPendingDeliveries(chatId, replyToMessageId);
@@ -2326,49 +2361,39 @@ export class FeishuBot {
                     let failureStage = "text";
                     try {
                         const attachments = JSON.parse(item.attachmentsJson || "[]");
-                        // Text first. A patch error is ambiguous: Feishu may have applied the
-                        // patch but timed out returning the response. Do NOT immediately create
-                        // a second visible answer. Retry the same idempotent patch; only after
-                        // the retry budget is exhausted do we fall back to a new message.
+                        // 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 = replyTarget && (item.sourceType === "assistant_visible" || item.sourceType === "verbose_transcript" || item.sourceType === "provider_error" || item.sourceType === "delayed_error");
-                            if (item.deliveryMode === "patch_live_status" && item.targetMessageId) {
+                            const shouldReplyToSource = Boolean(replyTarget) && (item.sourceType.startsWith("assistant_visible")
+                                || item.sourceType === "verbose_transcript"
+                                || item.sourceType === "provider_error"
+                                || item.sourceType === "delayed_error");
+                            let finalModel;
+                            try {
+                                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 {
-                                    const meta = JSON.parse(item.deliveryMetaJson || "{}");
-                                    await this.patchFinalAnswerCard(item.targetMessageId, item.content, meta, chatId);
-                                    this.store.markDeliveryTextDelivered(item.id);
+                                    await this.replyFinalMessage(replyTarget, item.content, finalModel);
                                 }
-                                catch (patchErr) {
-                                    if (item.attempts + 1 < DELIVERY_MAX_ATTEMPTS)
-                                        throw patchErr;
-                                    console.warn(`[${this.config.name}] final-card patch exhausted; falling back to new message:`, this.errorSummary(patchErr));
-                                    if (shouldReplyToSource) {
-                                        try {
-                                            await this.replyMessage(replyTarget, item.content);
-                                        }
-                                        catch {
-                                            await this.sendMessage(chatId, item.content);
-                                        }
-                                    }
-                                    else {
-                                        await this.sendMessage(chatId, item.content);
-                                    }
-                                    this.store.markDeliveryTextDeliveredWithCleanup(item.id);
+                                catch {
+                                    await this.sendFinalMessage(chatId, item.content, finalModel);
                                 }
                             }
                             else {
-                                if (shouldReplyToSource) {
-                                    try {
-                                        await this.replyMessage(replyTarget, item.content);
-                                    }
-                                    catch {
-                                        await this.sendMessage(chatId, item.content);
-                                    }
-                                }
-                                else {
-                                    await this.sendMessage(chatId, item.content);
-                                }
+                                await this.sendFinalMessage(chatId, item.content, finalModel);
+                            }
+                            // 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);
                             }
                         }
@@ -2589,7 +2614,6 @@ export class FeishuBot {
             const roundMarker = `—— 第 ${meta.round}/${meta.maxRounds} 轮 · ${this.config.name}`;
             displayReply = `${displayReply}\n\n${roundMarker}`;
         }
-        let finalStatusMeta;
         if (isVisible || parsedReply.attachments.length > 0) {
             const storedContent = [displayReply, ...parsedReply.attachments.map((a) => `[Attachment: ${a.type || "file"} ${a.path}]`)]
                 .filter(Boolean)
@@ -2603,14 +2627,10 @@ export class FeishuBot {
                 timestamp: Date.now(),
             });
             try {
-                if (isVisible || parsedReply.attachments.length > 0) {
-                    finalStatusMeta = await liveStatus?.prepareTerminalDelivery(false);
-                }
-                await this.enqueueAndDispatchDelivery(chatId, "discussion", `discussion:${Date.now()}:${Math.random().toString(36).slice(2)}`, isVisible ? displayReply : "", parsedReply.attachments, undefined, undefined, finalStatusMeta);
+                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) {
-                if (!finalStatusMeta)
-                    await liveStatus?.fail().catch(() => { });
+                await liveStatus?.fail().catch(() => { });
                 throw err;
             }
         }
@@ -2619,7 +2639,7 @@ export class FeishuBot {
         if (!isVisible && parsedReply.attachments.length === 0) {
             await liveStatus?.noReply().catch(() => { });
         }
-        else if (!finalStatusMeta) {
+        else {
             await liveStatus?.complete().catch(() => { });
         }
         return { botName: this.config.name, text: cleanVisibleReply, visible: isVisible };
@@ -2634,7 +2654,6 @@ export class FeishuBot {
             const summary = this.completionSummary({
                 toolCalls: view.toolCalls,
                 elapsed: view.elapsed,
-                model: view.model,
                 locale: en ? "en" : "zh",
             }, statusEmoji);
             return {
@@ -2667,12 +2686,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",
@@ -2756,8 +2773,8 @@ export class FeishuBot {
             };
         }
         // Running: phase line + ticking elapsed footer.
-        const phaseLine = view.phase === "tool-trim"
-            ? (en ? "🧹 Native compaction is slow — switching to fast trim…" : "🧹 原生压缩较慢，已切换快速压缩…")
+        const phaseLine = view.phase === "transcript-trim"
+            ? (en ? "🧹 Semantic compaction unavailable — trimming transcript safely…" : "🧹 语义压缩不可用，正在安全裁剪转录…")
             : (en ? "🧹 Compacting session…" : "🧹 正在压缩 session…");
         const footer = en ? `⏱ ${view.elapsed}` : `⏱ 已用 ${view.elapsed}`;
         return {
@@ -2833,9 +2850,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 },
@@ -2847,11 +2876,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",
                 },
             });
@@ -3179,8 +3209,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" },
@@ -3197,13 +3239,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",
                     },
                 });
@@ -3489,17 +3532,16 @@ export class FeishuBot {
      * Handle /compact command: compress session context.
      */
     /**
-     * Compact a session with a fallback chain:
-     *   1. OpenClaw's native (LLM-summary) compaction — best semantics.
-     *   2. If that did not compact (or threw), fall back to "tool-trim": rewrite
-     *      the transcript file to drop tool calls/results while keeping the
-     *      conversation. This needs no model, so it works no matter how large the
-     *      session is (the native path itself fails to fit an oversized session
-     *      into the model). A backup is always written before any file change.
-     * Returns a structured result describing what happened.
+     * Compact a session with a Gateway-owned fallback chain:
+     *   1. Semantic compaction through `sessions.compact`.
+     *   2. If summarization cannot run, ask the same RPC to retain only a bounded
+     *      transcript tail via `maxLines`. This works with legacy JSONL and the
+     *      SQLite session store introduced in OpenClaw 2026.8.x, and preserves
+     *      OpenClaw's write locks, transcript invariants, and migration ownership.
+     *
+     * LMA deliberately never opens or rewrites OpenClaw transcript storage.
      */
     async compactWithFallback(sessionKey, onPhase) {
-        // 1. Native compaction first.
         let nativeReason;
         try {
             const res = await this.openclawClient.compactSession(sessionKey);
@@ -3510,48 +3552,41 @@ export class FeishuBot {
         catch (err) {
             nativeReason = err.message;
         }
-        // 2. Fall back to tool-trim on the transcript file. Tell the caller so a
-        //    progress card can flip from "compacting" to "fast-trim" (this is the
-        //    slow→still-working transition the user most needs to see).
-        onPhase?.("tool-trim");
-        let sessionId;
+        onPhase?.("transcript-trim");
+        const maxLines = compactFallbackMaxLines();
         try {
-            const info = await this.openclawClient.getSessionInfo(sessionKey);
-            sessionId = info?.session?.sessionId;
-        }
-        catch {
-            // ignore; handled below
-        }
-        if (!sessionId) {
-            return { compacted: false, method: "none", reason: nativeReason || "could not resolve session file" };
-        }
-        const filePath = resolveSessionFilePath(sessionKey, sessionId);
-        if (!filePath) {
-            return { compacted: false, method: "none", reason: nativeReason || "transcript file not found" };
-        }
-        const trim = toolTrimCompactFile(filePath, toolTrimKeepRecent());
-        if (!trim.ok) {
-            return { compacted: false, method: "none", reason: trim.reason || "tool-trim failed" };
+            const trimmed = await this.openclawClient.compactSession(sessionKey, { maxLines });
+            if (trimmed?.compacted === true) {
+                const kept = typeof trimmed?.kept === "number" ? trimmed.kept : maxLines;
+                return {
+                    compacted: true,
+                    method: "transcript-trim",
+                    detail: `kept ${kept} transcript events`,
+                };
+            }
+            const trimReason = typeof trimmed?.reason === "string" ? trimmed.reason : undefined;
+            return {
+                compacted: false,
+                method: "none",
+                reason: trimReason || nativeReason || "transcript trim made no change",
+            };
         }
-        const before = trim.bytesBefore || 0;
-        const after = trim.bytesAfter || 0;
-        if (before > 0 && after >= before) {
-            // Nothing meaningful trimmed.
-            return { compacted: false, method: "none", reason: trim.reason || "no tool content to trim" };
+        catch (err) {
+            const trimReason = err.message;
+            return {
+                compacted: false,
+                method: "none",
+                reason: nativeReason
+                    ? `semantic compaction: ${nativeReason}; transcript trim: ${trimReason}`
+                    : trimReason,
+            };
         }
-        const pct = before > 0 ? Math.round((1 - after / before) * 100) : 0;
-        const mb = (n) => `${(n / 1024 / 1024).toFixed(1)}M`;
-        return {
-            compacted: true,
-            method: "tool-trim",
-            detail: `${mb(before)}→${mb(after)} (-${pct}%)`,
-        };
     }
     async handleCompactCommand(chatId, messageId) {
         const sessionKey = this.getSessionKey(chatId);
         const en = this.isEn(chatId);
         // Large sessions can take tens of seconds to compact (native compaction may
-        // even time out before the tool-trim fallback kicks in). Show a ticking
+        // even time out before the transcript-trim fallback kicks in). Show a ticking
         // "compacting…" card so the user can SEE it is working instead of staring at
         // nothing and assuming nothing is happening. The card is created lazily, so
         // a fast compaction that finishes quickly never flashes a card at all.
@@ -3563,19 +3598,24 @@ export class FeishuBot {
         progress.start();
         try {
             const r = await this.compactWithFallback(sessionKey, (phase) => {
-                if (phase === "tool-trim")
-                    void progress.toToolTrim().catch(() => { });
+                if (phase === "transcript-trim")
+                    void progress.toTranscriptTrim().catch(() => { });
             });
             if (r.compacted) {
                 // If a card was shown, patch it in place; otherwise (fast finish, no card)
                 // fall back to a normal reply so the user still gets confirmation.
-                const detail = r.method === "tool-trim" && r.detail
-                    ? (en ? `tool-trim ${r.detail}` : `删工具调用 ${r.detail}`)
+                const localizedTrimDetail = r.detail
+                    ?.replace("kept ", en ? "kept " : "保留最近 ")
+                    .replace(" transcript events", en ? " transcript events" : " 条转录事件");
+                const detail = r.method === "transcript-trim" && localizedTrimDetail
+                    ? (en ? `transcript trim: ${localizedTrimDetail}` : `转录裁剪：${localizedTrimDetail}`)
                     : (en ? "native" : "原生压缩");
                 await progress.done(detail);
                 if (!progress.id) {
-                    await this.replyMessage(messageId, r.method === "tool-trim"
-                        ? (en ? `✅ Session compacted (tool-trim${r.detail ? " " + r.detail : ""})` : `✅ Session 已压缩（删工具调用${r.detail ? " " + r.detail : ""}）`)
+                    await this.replyMessage(messageId, r.method === "transcript-trim"
+                        ? (en
+                            ? `✅ Session compacted (transcript trim${localizedTrimDetail ? ": " + localizedTrimDetail : ""})`
+                            : `✅ Session 已压缩（转录裁剪${localizedTrimDetail ? "：" + localizedTrimDetail : ""}）`)
                         : (en ? `✅ Session compacted` : `✅ Session 已压缩`));
                 }
             }