openclaw-lark-multi-agent 1.4.7 → 1.4.9

package/README.md

@@ -101,18 +101,17 @@ lma install-windows-service
 
 ### Real-time steering
 
-When the agent is mid-run and a new message arrives, the bridge submits it via
-OpenClaw's public `chat.send` API with `queueMode: "steer"`. The RPC
-acknowledgment is provisional: LMA retains its durable pending trigger until a
-matching `session.message` proves transcript commitment/consumption, and only
-then switches Feishu from Typing to Get. Async `error`/`aborted` terminals are
-routed by run id, while unconsumed input remains available for normal queue
-fallback. This replaces the deprecated synchronous plugin primitive whose
-boolean could not represent later runtime rejection.
-
-OpenClaw 2026.8+ no longer requires the bundled `lma-steer` plugin. The
-`install-steer-plugin` command remains temporarily for older installations but
-current LMA releases do not call its private Gateway method.
+When the agent is mid-run and a new message arrives, the bridge calls the
+bundled `lma-steer` plugin. The plugin resolves the active embedded run and only
+returns `steered` after queueing the message into that run. LMA then retains its
+durable pending trigger until a matching `session.message` proves transcript
+commitment/consumption, and only then switches Feishu from Typing to Get.
+
+OpenClaw's public `chat.send { queueMode: "steer" }` returns `started` even when
+a message falls through to a later ordinary run, so LMA does not use that
+ambiguous response as proof of realtime insertion. If the plugin is unavailable,
+there is no active run, or injection is rejected, the message safely stays in
+the normal queue and is never falsely shown as inserted.
 
 Useful CLI commands:
 
@@ -122,7 +121,7 @@ lma doctor
 lma start [config]
 lma init [--state-dir DIR] [--force]
 lma install-systemd [--user|--system] [--state-dir DIR]
-lma install-steer-plugin [--no-force]  # legacy; not needed on OpenClaw 2026.8+
+lma install-steer-plugin [--no-force]  # required for realtime mid-run insertion
 ```
 
 ## Quick start from source
@@ -464,9 +463,11 @@ when that list is non-empty. Exact refs and `provider/*` wildcards are accepted.
 LMA now surfaces a model-policy rejection instead of logging a false “model
 ensured” success.
 
-Mid-run messages use the public `chat.send { queueMode: "steer" }` path. LMA
-keeps the durable trigger until `session.message` confirms consumption; this is
-also the signal for the visible Typing-to-Get transition.
+Mid-run messages use the bundled `lma-steer` plugin because public
+`chat.send { queueMode: "steer" }` cannot distinguish true in-run insertion from
+a later ordinary run. LMA keeps the durable trigger until `session.message`
+confirms consumption; this is also the signal for the visible Typing-to-Get
+transition. Without the plugin, messages remain safely queued.
 
 ## Live status
 
@@ -589,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

@@ -414,7 +414,7 @@ LMA 以 Gateway protocol 4 为基线，并使用 `openclaw@2026.8.2` 构建和
 
 新版把模型元数据与模型覆盖允许列表分开。如果 `agents.defaults.modelPolicy.allow` 非空，LMA 配置中的每个模型都必须被该列表的精确模型引用或 `provider/*` 通配符允许。遇到拒绝时，LMA 会直接报告 model policy 错误，不再错误记录“模型已确保”。
 
-执行中插入的消息改用公开的 `chat.send { queueMode: "steer" }`。RPC 成功返回只是暂时接受；LMA 会继续保留本地 pending trigger，只有匹配的 `session.message` 确认消息已写入转录并被消费后才清除，同时把飞书标记从 Typing 切换为 Get。异步 `error`/`aborted` 按 runId 投递，未消费的输入仍由普通队列兜底。这样不再依赖无法表达后续异步拒绝的旧同步插件原语。
+执行中插入的消息使用内置 `lma-steer` 插件。插件会解析当前 active embedded run，只有消息确实排入该 run 时才返回 `steered`。LMA 仍会保留本地 pending trigger，直到匹配的 `session.message` 确认消息已写入转录并被消费后才清除，同时把飞书标记从 Typing 切换为 Get。公开的 `chat.send { queueMode: "steer" }` 即使退化为稍后的普通 run 也只返回 `started`，因此不再把它当作实时插入成功的证据。插件不可用、没有 active run 或拒绝插入时，消息会安全保留在普通队列中，不会伪报已插入。
 
 ## Live Status 与最终回复
 
@@ -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/cli.js

@@ -206,12 +206,12 @@ function runCapture(cmd, args) {
     }
 }
 /**
- * Install the legacy bundled lma-steer plugin. Current LMA uses OpenClaw's
- * public `chat.send { queueMode: "steer" }` API and does not call this plugin;
- * the command remains only for operators maintaining older LMA deployments.
+ * Install the bundled lma-steer plugin used for observable realtime mid-run
+ * insertion. LMA remains functional without it, but busy messages queue until
+ * the active run completes.
  */
 function cmdInstallSteerPlugin(args) {
-    console.warn("Note: current LMA releases use native chat.send queueMode=steer; this legacy plugin is not required on OpenClaw 2026.8+.");
+    console.warn("Note: lma-steer is required for confirmed realtime mid-run insertion; without it, busy messages remain safely queued.");
     // Default to --force so reinstalling an updated bundled plugin overwrites the
     // previously installed copy. Pass --no-force to keep an existing install.
     const noForce = hasFlag(args, "--no-force");

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.
@@ -968,63 +974,40 @@ export class FeishuBot {
                     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") {
-                    if (insertedId > 0) {
+                    if (insertedId > 0 && !consumedBeforeAck) {
                         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)}..."`);
+                    // The plugin confirmed queueing into the existing embedded run. Keep
+                    // that run's original delivery target and retain the durable trigger
+                    // until session.message proves this specific input was consumed.
+                    console.log(`[${this.config.name}] Agent busy for ${chatId.slice(-8)}, plugin steer accepted (awaiting transcript consumption): "${cleanText.substring(0, 50)}..."`);
                     return;
                 }
-                // Native steer was not accepted. Restore the previous run's routing
-                // target and keep the already-created trigger/reaction for normal drain.
+                // Plugin missing/no active run/rejected: keep the durable trigger for
+                // normal queue drain. Never claim that ambiguous native admission was an
+                // in-run insertion.
                 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
-            }
-            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) ---
@@ -1380,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: () => {
@@ -1403,6 +1386,11 @@ export class FeishuBot {
                             markSubmittedBatch(`submitted:${runId}`);
                         },
                         onProgress: (event) => liveStatus?.progress(event),
+                        onWaitPaused: async (notice) => {
+                            await liveStatus?.showWaitingForResult(notice.message);
+                            if (Date.now() - (this.lastRealDeliveryAt.get(chatId) || 0) >= 5000)
+                                await this.sendWaitPaused(chatId, triggerId, lastHuman.messageId, notice);
+                        },
                     }));
                 }
                 catch (mainErr) {
@@ -1613,6 +1601,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
@@ -1795,13 +1820,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 {
@@ -1844,7 +1869,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)) {
@@ -2067,13 +2106,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));
@@ -2162,11 +2207,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);
             });
@@ -2370,23 +2424,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
@@ -2579,6 +2638,7 @@ export class FeishuBot {
             : undefined;
         liveStatus?.start(meta ? `第 ${meta.round}/${meta.maxRounds} 轮讨论` : "讨论中");
         let reply;
+        let discussionWaitPaused = false;
         try {
             reply = await this.openclawClient.chatSendWithContext({
                 sessionKey,
@@ -2586,20 +2646,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();
@@ -2854,21 +2930,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 },
@@ -2881,7 +2961,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: {
@@ -3213,20 +3293,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" },
@@ -3245,7 +3329,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)