openclaw-lark-multi-agent 1.4.8 → 1.4.10

package/README.md

@@ -590,3 +590,21 @@ If a secret is ever committed, remove it from the current tree and rewrite git h
 ## License
 
 MIT
+
+### Reply status and context usage (v1.4.9)
+
+Final text replies include a compact footer, for example:
+
+`🧠 provider/model · running · 85K/200K`
+
+State and context usage come from one bounded Gateway status lookup. K values
+are rounded integers (1000 tokens per K); unavailable/stale values are not shown
+as zero. The footer is a send-time snapshot, not a live status widget.
+
+LMA's foreground result wait and live-card refresh budget are now 10 minutes.
+When the session is still running, LMA sends a normal wait notice instead of
+claiming execution failed. The old card stops periodic/progress edits; background
+result handling and the original queue remain, with no automatic abort/replay.
+Real results are sent separately; necessary terminal card cleanup is retained.
+This does not shorten the Gateway's execution limit. Unverified steer V2 and
+question adapters are not included in this release.

package/README.zh-CN.md

@@ -498,3 +498,19 @@ git ls-files | grep -E 'config|secret|\.env' || true
 ## License
 
 MIT
+
+### 回复状态与上下文用量（v1.4.9）
+
+最终文字回复使用紧凑尾部，例如：
+
+`🧠 provider/model · running · 85K/200K`
+
+状态与上下文已用量/上限来自同一次、有等待上限的 Gateway 查询；K 按
+1000 token 四舍五入为整数。缺失或明确过期的数据不冒充 0。尾部反映发送前
+查询的状态，不会持续自动刷新历史回复。
+
+前台结果等待与过程卡刷新预算调整为 10 分钟。会话仍在 running 时发送普通
+等待提示，不把它当作整个任务执行失败；旧卡不再周期刷新或随工具进度编辑。
+后台仍监听原任务，保留原队列，不因此停止或自动重发请求。真实结果另行回复，
+保留必要的终态收尾。本改动不缩短 Gateway 的执行时限，也不包含未验收的
+steer V2 与问答适配器。

package/dist/feishu-bot.d.ts

@@ -40,6 +40,8 @@ export declare class FeishuBot {
      * command/error/card sends with model attribution. */
     private replyModelFooters;
     private sendModelFooters;
+    private replyStatusFooters;
+    private sendStatusFooters;
     /** Per-chat durable outbox retry timer. */
     private deliveryRetryTimers;
     /** Last time a real assistant-visible reply was successfully handed to the delivery pipeline. */
@@ -137,6 +139,8 @@ export declare class FeishuBot {
     /** Best-effort terminal cleanup for status-only rows and legacy v1.4.3
      * outbox entries that once targeted the live-status card. */
     private patchLiveStatusDoneSummary;
+    private readSessionStatus;
+    private sendWaitPaused;
     private formatUserVisibleError;
     private isBridgeControlReply;
     private isLegacyBridgeControlMessage;

package/dist/feishu-bot.js

@@ -2,6 +2,8 @@ import * as lark from "@larksuiteoapi/node-sdk";
 import { createRequire } from "module";
 import { persistBotModel } from "./config.js";
 import { getI18n, normalizeLocale } from "./i18n.js";
+import { InactiveRunObservation } from "./openclaw-client.js";
+import { SessionWaitPaused, isWaitTimeout, normalizeSessionRuntimeStatus, formatSessionFooter, FOREGROUND_WAIT_MS } from "./session-status.js";
 import { LiveStatusController } from "./live-status.js";
 import { CompactProgressController } from "./compact-progress.js";
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
@@ -98,6 +100,8 @@ export class FeishuBot {
      * command/error/card sends with model attribution. */
     replyModelFooters = new Map();
     sendModelFooters = new Map();
+    replyStatusFooters = new Map();
+    sendStatusFooters = 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. */
@@ -930,9 +934,9 @@ export class FeishuBot {
                 return;
             }
             // --- Queue-based sending: if agent is busy, just accumulate ---
-            const busySince = this.busyChats.get(chatId) || 0;
-            const BUSY_TIMEOUT_MS = 1_800_000; // 30 minutes, matches collectReply safety timeout
-            const isBusy = busySince > 0 && (Date.now() - busySince) < BUSY_TIMEOUT_MS;
+            // The actual queue owner, not elapsed wall time, decides whether input
+            // should steer/queue. Long healthy runs must not lose their busy ownership.
+            const isBusy = this.queueRuns.has(chatId);
             if (isBusy) {
                 // The agent is mid-run. Instead of only queuing to wait for the current
                 // run to finish, try to STEER this message into the active run so it is
@@ -948,10 +952,12 @@ export class FeishuBot {
                 pending.push({ messageId, emoji: "Typing", rowId: insertedId });
                 this.pendingAckMessages.set(chatId, pending);
                 const norm = cleanText.replace(/\s+/g, " ").trim();
+                let consumedBeforeAck = false;
                 const stopWatchingConsumption = this.openclawClient.onSteerConsumed(sessionKeyForSteer, steerWrapped, (consumedText) => {
                     const cn = (consumedText || "").replace(/\s+/g, " ").trim();
                     if (cn !== norm && !cn.includes(norm))
                         return false;
+                    consumedBeforeAck = true;
                     // 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.
@@ -970,7 +976,7 @@ export class FeishuBot {
                 });
                 const steer = await this.openclawClient.steer(sessionKeyForSteer, steerWrapped, cleanText).catch(() => ({ status: "unavailable" }));
                 if (steer.status === "steered") {
-                    if (insertedId > 0) {
+                    if (insertedId > 0 && !consumedBeforeAck) {
                         this.pendingSteerCleanups.set(insertedId, () => {
                             stopWatchingConsumption();
                             if ("cancelPending" in steer)
@@ -990,13 +996,18 @@ export class FeishuBot {
                 if ("cancelPending" in steer)
                     steer.cancelPending?.();
                 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
-            }
-            if (busySince > 0) {
-                // Busy timeout expired — unlock but don't processQueue here;
-                // let the next new message trigger it naturally to avoid concurrent runs
-                console.warn(`[${this.config.name}] Busy timeout expired for ${chatId.slice(-8)} (${Math.round((Date.now() - busySince) / 1000)}s), unlocking (will process on next message)`);
-                this.busyChats.set(chatId, 0);
+                // Reconciliation may have finished the old owner during the steer RPC.
+                // Ensure this new, still-pending input is drained even when that owner
+                // exited through an error path. Already-consumed input is never replayed.
+                const owner = this.queueRuns.get(chatId);
+                const drainPending = () => {
+                    if (insertedId > 0 && this.store.getPendingTriggerIds(this.config.name, chatId).has(insertedId))
+                        return this.processQueue(chatId);
+                };
+                if (owner)
+                    void owner.then(drainPending, drainPending).catch(err => console.warn(`[${this.config.name}] pending drain failed:`, err.message));
+                else
+                    await drainPending();
                 return;
             }
             // --- Not busy, send now (with any accumulated messages) ---
@@ -1352,7 +1363,7 @@ export class FeishuBot {
                         deliver: false,
                         // Keep bridge UX responsive; long agent/tool loops should surface a clear failure
                         // instead of leaving reactions stuck forever.
-                        timeoutMs: 1_800_000,
+                        timeoutMs: FOREGROUND_WAIT_MS,
                         includeContext: !isNativeCommandTrigger,
                         includeBridgeAttachmentHint: !isNativeCommandTrigger,
                         onSendAttempt: () => {
@@ -1375,6 +1386,14 @@ export class FeishuBot {
                             markSubmittedBatch(`submitted:${runId}`);
                         },
                         onProgress: (event) => liveStatus?.progress(event),
+                        onWaitPaused: async (notice) => {
+                            await liveStatus?.showWaitingForResult(notice.message);
+                            // Yield is a confirmed handoff, not the timeout heuristic. A
+                            // recent unrelated reply must not suppress this turn's notice.
+                            if (notice.reason === "yield" ? !this.store.hasDeliveredReply(this.config.name, chatId, triggerId)
+                                : Date.now() - (this.lastRealDeliveryAt.get(chatId) || 0) >= 5000)
+                                await this.sendWaitPaused(chatId, triggerId, lastHuman.messageId, notice);
+                        },
                     }));
                 }
                 catch (mainErr) {
@@ -1585,6 +1604,43 @@ export class FeishuBot {
                 this.pendingAckMessages.set(chatId, remainingAcks);
             }
             catch (err) {
+                let pause = err instanceof SessionWaitPaused ? err : undefined;
+                if (!pause && isWaitTimeout(err instanceof Error ? err.message : String(err))) {
+                    const state = await this.readSessionStatus(chatId);
+                    if (state.running)
+                        pause = new SessionWaitPaused(state, true);
+                }
+                if (pause) {
+                    const target = this.activeDeliveryTargets.get(chatId);
+                    if (target?.triggerId === triggerId && target.runId)
+                        this.openclawClient.releasePausedWait?.(target.runId);
+                    await liveStatus?.pauseForUnconfirmedResult(pause.message, `${this.config.name} 等待暂停 · ${pause.snapshot.status}`).catch(() => { });
+                    await this.sendWaitPaused(chatId, triggerId, lastHuman.messageId, pause).catch(() => { });
+                    // A wait notice is not the final answer and must never claim its key.
+                    // Do not mark DONE, retry this input, or abort the running session.
+                    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}:wait-paused`);
+                    const acks = this.pendingAckMessages.get(chatId) || [];
+                    for (const ack of acks)
+                        if (completedTriggerIdSet.has(ack.rowId))
+                            await this.removeReaction(ack.messageId, ack.emoji).catch(() => { });
+                    this.pendingAckMessages.set(chatId, acks.filter(ack => !completedTriggerIdSet.has(ack.rowId)));
+                    break;
+                }
+                if (err instanceof InactiveRunObservation) {
+                    await liveStatus?.pauseForUnconfirmedResult(err.message).catch(() => { });
+                    if (!liveStatus?.id && lastHuman.messageId)
+                        await this.replyMessage(lastHuman.messageId, `ℹ️ ${err.message}`).catch(() => { });
+                    const acks = this.pendingAckMessages.get(chatId) || [];
+                    for (const ack of acks)
+                        if (completedTriggerIdSet.has(ack.rowId))
+                            await this.removeReaction(ack.messageId, ack.emoji).catch(() => { });
+                    this.pendingAckMessages.set(chatId, acks.filter(ack => !completedTriggerIdSet.has(ack.rowId)));
+                    // No DONE/delivered mark and no replay of the old input. The new
+                    // pending trigger resumes after this queue owner's finally releases.
+                    break;
+                }
                 if (err instanceof UnhealthySessionError) {
                     // stopForUnhealthySession already warned the user; mark the live
                     // status as interrupted. The user can send another message to retry
@@ -1767,13 +1823,13 @@ export class FeishuBot {
         }
         return s;
     }
-    buildMarkdownCard(text, model) {
+    buildMarkdownCard(text, model, status) {
         const elements = buildFeishuCardElements(text);
         if (model?.trim()) {
             elements.push({ tag: "hr" });
             elements.push({
                 tag: "markdown",
-                content: `<font color='grey'>🧠 ${this.escapeCardText(model.trim())}</font>`,
+                content: `<font color='grey'>🧠 ${this.escapeCardText(model.trim())}${status ? ` · ${this.escapeCardText(status)}` : ""}</font>`,
             });
         }
         return {
@@ -1816,7 +1872,21 @@ export class FeishuBot {
         };
         await this.patchLiveStatusCard(messageId, view, chatId);
     }
+    async readSessionStatus(chatId) {
+        try {
+            return await this.openclawClient.getSessionRuntimeStatus(this.getSessionKey(chatId));
+        }
+        catch {
+            return normalizeSessionRuntimeStatus(undefined);
+        }
+    }
+    async sendWaitPaused(chatId, triggerId, messageId, notice) {
+        const key = triggerId ? `trigger:${triggerId}:wait-paused` : `wait-paused:${notice.snapshot.checkedAt}`;
+        await this.enqueueAndDispatchDelivery(chatId, "wait_paused", key, notice.message, [], messageId, key, this.config.model);
+    }
     formatUserVisibleError(err) {
+        if (err instanceof SessionWaitPaused)
+            return err.message;
         const raw = err instanceof Error ? err.message : String(err);
         let reason = raw.replace(/\s+/g, " ").trim();
         if (/quota/i.test(reason) || /exceeded/i.test(reason)) {
@@ -2039,13 +2109,19 @@ export class FeishuBot {
                     currentMessage: probe,
                     currentSenderName: senderName,
                     deliver: false,
-                    timeoutMs: 1_800_000,
+                    timeoutMs: FOREGROUND_WAIT_MS,
                     includeContext: false,
                     includeBridgeAttachmentHint: false,
                     onProgress: (event) => liveStatus?.progress(event),
+                    onWaitPaused: async (notice) => {
+                        await liveStatus?.showWaitingForResult(notice.message);
+                        await this.sendWaitPaused(chatId, triggerId, lastHumanMessageId, notice);
+                    },
                 }));
             }
             catch (err) {
+                if (err instanceof SessionWaitPaused)
+                    throw err;
                 // The confirmation round itself failed (timeout/unhealthy). Do not spin:
                 // deliver the existing (truncated-looking) reply as-is.
                 console.warn(`[${this.config.name}] auto-retry probe failed for ${chatId.slice(-8)}:`, this.errorSummary(err));
@@ -2134,11 +2210,20 @@ export class FeishuBot {
         this.cancelDelayedFailure(chatId);
         const timer = setTimeout(() => {
             this.delayedFailureTimers.delete(chatId);
-            void this.enqueueAndDispatchDelivery(chatId, "delayed_error", `trigger:${triggerId}:delayed-error`, text, [], replyToMessageId, `trigger:${triggerId}:delayed-error`)
-                .then(() => {
+            void (async () => {
+                if (isWaitTimeout(text)) {
+                    const status = await this.readSessionStatus(chatId);
+                    if (Date.now() - (this.lastRealDeliveryAt.get(chatId) || 0) < 90_000)
+                        return;
+                    if (status.running) {
+                        await this.sendWaitPaused(chatId, triggerId, replyToMessageId, new SessionWaitPaused(status, true));
+                        return;
+                    }
+                }
+                await this.enqueueAndDispatchDelivery(chatId, "delayed_error", `trigger:${triggerId}:delayed-error`, text, [], replyToMessageId, `trigger:${triggerId}:delayed-error`);
                 if (triggerId)
                     this.store.markDeliveredReply(this.config.name, chatId, triggerId, replyToMessageId);
-            })
+            })()
                 .catch((err) => {
                 console.warn(`[${this.config.name}] delayed failure delivery failed:`, err.message);
             });
@@ -2342,23 +2427,28 @@ export class FeishuBot {
                             const shouldReplyToSource = Boolean(replyTarget) && (item.sourceType.startsWith("assistant_visible")
                                 || item.sourceType === "verbose_transcript"
                                 || item.sourceType === "provider_error"
-                                || item.sourceType === "delayed_error");
+                                || item.sourceType === "delayed_error"
+                                || item.sourceType === "wait_paused");
                             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 */ }
+                            const needsStatus = Boolean(finalModel) || item.sourceType.startsWith("assistant_visible") || ["provider_error", "delayed_error", "wait_paused"].includes(item.sourceType);
+                            const finalStatus = needsStatus ? formatSessionFooter(await this.readSessionStatus(chatId)) : undefined;
+                            if (needsStatus && !finalModel)
+                                finalModel = this.config.model;
                             if (shouldReplyToSource) {
                                 try {
-                                    await this.replyFinalMessage(replyTarget, item.content, finalModel);
+                                    await this.replyFinalMessage(replyTarget, item.content, finalModel, finalStatus);
                                 }
                                 catch {
-                                    await this.sendFinalMessage(chatId, item.content, finalModel);
+                                    await this.sendFinalMessage(chatId, item.content, finalModel, finalStatus);
                                 }
                             }
                             else {
-                                await this.sendFinalMessage(chatId, item.content, finalModel);
+                                await this.sendFinalMessage(chatId, item.content, finalModel, finalStatus);
                             }
                             // Rows created by v1.4.3 may still target a live-status card. Preserve
                             // restart compatibility: send their text as a new message, then
@@ -2551,6 +2641,7 @@ export class FeishuBot {
             : undefined;
         liveStatus?.start(meta ? `第 ${meta.round}/${meta.maxRounds} 轮讨论` : "讨论中");
         let reply;
+        let discussionWaitPaused = false;
         try {
             reply = await this.openclawClient.chatSendWithContext({
                 sessionKey,
@@ -2558,20 +2649,36 @@ export class FeishuBot {
                 currentMessage: prompt,
                 currentSenderName: "Discussion Scheduler",
                 deliver: false,
-                timeoutMs: 1_800_000,
+                timeoutMs: FOREGROUND_WAIT_MS,
                 emptyFinalAsNoReply: true,
                 onProgress: (event) => { void liveStatus?.progress(event).catch((err) => console.warn(`[${this.config.name}] live status progress failed:`, err instanceof Error ? err.message : err)); },
+                onWaitPaused: async (notice) => {
+                    await liveStatus?.showWaitingForResult(notice.message);
+                    await this.sendWaitPaused(chatId, 0, undefined, notice);
+                },
             });
         }
         catch (err) {
-            await liveStatus?.fail().catch(() => { });
-            throw err;
+            let pause = err instanceof SessionWaitPaused ? err : undefined;
+            if (!pause && isWaitTimeout(err instanceof Error ? err.message : String(err))) {
+                const status = await this.readSessionStatus(chatId);
+                if (status.running)
+                    pause = new SessionWaitPaused(status, true);
+            }
+            if (pause) {
+                discussionWaitPaused = true;
+                await liveStatus?.pauseForUnconfirmedResult(pause.message, `${this.config.name} 等待暂停 · ${pause.snapshot.status}`).catch(() => { });
+                await this.sendWaitPaused(chatId, 0, undefined, pause).catch(() => { });
+            }
+            else
+                await liveStatus?.fail().catch(() => { });
+            throw pause || err;
         }
         finally {
             // OpenClaw can emit the final assistant session.message shortly after
             // chatSend/collectReply returns. Keep discussion proactive muted briefly;
             // the discussion coordinator already owns user-visible delivery.
-            releaseProactiveMute(120_000);
+            releaseProactiveMute(discussionWaitPaused ? 0 : 120_000);
         }
         const parsedReply = this.extractBridgeAttachments(reply);
         const rawVisibleReply = parsedReply.text.trim();
@@ -2826,21 +2933,25 @@ export class FeishuBot {
     async deleteMessageById(messageId) {
         await this.client.im.v1.message.delete({ path: { message_id: messageId } });
     }
-    async replyFinalMessage(messageId, text, model) {
+    async replyFinalMessage(messageId, text, model, status) {
         if (!model?.trim())
             return this.replyMessage(messageId, text);
         this.replyModelFooters.set(messageId, model.trim());
+        if (status)
+            this.replyStatusFooters.set(messageId, status);
         try {
             return await this.replyMessage(messageId, text);
         }
         finally {
             this.replyModelFooters.delete(messageId);
+            this.replyStatusFooters.delete(messageId);
         }
     }
     async replyMessage(messageId, text) {
         // Use Feishu CardKit v2 markdown component for full Markdown rendering.
         const model = this.replyModelFooters.get(messageId);
-        const card = this.buildMarkdownCard(text, model);
+        const status = this.replyStatusFooters.get(messageId);
+        const card = this.buildMarkdownCard(text, model, status);
         try {
             const res = await this.client.im.message.reply({
                 path: { message_id: messageId },
@@ -2853,7 +2964,7 @@ export class FeishuBot {
         }
         catch {
             // Fallback to plain text if card fails; retain model attribution.
-            const fallbackText = model?.trim() ? `${text}\n\n🧠 ${model.trim()}` : text;
+            const fallbackText = model?.trim() ? `${text}\n\n🧠 ${model.trim()}${status ? ` · ${status}` : ""}` : text;
             const res = await this.client.im.message.reply({
                 path: { message_id: messageId },
                 data: {
@@ -3185,20 +3296,24 @@ export class FeishuBot {
     /**
      * Send a proactive message to a chat (not a reply).
      */
-    async sendFinalMessage(chatId, text, model) {
+    async sendFinalMessage(chatId, text, model, status) {
         if (!model?.trim())
             return this.sendMessage(chatId, text);
         this.sendModelFooters.set(chatId, model.trim());
+        if (status)
+            this.sendStatusFooters.set(chatId, status);
         try {
             return await this.sendMessage(chatId, text);
         }
         finally {
             this.sendModelFooters.delete(chatId);
+            this.sendStatusFooters.delete(chatId);
         }
     }
     async sendMessage(chatId, text) {
         const model = this.sendModelFooters.get(chatId);
-        const card = this.buildMarkdownCard(text, model);
+        const status = this.sendStatusFooters.get(chatId);
+        const card = this.buildMarkdownCard(text, model, status);
         try {
             const res = await this.client.im.message.create({
                 params: { receive_id_type: "chat_id" },
@@ -3217,7 +3332,7 @@ export class FeishuBot {
                 this.markCurrentBotUnavailable(chatId, err);
             // Fallback to plain text; retain model attribution.
             try {
-                const fallbackText = model?.trim() ? `${text}\n\n🧠 ${model.trim()}` : text;
+                const fallbackText = model?.trim() ? `${text}\n\n🧠 ${model.trim()}${status ? ` · ${status}` : ""}` : text;
                 const res = await this.client.im.message.create({
                     params: { receive_id_type: "chat_id" },
                     data: {

package/dist/live-status.d.ts

@@ -50,6 +50,8 @@ export type LiveStatusOptions = {
     historySize?: number;
     /** Footer/auto-refresh cadence in ms. */
     tickMs?: number;
+    /** Fixed card refresh lifetime; activity does not extend it. */
+    refreshBudgetMs?: number;
 };
 export declare class LiveStatusController {
     private readonly callbacks;
@@ -61,8 +63,11 @@ export declare class LiveStatusController {
     private startedAt;
     private createTimer?;
     private tickTimer?;
+    private refreshBudgetTimer?;
     private createPromise?;
     private finalized;
+    private waitingForResult;
+    private updatesFrozen;
     private disabled;
     /** Consecutive safeEdit failures. A single transient Feishu error (e.g. card
      *  patch code=2200 "Internal Error") must NOT permanently disable the card:
@@ -79,6 +84,12 @@ export declare class LiveStatusController {
     get id(): string | undefined;
     start(initialDetail?: string): void;
     progress(event: ProgressEvent | string): Promise<void>;
+    /** Freeze recurring/progress edits, not the original result observer.
+     * A single final/error summary remains allowed when the real outcome arrives. */
+    showWaitingForResult(detail: string): Promise<void>;
+    /** Release only local observation of a now-idle session, without claiming
+     * the previous task succeeded or was aborted. Normal progress is unchanged. */
+    pauseForUnconfirmedResult(detail: string, title?: string): Promise<void>;
     complete(): Promise<void>;
     /**
      * Freeze any successful terminal state (text, attachment-only, or NO_REPLY)

package/dist/live-status.js

@@ -1,3 +1,4 @@
+import { FOREGROUND_WAIT_MS } from "./session-status.js";
 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);
 // How many recent activity lines to keep in the card content area.
@@ -22,8 +23,11 @@ export class LiveStatusController {
     startedAt = Date.now();
     createTimer;
     tickTimer;
+    refreshBudgetTimer;
     createPromise;
     finalized = false;
+    waitingForResult = false;
+    updatesFrozen = false;
     disabled = false;
     /** Consecutive safeEdit failures. A single transient Feishu error (e.g. card
      *  patch code=2200 "Internal Error") must NOT permanently disable the card:
@@ -42,9 +46,15 @@ export class LiveStatusController {
     }
     get id() { return this.messageId; }
     start(initialDetail) {
-        if (this.disabled || this.finalized || this.createTimer || this.messageId)
+        if (this.disabled || this.finalized || this.updatesFrozen || this.createTimer || this.messageId)
             return;
         this.startedAt = Date.now();
+        this.refreshBudgetTimer = setTimeout(() => {
+            void this.showWaitingForResult(this.opts.locale === "en"
+                ? "Foreground refresh budget reached; background results are still monitored."
+                : "前台刷新时间已到，过程卡停止实时刷新；后台继续接收结果。").catch(err => this.callbacks.warn?.("live status freeze failed", err));
+        }, this.opts.refreshBudgetMs ?? FOREGROUND_WAIT_MS);
+        this.refreshBudgetTimer.unref?.();
         if (initialDetail && initialDetail.trim()) {
             this.pushLine("lifecycle", initialDetail.trim());
         }
@@ -56,6 +66,12 @@ export class LiveStatusController {
     async progress(event) {
         if (this.disabled || this.finalized)
             return;
+        if (this.updatesFrozen) {
+            // Keep only the cheap local counter for the eventual one-time summary.
+            if (typeof event !== "string" && event.kind === "tool" && event.phase === "start")
+                this.toolCallCount++;
+            return;
+        }
         // 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
@@ -96,9 +112,41 @@ export class LiveStatusController {
         else {
             return; // lifecycle ticks: ignore (footer timer already advances)
         }
+        this.waitingForResult = false;
         await this.ensureCreatedNow();
         await this.safeEdit(this.buildView());
     }
+    /** Freeze recurring/progress edits, not the original result observer.
+     * A single final/error summary remains allowed when the real outcome arrives. */
+    async showWaitingForResult(detail) {
+        if (this.disabled || this.finalized || this.updatesFrozen)
+            return;
+        this.updatesFrozen = true;
+        this.waitingForResult = true;
+        this.pushLine("lifecycle", detail);
+        this.stopTimers();
+        if (this.createPromise)
+            await this.createPromise.catch(() => { });
+        this.stopTimers();
+        if (this.messageId && !this.disabled)
+            await this.safeEditFinal(this.buildView());
+    }
+    /** Release only local observation of a now-idle session, without claiming
+     * the previous task succeeded or was aborted. Normal progress is unchanged. */
+    async pauseForUnconfirmedResult(detail, title) {
+        if (this.finalized)
+            return;
+        this.pushLine("lifecycle", detail);
+        this.finalized = true;
+        this.stopTimers();
+        if (this.createPromise)
+            await this.createPromise.catch(() => { });
+        if (!this.messageId || this.disabled)
+            return;
+        const view = this.buildView();
+        view.title = title || (this.opts.locale === "en" ? `${this.opts.botName} result unconfirmed` : `${this.opts.botName} 结果未确认`);
+        await this.safeEditFinal(view);
+    }
     async complete() {
         this.state = "done";
         this.finalized = true;
@@ -205,6 +253,10 @@ export class LiveStatusController {
             this.lines = this.lines.slice(this.lines.length - limit);
     }
     stopTimers() {
+        if (this.refreshBudgetTimer) {
+            clearTimeout(this.refreshBudgetTimer);
+            this.refreshBudgetTimer = undefined;
+        }
         if (this.createTimer) {
             clearTimeout(this.createTimer);
             this.createTimer = undefined;
@@ -244,11 +296,11 @@ export class LiveStatusController {
     }
     /** Refresh the elapsed-time footer periodically even with no new activity. */
     startTicker() {
-        if (this.tickTimer || this.disabled || this.finalized)
+        if (this.tickTimer || this.disabled || this.finalized || this.updatesFrozen)
             return;
         const tickMs = this.opts.tickMs ?? DEFAULT_TICK_MS;
         this.tickTimer = setInterval(() => {
-            if (this.finalized || this.disabled || !this.messageId)
+            if (this.finalized || this.disabled || this.updatesFrozen || !this.messageId)
                 return;
             void this.safeEdit(this.buildView());
         }, tickMs);
@@ -257,7 +309,7 @@ export class LiveStatusController {
     async safeEdit(view, force = false) {
         if (!this.messageId || this.disabled)
             return false;
-        if (!force && this.finalized)
+        if (!force && (this.finalized || this.updatesFrozen))
             return false;
         const sig = this.signature(view);
         if (!force && sig === this.lastSentSignature)
@@ -338,6 +390,8 @@ export class LiveStatusController {
             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 if (this.waitingForResult)
+            title = en ? `${this.opts.botName} waiting (card frozen)` : `${this.opts.botName} 等待后续结果（已停止刷新）`;
         else
             title = en ? `${this.opts.botName} is working` : `${this.opts.botName} \u6b63\u5728\u6267\u884c`;
         // On a clean finish (done / NO_REPLY) show only the compact summary. On a