openclaw-lark-multi-agent 1.0.23 → 1.1.1

package/dist/feishu-bot.d.ts

@@ -147,6 +147,12 @@ export declare class FeishuBot {
     private getChairmanParticipant;
     private asDiscussionParticipant;
     private runDiscussionTurn;
+    private buildLiveStatusCard;
+    /** Minimal escaping so activity text does not break card markdown. */
+    private escapeCardText;
+    private sendLiveStatusCard;
+    private replyLiveStatusCard;
+    private patchLiveStatusCard;
     private sendTextMessage;
     private replyTextMessage;
     private editTextMessage;

package/dist/feishu-bot.js

@@ -1179,15 +1179,13 @@ export class FeishuBot {
                 };
                 liveStatus = this.shouldUseLiveStatus(chatId, isNativeCommandTrigger)
                     ? new LiveStatusController({
-                        create: (text) => this.sendOrdered(chatId, () => this.replyTextMessage(lastHuman.messageId || "", text)),
-                        edit: (messageId, text) => this.sendOrdered(chatId, () => this.editTextMessage(messageId, text)),
+                        create: (view) => this.sendOrdered(chatId, () => this.replyLiveStatusCard(lastHuman.messageId || "", view, chatId)),
+                        edit: (messageId, view) => this.sendOrdered(chatId, () => this.patchLiveStatusCard(messageId, view, chatId)),
                         warn: (message, err) => console.warn(`[${this.config.name}] ${message}:`, this.errorSummary(err)),
                     }, {
                         botName: this.config.name,
+                        model: this.config.model,
                         locale: this.isEn(chatId) ? "en" : "zh",
-                        disableHint: this.isEn(chatId)
-                            ? `Tip: send /livestatus off to hide this status message`
-                            : `提示：调用 /livestatus off 关闭该状态提示`,
                     })
                     : undefined;
                 liveStatus?.start(this.isEn(chatId) ? "waiting for OpenClaw" : "等待 OpenClaw 回复");
@@ -1242,7 +1240,7 @@ 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");
-                    liveStatus?.dispose();
+                    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 = [];
@@ -1342,7 +1340,10 @@ export class FeishuBot {
                     this.scheduleDelayedFailure(chatId, lastHuman.messageId, visibleReply, triggerId);
                 }
                 else if (!shouldReply && !hasAttachments) {
-                    liveStatus?.dispose();
+                    // 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(() => { });
                 }
                 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
@@ -1860,15 +1861,13 @@ export class FeishuBot {
         const liveStatusEnabled = this.store.getBotLiveStatus(this.config.name, chatId) && !this.store.getBotVerbose(this.config.name, chatId);
         const liveStatus = liveStatusEnabled
             ? new LiveStatusController({
-                create: (text) => this.sendOrdered(chatId, () => this.sendTextMessage(chatId, text)),
-                edit: (messageId, text) => this.sendOrdered(chatId, () => this.editTextMessage(messageId, text)),
+                create: (view) => this.sendOrdered(chatId, () => this.sendLiveStatusCard(chatId, view)),
+                edit: (messageId, view) => this.sendOrdered(chatId, () => this.patchLiveStatusCard(messageId, view, chatId)),
                 warn: (message, err) => console.warn(`[${this.config.name}] ${message}:`, err instanceof Error ? err.message : err),
             }, {
                 botName: this.config.name,
+                model: this.config.model,
                 locale: this.isEn(chatId) ? "en" : "zh",
-                disableHint: this.isEn(chatId)
-                    ? `Tip: send /livestatus off to hide this status message`
-                    : `提示：调用 /livestatus off 关闭该状态提示`,
             })
             : undefined;
         liveStatus?.start(meta ? `第 ${meta.round}/${meta.maxRounds} 轮讨论` : "讨论中");
@@ -1929,9 +1928,100 @@ export class FeishuBot {
                 throw err;
             }
         }
-        await liveStatus?.complete().catch(() => { });
+        // Mirror the normal path: a NO_REPLY/empty discussion turn should finish the
+        // status card with a "no content" summary, not a plain done summary.
+        if (!isVisible && parsedReply.attachments.length === 0) {
+            await liveStatus?.noReply().catch(() => { });
+        }
+        else {
+            await liveStatus?.complete().catch(() => { });
+        }
         return { botName: this.config.name, text: cleanVisibleReply, visible: isVisible };
     }
+    buildLiveStatusCard(view, chatId) {
+        const en = this.isEn(chatId);
+        const elements = [];
+        // Content area. While running: recent activity lines (each prefixed with the
+        // relative time mm:ss since the run started). When finished: a single run
+        // summary line (total tool calls + elapsed) instead of recent messages.
+        if (view.lines.length > 0) {
+            const iconFor = (kind) => kind === "tool_start" ? "▸"
+                : kind === "tool_end" ? "✓"
+                    : kind === "lifecycle" ? "⋯"
+                        : kind === "summary" ? "📊"
+                            : "•";
+            const fmtAt = (sec) => `${Math.floor(sec / 60)}:${String(sec % 60).padStart(2, "0")}`;
+            const content = view.lines
+                .map((l) => {
+                const stamp = l.kind === "summary" ? "" : `\`${fmtAt(l.at)}\` `;
+                return `${stamp}${iconFor(l.kind)} ${this.escapeCardText(l.text)}`;
+            })
+                .join("\n");
+            elements.push({ tag: "markdown", content });
+        }
+        else {
+            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>` });
+        // Title color reflects state.
+        const template = view.state === "done" ? "green" : view.state === "failed" ? "orange" : "blue";
+        return {
+            schema: "2.0",
+            // update_multi is REQUIRED for im.message.patch to update the card; Feishu
+            // rejects patches on cards that did not declare it before and after.
+            config: { update_multi: true, width_mode: "fill" },
+            header: {
+                title: { tag: "plain_text", content: view.title },
+                template,
+            },
+            body: { elements },
+        };
+    }
+    /** Minimal escaping so activity text does not break card markdown. */
+    escapeCardText(text) {
+        return String(text || "").replace(/</g, "\uff1c").replace(/>/g, "\uff1e");
+    }
+    async sendLiveStatusCard(chatId, view) {
+        try {
+            const res = await this.client.im.message.create({
+                params: { receive_id_type: "chat_id" },
+                data: {
+                    receive_id: chatId,
+                    content: JSON.stringify(this.buildLiveStatusCard(view, chatId)),
+                    msg_type: "interactive",
+                },
+            });
+            this.store.clearBotUnavailableInChat(this.config.name, chatId);
+            return res?.data?.message_id || res?.message_id;
+        }
+        catch (err) {
+            if (this.isOutOfChatError(err))
+                this.markCurrentBotUnavailable(chatId, err);
+            throw err;
+        }
+    }
+    async replyLiveStatusCard(messageId, view, chatId) {
+        const res = await this.client.im.message.reply({
+            path: { message_id: messageId },
+            data: {
+                content: JSON.stringify(this.buildLiveStatusCard(view, chatId)),
+                msg_type: "interactive",
+            },
+        });
+        return res?.data?.message_id || res?.message_id;
+    }
+    async patchLiveStatusCard(messageId, view, chatId) {
+        await this.client.im.message.patch({
+            path: { message_id: messageId },
+            data: { content: JSON.stringify(this.buildLiveStatusCard(view, chatId)) },
+        });
+    }
     async sendTextMessage(chatId, text) {
         try {
             const res = await this.client.im.message.create({
@@ -2000,11 +2090,12 @@ export class FeishuBot {
     }
     extractBridgeAttachments(reply) {
         const attachments = [];
-        // Some models occasionally corrupt the closing tag from
-        // </LMA_BRIDGE_ATTACHMENTS> to </parameter> while preserving the exact JSON
-        // payload. Treat that as a recoverable marker shape; otherwise the whole
-        // marker leaks as user-visible text and attachments are not sent.
-        const markerPattern = /<LMA_BRIDGE_ATTACHMENTS>([\s\S]*?)(?:<\/LMA_BRIDGE_ATTACHMENTS>|<\/parameter>)/g;
+        // Some models occasionally corrupt the attachment marker while preserving
+        // the exact JSON payload: the closing tag can become </parameter>, or the
+        // opening "<LMA" prefix can be truncated leaving "_BRIDGE_ATTACHMENTS>".
+        // Treat these as recoverable shapes; otherwise the marker leaks as
+        // user-visible text and attachments are not sent.
+        const markerPattern = /(?:<LMA_BRIDGE_ATTACHMENTS>|_BRIDGE_ATTACHMENTS>)([\s\S]*?)(?:<\/LMA_BRIDGE_ATTACHMENTS>|<\/parameter>)/g;
         let text = reply.replace(markerPattern, (_match, jsonText) => {
             try {
                 const parsed = JSON.parse(String(jsonText).trim());

package/dist/live-status.d.ts

@@ -1,7 +1,29 @@
 import type { ProgressEvent } from "./openclaw-client";
+/** One activity line shown in the card content area. */
+export type LiveStatusLine = {
+    kind: "tool_start" | "tool_end" | "text" | "lifecycle" | "summary";
+    text: string;
+    /** Relative time (seconds since run start) when this line was produced. */
+    at: number;
+};
+/** Structured snapshot the renderer turns into a Feishu interactive card. */
+export type LiveStatusView = {
+    /** Card title, e.g. "Claude 正在执行" / "✅ Claude 已完成". */
+    title: string;
+    /** Activity lines (oldest first); when finished this holds a summary instead. */
+    lines: LiveStatusLine[];
+    /** Footer: elapsed time like "0:42". */
+    elapsed: string;
+    /** Footer: model name, e.g. "phgeek-gw/claude-opus-4.8". */
+    model?: string;
+    /** Terminal state: running / done / failed (lets renderer pick color). */
+    state: "running" | "done" | "failed";
+};
 export type LiveStatusCallbacks = {
-    create: (text: string) => Promise<string | undefined>;
-    edit: (messageId: string, text: string) => Promise<void>;
+    /** Create the status card; returns the new message id. */
+    create: (view: LiveStatusView) => Promise<string | undefined>;
+    /** Patch the existing status card. */
+    edit: (messageId: string, view: LiveStatusView) => Promise<void>;
     warn?: (message: string, err?: unknown) => void;
 };
 export type LiveStatusOptions = {
@@ -9,48 +31,67 @@ export type LiveStatusOptions = {
     locale?: "zh" | "en";
     delayMs?: number;
     maxChars?: number;
-    maxEdits?: number;
-    disableHint?: string;
+    /** Model name shown in the footer. */
+    model?: string;
+    /** Number of recent activity lines kept in the content area. */
+    historySize?: number;
+    /** Footer/auto-refresh cadence in ms. */
+    tickMs?: number;
 };
 export declare class LiveStatusController {
     private readonly callbacks;
     private readonly opts;
     private messageId?;
-    private lastSentText;
-    private detail;
-    /** Number of edits already issued against the live message (excludes create). */
-    private editCount;
+    private lastSentSignature;
+    /** Recent activity lines (most-recent last), capped at historySize. */
+    private lines;
+    private startedAt;
     private createTimer?;
+    private tickTimer?;
     private createPromise?;
     private finalized;
     private disabled;
-    /** True after the running-state budget is spent; future progress is ignored. */
-    private runningLimitReached;
+    private state;
+    /** Total tool calls (tool_start events) seen during the run, for the summary. */
+    private toolCallCount;
+    /** True when finished via noReply(): show a "no content" summary. */
+    private noReplyResult;
     constructor(callbacks: LiveStatusCallbacks, opts: LiveStatusOptions);
     get id(): string | undefined;
     start(initialDetail?: string): void;
     progress(event: ProgressEvent | string): Promise<void>;
-    /**
-     * Finish the live status when the real (final) reply is delivered separately.
-     * The final answer is sent by the normal interactive-card path, so the status
-     * message must NOT be overwritten with the answer (text type does not render
-     * Markdown). Feishu renders message deletion as a visible "recalled a message"
-     * tombstone, so keep the status message and mark it done instead.
-     */
     complete(): Promise<void>;
+    fail(): Promise<void>;
     /**
-     * Finish the live status when the run failed and the error is delivered by the
-     * normal path. Use a neutral/negative marker so it does not contradict the
-     * separately delivered error message.
+     * Finish when the model explicitly produced no reply (NO_REPLY) or an empty
+     * final. Mark the card done but show a "no content" summary instead of the
+     * activity window, so the user understands the run finished without output.
      */
-    fail(): Promise<void>;
+    noReply(): Promise<void>;
     dispose(): void;
+    /**
+     * Intermediate assistant text arrives as incremental fragments (each flush
+     * sends only the newly-added slice). Consecutive fragments with no tool event
+     * in between belong to the same thought, so merge them into ONE line instead
+     * of showing each fragment (or each table row) as a separate message. A tool
+     * event resets this, so the next text starts a fresh line.
+     */
+    private appendText;
+    private normalizeText;
+    private clip;
+    private pushLine;
     private stopTimers;
     private ensureCreatedNow;
     private ensureCreated;
-    private editRunningStatus;
+    /** Refresh the elapsed-time footer periodically even with no new activity. */
+    private startTicker;
     private safeEdit;
-    private formatToolStart;
-    private formatStatus;
-    private formatLimitNotice;
+    /** Dedupe key includes elapsed so the footer timer ticks even without new
+     *  activity, while identical content within the same second is still skipped. */
+    private signature;
+    private isNoReplyText;
+    private formatTool;
+    private formatElapsed;
+    private buildView;
+    private buildSummaryLine;
 }

package/dist/live-status.js

@@ -1,23 +1,29 @@
 const DEFAULT_DELAY_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_DELAY_MS || 800);
 const DEFAULT_MAX_CHARS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_MAX_CHARS || 120);
-// Feishu caps a single message at 20 edits (code=230072 once exhausted). Keep the
-// final edit for the completion marker; running-state updates may consume at most
-// maxEdits - 1, with the last running edit reserved for an explicit limit notice.
-const DEFAULT_MAX_EDITS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_MAX_EDITS || 20);
+// How many recent activity lines to keep in the card content area.
+const DEFAULT_HISTORY = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_HISTORY || 6);
+// How often to refresh the elapsed-time footer even when no new activity arrives,
+// so the "已用时间" ticks like a live timer. Interactive-card patch has no 20-edit
+// cap (unlike text edit), so a 1s cadence is fine.
+const DEFAULT_TICK_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_TICK_MS || 1000);
 export class LiveStatusController {
     callbacks;
     opts;
     messageId;
-    lastSentText = "";
-    detail = "";
-    /** Number of edits already issued against the live message (excludes create). */
-    editCount = 0;
+    lastSentSignature = "";
+    /** Recent activity lines (most-recent last), capped at historySize. */
+    lines = [];
+    startedAt = Date.now();
     createTimer;
+    tickTimer;
     createPromise;
     finalized = false;
     disabled = false;
-    /** True after the running-state budget is spent; future progress is ignored. */
-    runningLimitReached = false;
+    state = "running";
+    /** Total tool calls (tool_start events) seen during the run, for the summary. */
+    toolCallCount = 0;
+    /** True when finished via noReply(): show a "no content" summary. */
+    noReplyResult = false;
     constructor(callbacks, opts) {
         this.callbacks = callbacks;
         this.opts = opts;
@@ -26,78 +32,138 @@ export class LiveStatusController {
     start(initialDetail) {
         if (this.disabled || this.finalized || this.createTimer || this.messageId)
             return;
-        this.detail = initialDetail || "";
+        this.startedAt = Date.now();
+        if (initialDetail && initialDetail.trim()) {
+            this.pushLine("lifecycle", initialDetail.trim());
+        }
         this.createTimer = setTimeout(() => {
             this.createTimer = undefined;
             this.createPromise = this.ensureCreated();
         }, this.opts.delayMs ?? DEFAULT_DELAY_MS);
     }
     async progress(event) {
-        if (this.disabled || this.finalized || this.runningLimitReached)
+        if (this.disabled || this.finalized)
             return;
-        // Only tool-call start is meaningful enough to spend one of Feishu's limited
-        // edit slots. Ignore verbose assistant notes, lifecycle ticks, tool end, and
-        // tool error; the final/error answer is delivered by the normal message path.
-        if (typeof event !== "string") {
-            if (event.kind !== "tool" || event.phase !== "start")
+        // Card patch has no 20-edit cap (verified against Feishu im.message.patch),
+        // so we can show a small rolling window of recent activity: tool start, tool
+        // end, and intermediate assistant text each count as one line. We ignore
+        // tool "error" (the error is delivered through the normal message path) and
+        // lifecycle ticks after the first.
+        if (typeof event === "string") {
+            const t = event.trim();
+            if (!t || this.isNoReplyText(t))
+                return;
+            this.appendText(t);
+        }
+        else if (event.kind === "tool") {
+            if (event.phase === "start") {
+                this.toolCallCount++;
+                this.pushLine("tool_start", this.formatTool(event));
+            }
+            else if (event.phase === "end")
+                this.pushLine("tool_end", this.formatTool(event));
+            else
+                return; // tool error -> normal error path
+        }
+        else if (event.kind === "assistant_note") {
+            const t = (event.text || "").trim();
+            if (!t || this.isNoReplyText(t))
                 return;
-            this.detail = this.formatToolStart(event);
+            this.appendText(t);
         }
         else {
-            // String progress is kept for tests/backwards compatibility, but in normal
-            // runtime OpenClaw progress is structured and only tool start passes above.
-            this.detail = event.trim();
+            return; // lifecycle ticks: ignore (footer timer already advances)
         }
-        if (!this.detail)
-            return;
         await this.ensureCreatedNow();
-        await this.editRunningStatus();
+        await this.safeEdit(this.buildView());
     }
-    /**
-     * Finish the live status when the real (final) reply is delivered separately.
-     * The final answer is sent by the normal interactive-card path, so the status
-     * message must NOT be overwritten with the answer (text type does not render
-     * Markdown). Feishu renders message deletion as a visible "recalled a message"
-     * tombstone, so keep the status message and mark it done instead.
-     */
     async complete() {
+        this.state = "done";
         this.finalized = true;
         this.stopTimers();
         if (this.createPromise)
             await this.createPromise.catch(() => { });
         if (!this.messageId || this.disabled)
             return;
-        const doneText = this.opts.locale === "en"
-            ? `\u2705 ${this.opts.botName} done`
-            : `\u2705 ${this.opts.botName} \u5df2\u5b8c\u6210`;
-        await this.safeEdit(doneText, true);
+        await this.safeEdit(this.buildView(), true);
+    }
+    async fail() {
+        this.state = "failed";
+        this.finalized = true;
+        this.stopTimers();
+        if (this.createPromise)
+            await this.createPromise.catch(() => { });
+        if (!this.messageId || this.disabled)
+            return;
+        await this.safeEdit(this.buildView(), true);
     }
     /**
-     * Finish the live status when the run failed and the error is delivered by the
-     * normal path. Use a neutral/negative marker so it does not contradict the
-     * separately delivered error message.
+     * Finish when the model explicitly produced no reply (NO_REPLY) or an empty
+     * final. Mark the card done but show a "no content" summary instead of the
+     * activity window, so the user understands the run finished without output.
      */
-    async fail() {
+    async noReply() {
+        this.state = "done";
+        this.noReplyResult = true;
         this.finalized = true;
         this.stopTimers();
         if (this.createPromise)
             await this.createPromise.catch(() => { });
         if (!this.messageId || this.disabled)
             return;
-        const failedText = this.opts.locale === "en"
-            ? `\u26A0\uFE0F ${this.opts.botName} stopped`
-            : `\u26A0\uFE0F ${this.opts.botName} \u6267\u884c\u4e2d\u65ad`;
-        await this.safeEdit(failedText, true);
+        await this.safeEdit(this.buildView(), true);
     }
     dispose() {
         this.finalized = true;
         this.stopTimers();
     }
+    /**
+     * Intermediate assistant text arrives as incremental fragments (each flush
+     * sends only the newly-added slice). Consecutive fragments with no tool event
+     * in between belong to the same thought, so merge them into ONE line instead
+     * of showing each fragment (or each table row) as a separate message. A tool
+     * event resets this, so the next text starts a fresh line.
+     */
+    appendText(fragment) {
+        const last = this.lines[this.lines.length - 1];
+        if (last && last.kind === "text") {
+            const merged = `${last.text} ${this.normalizeText(fragment)}`.replace(/\s+/g, " ").trim();
+            last.text = this.clip(merged);
+            return;
+        }
+        this.pushLine("text", fragment);
+    }
+    normalizeText(text) {
+        return text.replace(/\s+/g, " ").trim();
+    }
+    clip(text) {
+        const maxChars = this.opts.maxChars ?? DEFAULT_MAX_CHARS;
+        return text.length > maxChars ? `${text.slice(0, Math.max(0, maxChars - 1))}\u2026` : text;
+    }
+    pushLine(kind, text) {
+        const clean = this.normalizeText(text);
+        if (!clean)
+            return;
+        const clipped = this.clip(clean);
+        // Collapse consecutive identical lines (e.g. repeated "等待 OpenClaw").
+        const last = this.lines[this.lines.length - 1];
+        if (last && last.kind === kind && last.text === clipped)
+            return;
+        const at = Math.max(0, Math.floor((Date.now() - this.startedAt) / 1000));
+        this.lines.push({ kind, text: clipped, at });
+        const limit = this.opts.historySize ?? DEFAULT_HISTORY;
+        if (this.lines.length > limit)
+            this.lines = this.lines.slice(this.lines.length - limit);
+    }
     stopTimers() {
         if (this.createTimer) {
             clearTimeout(this.createTimer);
             this.createTimer = undefined;
         }
+        if (this.tickTimer) {
+            clearInterval(this.tickTimer);
+            this.tickTimer = undefined;
+        }
     }
     async ensureCreatedNow() {
         if (this.createTimer) {
@@ -111,45 +177,45 @@ export class LiveStatusController {
     async ensureCreated() {
         if (this.disabled || this.finalized || this.messageId)
             return;
-        const text = this.formatStatus(true);
+        const view = this.buildView();
         try {
-            const id = await this.callbacks.create(text);
+            const id = await this.callbacks.create(view);
             if (!id) {
                 this.disabled = true;
                 return;
             }
             this.messageId = id;
-            this.lastSentText = text;
+            this.lastSentSignature = this.signature(view);
+            this.startTicker();
         }
         catch (err) {
             this.disabled = true;
             this.callbacks.warn?.("live status create failed", err);
         }
     }
-    async editRunningStatus() {
-        if (!this.messageId || this.disabled || this.finalized || this.runningLimitReached)
-            return;
-        const maxEdits = this.opts.maxEdits ?? DEFAULT_MAX_EDITS;
-        const runningBudget = Math.max(0, maxEdits - 1); // reserve final edit for complete()
-        if (this.editCount >= runningBudget)
+    /** Refresh the elapsed-time footer periodically even with no new activity. */
+    startTicker() {
+        if (this.tickTimer || this.disabled || this.finalized)
             return;
-        const isLimitNotice = this.editCount === runningBudget - 1;
-        const text = isLimitNotice ? this.formatLimitNotice() : this.formatStatus();
-        const ok = await this.safeEdit(text);
-        if (ok && isLimitNotice)
-            this.runningLimitReached = true;
+        const tickMs = this.opts.tickMs ?? DEFAULT_TICK_MS;
+        this.tickTimer = setInterval(() => {
+            if (this.finalized || this.disabled || !this.messageId)
+                return;
+            void this.safeEdit(this.buildView());
+        }, tickMs);
+        this.tickTimer.unref?.();
     }
-    async safeEdit(text, force = false) {
+    async safeEdit(view, force = false) {
         if (!this.messageId || this.disabled)
             return false;
         if (!force && this.finalized)
             return false;
-        if (!force && text === this.lastSentText)
+        const sig = this.signature(view);
+        if (!force && sig === this.lastSentSignature)
             return true;
         try {
-            await this.callbacks.edit(this.messageId, text);
-            this.lastSentText = text;
-            this.editCount++;
+            await this.callbacks.edit(this.messageId, view);
+            this.lastSentSignature = sig;
             return true;
         }
         catch (err) {
@@ -159,26 +225,62 @@ export class LiveStatusController {
             return false;
         }
     }
-    formatToolStart(event) {
+    /** Dedupe key includes elapsed so the footer timer ticks even without new
+     *  activity, while identical content within the same second is still skipped. */
+    signature(view) {
+        return `${view.state}|${view.title}|${view.elapsed}|${view.lines.map((l) => `${l.kind}@${l.at}:${l.text}`).join("|")}`;
+    }
+    isNoReplyText(text) {
+        return text.trim().toUpperCase() === "NO_REPLY";
+    }
+    formatTool(event) {
         const raw = event.text || event.name || "";
-        const prefix = `${event.name} start`;
+        const prefix = `${event.name} ${event.phase}`;
         let detail = raw.startsWith(prefix) ? raw.slice(prefix.length).trim() : raw.trim();
         if (detail.startsWith(":"))
             detail = detail.slice(1).trim();
         return detail ? `${event.name}: ${detail}` : event.name;
     }
-    formatStatus(includeDisableHint = false) {
-        const maxChars = this.opts.maxChars ?? DEFAULT_MAX_CHARS;
-        const clean = (this.detail || "").replace(/\s+/g, " ").trim();
-        const clipped = clean.length > maxChars ? `${clean.slice(0, Math.max(0, maxChars - 1))}\u2026` : clean;
-        const base = !clipped
-            ? (this.opts.locale === "en" ? `${this.opts.botName} is working` : `${this.opts.botName} \u6b63\u5728\u6267\u884c`)
-            : (this.opts.locale === "en" ? `${this.opts.botName} is working: ${clipped}` : `${this.opts.botName} \u6b63\u5728\u6267\u884c\uff1a${clipped}`);
-        return includeDisableHint && this.opts.disableHint ? `${base}\n${this.opts.disableHint}` : base;
-    }
-    formatLimitNotice() {
-        return this.opts.locale === "en"
-            ? `${this.opts.botName} reached the update limit and is still running`
-            : `${this.opts.botName} \u5df2\u8fbe\u66f4\u65b0\u9650\u5236\uff0c\u6b63\u5728\u6301\u7eed\u6267\u884c\u4e2d`;
+    formatElapsed() {
+        const totalSec = Math.max(0, Math.floor((Date.now() - this.startedAt) / 1000));
+        const m = Math.floor(totalSec / 60);
+        const s = totalSec % 60;
+        return `${m}:${String(s).padStart(2, "0")}`;
+    }
+    buildView() {
+        const en = this.opts.locale === "en";
+        let title;
+        if (this.state === "done")
+            title = en ? `\u2705 ${this.opts.botName} done` : `\u2705 ${this.opts.botName} \u5df2\u5b8c\u6210`;
+        else if (this.state === "failed")
+            title = en ? `\u26A0\uFE0F ${this.opts.botName} stopped` : `\u26A0\uFE0F ${this.opts.botName} \u6267\u884c\u4e2d\u65ad`;
+        else
+            title = en ? `${this.opts.botName} is working` : `${this.opts.botName} \u6b63\u5728\u6267\u884c`;
+        // When finished, replace the recent-activity window with a run summary
+        // (total tool calls + total time) instead of the last few messages.
+        const lines = this.state === "running"
+            ? [...this.lines]
+            : [this.buildSummaryLine(en)];
+        return {
+            title,
+            lines,
+            elapsed: this.formatElapsed(),
+            model: this.opts.model,
+            state: this.state,
+        };
+    }
+    buildSummaryLine(en) {
+        const elapsed = this.formatElapsed();
+        const at = Math.max(0, Math.floor((Date.now() - this.startedAt) / 1000));
+        if (this.noReplyResult) {
+            const text = en
+                ? `Model returned no content \u00b7 ${this.toolCallCount} tool call${this.toolCallCount === 1 ? "" : "s"} \u00b7 ${elapsed}`
+                : `\u6a21\u578b\u6ca1\u6709\u56de\u590d\u5185\u5bb9 \u00b7 \u5171\u8c03\u7528\u5de5\u5177 ${this.toolCallCount} \u6b21 \u00b7 \u8017\u65f6 ${elapsed}`;
+            return { kind: "summary", text, at };
+        }
+        const text = en
+            ? `${this.toolCallCount} tool call${this.toolCallCount === 1 ? "" : "s"} \u00b7 ${elapsed}`
+            : `\u5171\u8c03\u7528\u5de5\u5177 ${this.toolCallCount} \u6b21 \u00b7 \u8017\u65f6 ${elapsed}`;
+        return { kind: "summary", text, at };
     }
 }

package/dist/openclaw-client.d.ts

@@ -90,6 +90,15 @@ export declare class OpenClawClient {
      * 30-minute safety net only for catastrophic WS disconnection.
      */
     private collectReply;
+    /**
+     * Recoverable agent errors are lifecycle errors that OpenClaw can self-heal
+     * (it auto-compacts and keeps running the same run, then emits a real final).
+     * For these we must not reject collectReply immediately, or the bridge reports
+     * "没有完成回复" while the agent is still working. Currently this covers
+     * context-overflow / prompt-too-large, which OpenClaw recovers from via its
+     * context-overflow-recovery + auto-compaction path.
+     */
+    private isRecoverableAgentError;
     private pickBestCollectedText;
     createSession(params: {
         key: string;

package/dist/openclaw-client.js

@@ -810,13 +810,29 @@ export class OpenClawClient {
                             return;
                         }
                         if (ev.stream === "lifecycle" && ev.data?.phase === "error") {
+                            const errText = String(ev.data?.error || "unknown");
+                            // Some agent errors are recoverable: OpenClaw emits a lifecycle
+                            // error (e.g. "Context overflow: prompt too large") and then
+                            // auto-compacts and KEEPS RUNNING the same run, eventually emitting
+                            // a real final. If we reject immediately the user sees a scary
+                            // "没有完成回复" while the agent is in fact still working. So for
+                            // recoverable errors we defer: record the failure text and keep
+                            // waiting. Subsequent delta/item events reset the idle timer, so a
+                            // real final wins; if the run truly stalls, the idle timeout falls
+                            // back to this text.
+                            if (this.isRecoverableAgentError(errText)) {
+                                pendingRuntimeFailureText = `⚠️ Agent 未正常完成\n原因: ${errText}`;
+                                resetIdleTimer();
+                                console.warn(`[OpenClaw] recoverable lifecycle error for runId=${evRunId || runId}; deferring (agent may auto-recover): ${errText.slice(0, 120)}`);
+                                return;
+                            }
                             clearTimeout(idleTimer);
                             clearInterval(poller);
                             if (chatFinalTimer)
                                 clearTimeout(chatFinalTimer);
                             if (lifecycleEndTimer)
                                 clearTimeout(lifecycleEndTimer);
-                            reject(new Error(`Agent error: ${ev.data?.error || "unknown"}`));
+                            reject(new Error(`Agent error: ${errText}`));
                             return;
                         }
                     }
@@ -824,6 +840,22 @@ export class OpenClawClient {
             }, 50);
         });
     }
+    /**
+     * Recoverable agent errors are lifecycle errors that OpenClaw can self-heal
+     * (it auto-compacts and keeps running the same run, then emits a real final).
+     * For these we must not reject collectReply immediately, or the bridge reports
+     * "没有完成回复" while the agent is still working. Currently this covers
+     * context-overflow / prompt-too-large, which OpenClaw recovers from via its
+     * context-overflow-recovery + auto-compaction path.
+     */
+    isRecoverableAgentError(errText) {
+        const t = (errText || "").toLowerCase();
+        return t.includes("context overflow")
+            || t.includes("prompt too large")
+            || t.includes("context length")
+            || t.includes("too many tokens")
+            || t.includes("maximum context");
+    }
     pickBestCollectedText(chatFinalText, assistantText, chatDeltaText, transcriptAssistantText) {
         if (chatFinalText)
             return chatFinalText;

package/package.json

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