openclaw-lark-multi-agent 1.4.9 → 1.4.11

package/README.md

@@ -601,10 +601,20 @@ 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
+LMA pauses foreground waiting after **10 consecutive minutes without effective
+task activity**, not after ten minutes of total runtime. New owned assistant
+text or distinct tool start/completion resets the collector's idle clock;
+card elapsed ticks, status polling, usage-only and duplicate events do not.
+There is no independent card lifetime, and time before chat.send admission /
+collector start is not charged as task silence. A write completion at 9:35 means
+no silence freeze before 19:35, not a freeze at 10:00.
+LMA sends a normal wait notice rather than claiming execution failed, displaying
+the actual status even if unavailable. Confirmed chat-final `yielded: true`
+still pauses immediately. Once frozen, the old card does not auto-resume after
+later tool activity (same published policy for silence and yield); 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.
+
+Timing/API parameters and limitations: [foreground idle semantics](docs/foreground-idle-2026-09-11.md).

package/README.zh-CN.md

@@ -509,8 +509,16 @@ MIT
 1000 token 四舍五入为整数。缺失或明确过期的数据不冒充 0。尾部反映发送前
 查询的状态，不会持续自动刷新历史回复。
 
-前台结果等待与过程卡刷新预算调整为 10 分钟。会话仍在 running 时发送普通
-等待提示，不把它当作整个任务执行失败；旧卡不再周期刷新或随工具进度编辑。
+前台等待改为**连续 10 分钟没有有效任务活动才暂停**，不是任务总时长上限。
+已归属本次任务的新 assistant 文本、不同工具调用的开始/结束等会重置 collector
+的静默计时；卡片 elapsed ticker、状态轮询、usage-only 与重复事件不会续时。
+卡片没有独立总时长计时器；chat.send 接受及 collector 启动前的排队/内部耗时不算
+任务静默。9:35 的 write 完成后，最早 19:35 静默到期，不能在 10:00 冻结。
+到期发送普通等待提示，显示实际状态（不可用也不冒充 running），不判任务失败。
+真正的 chat-final `yielded: true` 仍立即提示并冻结，不等 10 分钟。
+普通静默暂停与 yield 都沿用已发布策略：后续工具活动不会自动解冻旧卡。
 后台仍监听原任务，保留原队列，不因此停止或自动重发请求。真实结果另行回复，
 保留必要的终态收尾。本改动不缩短 Gateway 的执行时限，也不包含未验收的
 steer V2 与问答适配器。
+
+计时、API 参数及限制详见 [前台静默计时说明](docs/foreground-idle-2026-09-11.md)。

package/dist/feishu-bot.js

@@ -1361,8 +1361,8 @@ export class FeishuBot {
                         currentMessage: mergedContent,
                         currentSenderName: lastHuman.senderName,
                         deliver: false,
-                        // Keep bridge UX responsive; long agent/tool loops should surface a clear failure
-                        // instead of leaving reactions stuck forever.
+                        // Pause foreground only after consecutive effective-activity silence;
+                        // active long-running tool loops are not a failure.
                         timeoutMs: FOREGROUND_WAIT_MS,
                         includeContext: !isNativeCommandTrigger,
                         includeBridgeAttachmentHint: !isNativeCommandTrigger,
@@ -1388,7 +1388,10 @@ export class FeishuBot {
                         onProgress: (event) => liveStatus?.progress(event),
                         onWaitPaused: async (notice) => {
                             await liveStatus?.showWaitingForResult(notice.message);
-                            if (Date.now() - (this.lastRealDeliveryAt.get(chatId) || 0) >= 5000)
+                            // 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);
                         },
                     }));

package/dist/live-status.d.ts

@@ -50,8 +50,6 @@ 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;
@@ -63,7 +61,6 @@ export declare class LiveStatusController {
     private startedAt;
     private createTimer?;
     private tickTimer?;
-    private refreshBudgetTimer?;
     private createPromise?;
     private finalized;
     private waitingForResult;

package/dist/live-status.js

@@ -1,4 +1,3 @@
-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.
@@ -23,7 +22,6 @@ export class LiveStatusController {
     startedAt = Date.now();
     createTimer;
     tickTimer;
-    refreshBudgetTimer;
     createPromise;
     finalized = false;
     waitingForResult = false;
@@ -49,12 +47,9 @@ export class LiveStatusController {
         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?.();
+        // Presentation may start before chat.send admission. Only the collector's
+        // effective-activity idle decision (or confirmed yield) freezes this card;
+        // elapsed ticks are presentation, never evidence of task progress.
         if (initialDetail && initialDetail.trim()) {
             this.pushLine("lifecycle", initialDetail.trim());
         }
@@ -253,10 +248,6 @@ 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;

package/dist/openclaw-client.d.ts

@@ -226,6 +226,7 @@ export declare class OpenClawClient {
         message: string;
         attachments?: ChatAttachment[];
         deliver?: boolean;
+        /** Consecutive effective-activity silence after admission/collector start; default 10 minutes, not total run time. */
         timeoutMs?: number;
         emptyFinalAsNoReply?: boolean;
         /** Called immediately before issuing chat.send RPC; use for at-most-once bookkeeping. */
@@ -256,6 +257,7 @@ export declare class OpenClawClient {
         currentMessage: string;
         currentSenderName: string;
         deliver?: boolean;
+        /** Consecutive effective-activity silence after admission/collector start; default 10 minutes, not total run time. */
         timeoutMs?: number;
         emptyFinalAsNoReply?: boolean;
         /** Native escaped commands (//status -> /status) should not receive catch-up context. */

package/dist/openclaw-client.js

@@ -1,6 +1,6 @@
 import WebSocket from "ws";
 import { SessionWaitPaused, normalizeSessionRuntimeStatus, isWaitTimeout, FOREGROUND_WAIT_MS } from "./session-status.js";
-import { randomUUID } from "crypto";
+import { createHash, randomUUID } from "crypto";
 import { mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
 import { basename, extname, join, resolve, sep } from "path";
 import { getBridgeAttachmentsDir, getDataDir } from "./paths.js";
@@ -231,7 +231,9 @@ export class OpenClawClient {
                             this.agentEvents.get(sk).push({
                                 ...frame.payload,
                                 stream: "chatFinal",
-                                data: { text: textParts.join("\n") },
+                                // Only the Gateway chat-final envelope confirms a handoff.
+                                // Never infer it from tool names, arguments or raw tool output.
+                                data: { text: textParts.join("\n"), gatewayYielded: frame.payload?.yielded === true },
                             });
                         }
                         else if (state === "error") {
@@ -467,6 +469,11 @@ export class OpenClawClient {
     /** Render protocol-4 structured tool args/results without `[object Object]`.
      * Prefer useful, non-secret fields and keep the fallback bounded. */
     formatToolValue(value, toolName, phase) {
+        // sessions_yield.message is private resumed context. Do not mirror its
+        // arguments/results (including JSON strings) into process cards or verbose
+        // tool replies. This is redaction only, never evidence of a handoff.
+        if (toolName === "sessions_yield")
+            return "";
         if (value === null || value === undefined || value === "")
             return "";
         if (typeof value === "string")
@@ -704,7 +711,7 @@ export class OpenClawClient {
      */
     collectReply(runId, timeoutMs = FOREGROUND_WAIT_MS, targetSessionKey, options) {
         let cleanupObservation = () => { };
-        return new Promise((resolve, reject) => {
+        return new Promise((resolveResult, rejectResult) => {
             // Whether we were connected when the run started. We only treat a later
             // disconnect as a mid-run gateway drop (fail fast) if we began connected;
             // this keeps unit tests that drive collectReply without a live socket from
@@ -713,6 +720,7 @@ export class OpenClawClient {
             let text = "";
             let chatDeltaText = "";
             let chatFinalText = "";
+            let chatFinalSeen = false;
             let transcriptAssistantText = "";
             let sessionKey = targetSessionKey ? `agent:main:${targetSessionKey.replace(/^agent:[^:]+:/, "")}` : "";
             let shortSessionKey = targetSessionKey ? targetSessionKey.replace(/^agent:[^:]+:/, "") : "";
@@ -739,13 +747,18 @@ export class OpenClawClient {
             };
             let idleTimer;
             let observationClosed = false;
+            // Close synchronously: a deferred yield notice must not overtake a final
+            // or error just because Promise.finally cleanup has not run yet.
+            const resolve = (value) => { observationClosed = true; resolveResult(value); };
+            const reject = (error) => { observationClosed = true; rejectResult(error); };
             let checkingState = false;
             let lastStateCheckAt = -Infinity;
             let quietNotified = false;
             let decidingTimeout = false;
             let waitNoticeSent = false;
             let foregroundPaused = false;
-            let foregroundWaitTimer;
+            let foregroundYielded = false;
+            let turnYielded = false;
             const handleTimeoutResult = async (error) => {
                 if (observationClosed)
                     return;
@@ -757,8 +770,6 @@ export class OpenClawClient {
                     // Foreground notice, background observation. Keep the original queue
                     // owner/progress path so later input still steers into the same run.
                     foregroundPaused = true;
-                    if (foregroundWaitTimer)
-                        clearTimeout(foregroundWaitTimer);
                     if (!waitNoticeSent) {
                         waitNoticeSent = true;
                         try {
@@ -775,7 +786,7 @@ export class OpenClawClient {
                 }
                 reject(error);
             };
-            const checkRunState = async () => {
+            const checkRunState = async (idleStillCurrent = () => true) => {
                 if (observationClosed || checkingState || Date.now() - lastStateCheckAt < 60_000)
                     return;
                 checkingState = true;
@@ -801,8 +812,10 @@ export class OpenClawClient {
                     else if (snapshot.status === "error" || snapshot.status === "timeout") {
                         if (snapshot.status === "timeout" || isWaitTimeout(String(snapshot.error || ""))) {
                             const status = await this.getSessionRuntimeStatus(targetSessionKey || sessionKey);
+                            collectEvents();
                             if (!observationClosed && status.running) {
-                                await handleTimeoutResult(new SessionWaitPaused(status, true));
+                                if (idleStillCurrent())
+                                    await handleTimeoutResult(new SessionWaitPaused(status, true));
                                 return;
                             }
                         }
@@ -817,33 +830,102 @@ export class OpenClawClient {
                     checkingState = false;
                 }
             };
+            // One clock for foreground silence and subsequent low-frequency observation.
+            // A generation fences status RPCs that complete after newer real activity.
+            let idleGeneration = 0;
             const resetIdleTimer = (delayMs = timeoutMs, activity = true) => {
                 if (activity) {
                     if (!foregroundPaused)
                         waitNoticeSent = false;
                     quietNotified = false;
                 }
+                const generation = ++idleGeneration;
+                const idleStillCurrent = () => !observationClosed && generation === idleGeneration;
                 if (idleTimer)
                     clearTimeout(idleTimer);
                 if (observationClosed)
                     return;
                 idleTimer = setTimeout(async () => {
+                    // Drain already-received frames before judging silence: the 50ms
+                    // collection poll may otherwise run just after this deadline.
+                    collectEvents();
+                    if (!idleStillCurrent())
+                        return;
                     if (!quietNotified) {
                         quietNotified = true;
                         console.warn(`[OpenClaw] quiet run ${runId}; checking Gateway state without stopping execution`);
                     }
-                    await checkRunState();
-                    if (!observationClosed) {
-                        const status = await this.getSessionRuntimeStatus(targetSessionKey || sessionKey);
-                        if (!observationClosed && status.running) {
-                            await handleTimeoutResult(new SessionWaitPaused(status));
-                            return;
-                        }
+                    await checkRunState(idleStillCurrent);
+                    if (!idleStillCurrent())
+                        return;
+                    const status = await this.getSessionRuntimeStatus(targetSessionKey || sessionKey);
+                    collectEvents();
+                    if (!idleStillCurrent())
+                        return;
+                    // With a foreground callback, silence freezes presentation even when
+                    // status is unknown/idle; never invent running. Without one, retain
+                    // the published running-only typed outcome and background checks.
+                    if (status.running || options?.onWaitPaused) {
+                        await handleTimeoutResult(new SessionWaitPaused(status));
+                        return;
                     }
-                    if (!observationClosed)
-                        resetIdleTimer(60_000, false);
+                    resetIdleTimer(60_000, false);
                 }, delayMs);
             };
+            // Activity filtering is deliberately separate from reply assembly/matching:
+            // legacy session fallback must keep delivering replies as before, but an
+            // unrelated/unidentified run must not extend this run's foreground wait.
+            const activityKeys = new Set();
+            const activityText = new Map();
+            const claimActivity = (value) => {
+                // Retain fingerprints rather than copies of cumulative/private text.
+                const key = createHash("sha256").update(value).digest("hex");
+                if (activityKeys.has(key))
+                    return false;
+                activityKeys.add(key);
+                return true;
+            };
+            const hasEffectiveActivity = (ev) => {
+                if (!ev.runId || !activeRunIds.has(ev.runId))
+                    return false;
+                const data = ev.data || {};
+                const run = String(ev.runId);
+                if (ev.stream === "tool" || (ev.stream === "item" && data.kind === "tool")) {
+                    const phase = data.phase === "result" ? (data.isError || data.error ? "error" : "end") : data.phase;
+                    if (phase !== "start" && phase !== "end" && phase !== "error")
+                        return false;
+                    // Canonical tool and legacy item mirrors share identity and phase.
+                    // Without a call id, conservatively recognize each name/phase once.
+                    const id = data.toolCallId || data.itemId || data.id || data.name || data.toolName;
+                    return Boolean(id) && claimActivity(JSON.stringify([run, "tool", id, phase]));
+                }
+                if (ev.stream === "lifecycle" && data.phase === "start") {
+                    return claimActivity(JSON.stringify([run, "start"]));
+                }
+                if (ev.stream === "assistant" || ev.stream === "chatDelta" || ev.stream === "transcriptAssistant") {
+                    const fullText = typeof data.text === "string" ? data.text : "";
+                    const chunk = fullText || data.deltaText || data.delta;
+                    const replace = Boolean(fullText || data.replace);
+                    if (typeof chunk !== "string" || !chunk.trim())
+                        return false;
+                    const source = JSON.stringify([run, ev.stream]);
+                    // seq identifies repeated incremental frames, not progress by itself.
+                    // No-seq identical fragments are ambiguous: do not let replay extend idle.
+                    if (!claimActivity(JSON.stringify([source, ev.seq ?? null, replace, chunk])))
+                        return false;
+                    const previous = activityText.get(source) || "";
+                    const next = replace ? chunk : previous + chunk;
+                    activityText.set(source, next);
+                    if (next === previous || (replace && previous.includes(next)))
+                        return false;
+                    // Replayed replacement snapshots and assistant/chat/transcript mirrors
+                    // with the same accumulated text are not additional task progress.
+                    return claimActivity(JSON.stringify([run, "text", next]));
+                }
+                // Usage, ticks, user receipts, status/wait responses and unknown streams
+                // are not verified task progress. Tool output is counted at completion.
+                return false;
+            };
             const summarizeActivity = (ev) => {
                 if (ev.stream === "item") {
                     const data = ev.data || {};
@@ -906,10 +988,12 @@ export class OpenClawClient {
                     clearTimeout(genericChatErrorTimer);
                 resolve(finalText);
             };
-            const poller = setInterval(() => {
+            const collectEvents = () => {
+                if (observationClosed)
+                    return;
                 // Gateway connection dropped mid-run (e.g. gateway restart): the run will
                 // never deliver a reply on this connection, so stop waiting instead of
-                // hanging until the 30-min idle timeout. Failing fast lets the bridge
+                // hanging until the idle timeout. Failing fast lets the bridge
                 // release its busy lock so new messages are not stuck "waiting".
                 if (startedConnected && !this.connected) {
                     clearInterval(poller);
@@ -960,7 +1044,6 @@ export class OpenClawClient {
                             bucket.splice(i, 1);
                             if (!anchorSeen && isExpectedUserText(ev.data?.text || "")) {
                                 anchorSeen = true;
-                                resetIdleTimer();
                                 for (const pendingEv of preAnchorEvents) {
                                     const pendingRunId = typeof pendingEv.runId === "string" ? pendingEv.runId : "";
                                     if (pendingRunId && pendingEv.stream === "lifecycle" && pendingEv.data?.phase === "start") {
@@ -982,6 +1065,16 @@ export class OpenClawClient {
                             }
                             continue;
                         }
+                        // After handoff, an unowned new run (including requester-settle)
+                        // retains its existing proactive delivery route. A session/lifecycle
+                        // start alone must not turn it into the old run's final. Discussion's
+                        // transcript mute marks scheduler-owned collection; retain its existing
+                        // anchored collector path rather than changing discussion routing.
+                        if (eventSessionMatches && foregroundYielded && evRunId && !matchesRun
+                            && !this.mutedProactiveSessions.has(sessionKey) && !this.mutedProactiveSessions.has(shortSessionKey)) {
+                            bucket.splice(i, 1);
+                            continue;
+                        }
                         if (eventSessionMatches && expectedUserText && !anchorSeen && !matchesRun) {
                             bucket.splice(i, 1);
                             preAnchorEvents.push(ev);
@@ -1021,10 +1114,8 @@ export class OpenClawClient {
                             continue;
                         }
                         bucket.splice(i, 1);
-                        // Any matching event — including toolCall/toolResult/item/lifecycle —
-                        // means the agent is still alive. Use an idle timeout, not an absolute
-                        // wall-clock timeout, so long tool-heavy tasks are not killed while active.
-                        resetIdleTimer();
+                        if (hasEffectiveActivity(ev))
+                            resetIdleTimer();
                         rememberActivity(ev);
                         // If more events arrive after a replay-invalid lifecycle end, that lifecycle
                         // was not terminal for the user-visible run. Keep waiting for the real final.
@@ -1035,6 +1126,10 @@ export class OpenClawClient {
                         if (ev.stream !== "lifecycle") {
                             pendingRuntimeFailureText = "";
                         }
+                        // A matched resumed turn can again complete via the existing
+                        // assistant/transcript + lifecycle path, even without chat final.
+                        if (ev.stream === "lifecycle" && ev.data?.phase === "start")
+                            turnYielded = false;
                         if (ev.stream === "lifecycle" && ev.data?.phase === "start" && !lifecycleStartedLogged) {
                             lifecycleStartedLogged = true;
                             console.log(`[OpenClaw] lifecycle start for runId=${runId} after ${Date.now() - collectStartedAt}ms`);
@@ -1067,17 +1162,48 @@ export class OpenClawClient {
                             }
                         }
                         if (ev.stream === "chatFinal") {
+                            chatFinalSeen = true;
+                            if (ev.data?.gatewayYielded === true) {
+                                // A yielded turn is not a terminal answer, even if its buffered
+                                // message contains a preface. Preserve the collector/queue owner
+                                // and final-delivery key; only pause foreground presentation.
+                                if (chatFinalText.trim())
+                                    continue; // an actual final wins
+                                foregroundYielded = true;
+                                turnYielded = true;
+                                text = chatDeltaText = transcriptAssistantText = "";
+                                if (chatFinalTimer) {
+                                    clearTimeout(chatFinalTimer);
+                                    chatFinalTimer = null;
+                                }
+                                if (lifecycleEndTimer) {
+                                    clearTimeout(lifecycleEndTimer);
+                                    lifecycleEndTimer = null;
+                                }
+                                // Finish scanning this batch first so an already-arrived real
+                                // final/error wins over a stale waiting notice. No status RPC
+                                // (or ten-minute silence) is needed to confirm this wire fact.
+                                if (options?.onWaitPaused)
+                                    void Promise.resolve().then(() => handleTimeoutResult(new SessionWaitPaused(normalizeSessionRuntimeStatus(undefined), false, "yield")));
+                                continue;
+                            }
                             chatFinalText = ev.data?.text || "";
+                            if (chatFinalText.trim())
+                                turnYielded = false;
+                            else if (turnYielded)
+                                continue;
                             // Fallback: if lifecycle end doesn't arrive within 5s, resolve
                             if (!chatFinalTimer) {
                                 chatFinalTimer = setTimeout(() => {
                                     console.warn(`[OpenClaw] collectReply: lifecycle end missing, using chatFinal fallback`);
-                                    this.abortChat(targetSessionKey || sessionKey, runId).catch((err) => {
-                                        console.warn(`[OpenClaw] abort after chatFinal fallback failed:`, err.message);
-                                    });
                                     // Prefer final chat message over accumulated deltas: some providers may
                                     // emit only partial deltas (e.g. "N") while final contains "NO_REPLY".
                                     const latestFinalText = this.pickBestCollectedText(chatFinalText, text, chatDeltaText, transcriptAssistantText);
+                                    // Never abort a yielded original run, nor an empty final.
+                                    if (!foregroundYielded && latestFinalText)
+                                        this.abortChat(targetSessionKey || sessionKey, runId).catch((err) => {
+                                            console.warn(`[OpenClaw] abort after chatFinal fallback failed:`, err.message);
+                                        });
                                     if (latestFinalText) {
                                         finish(latestFinalText);
                                     }
@@ -1092,6 +1218,11 @@ export class OpenClawClient {
                             }
                         }
                         if (ev.stream === "lifecycle" && ev.data?.phase === "end") {
+                            // paused/end_turn can beat the confirming chat event, including
+                            // discussion's emptyFinalAsNoReply path. It is neither success
+                            // nor failure and alone does NOT authorize a handoff notice.
+                            if (!chatFinalText.trim() && (turnYielded || (ev.data?.livenessState === "paused" && ev.data?.stopReason === "end_turn")))
+                                continue;
                             // Prefer final chat message over accumulated deltas: some providers may
                             // emit only partial deltas (e.g. "N") while final contains "NO_REPLY".
                             const finalText = this.pickBestCollectedText(chatFinalText, text, chatDeltaText, transcriptAssistantText);
@@ -1143,7 +1274,12 @@ export class OpenClawClient {
                             };
                             // If lifecycle end beats chat final, a short delta like "N" can be a truncated
                             // final reply. Wait for chatFinal before resolving; otherwise suppress lone "N".
-                            if (!options?.emptyFinalAsNoReply && ev.data?.livenessState === "working" && !chatFinalText && text.length <= 1) {
+                            if ((!options?.emptyFinalAsNoReply && ev.data?.livenessState === "working" && !chatFinalText && text.length <= 1)
+                                || (options?.emptyFinalAsNoReply && !chatFinalSeen && !finalText)) {
+                                // A lifecycle-only empty discussion end also needs this small
+                                // window for a confirming yielded chat final, not instant NO_REPLY.
+                                if (lifecycleEndTimer)
+                                    clearTimeout(lifecycleEndTimer);
                                 lifecycleEndTimer = setTimeout(finishFromLifecycle, 5000);
                             }
                             else {
@@ -1164,7 +1300,6 @@ export class OpenClawClient {
                             // 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;
                             }
@@ -1222,7 +1357,6 @@ export class OpenClawClient {
                             }
                             if (this.isRecoverableAgentError(errText)) {
                                 pendingRuntimeFailureText = `⚠️ Agent 未正常完成\n原因: ${errText}`;
-                                resetIdleTimer();
                                 console.warn(`[OpenClaw] recoverable chat error for runId=${evRunId || runId}; deferring: ${errText.slice(0, 120)}`);
                                 bucket.splice(i, 1);
                                 continue;
@@ -1254,7 +1388,8 @@ export class OpenClawClient {
                         }
                     }
                 }
-            }, 50);
+            };
+            const poller = setInterval(collectEvents, 50);
             const observationKey = targetSessionKey ? this.canonicalSessionKey(targetSessionKey) : "";
             const checkAfterNoActiveRun = async () => {
                 await checkRunState();
@@ -1273,29 +1408,12 @@ export class OpenClawClient {
             };
             if (observationKey)
                 this.runStateChecks.set(observationKey, checkAfterNoActiveRun);
-            // Fixed foreground budget: tool/assistant activity must not keep a card
-            // refreshing indefinitely. The original result observer stays alive.
-            if (options?.onWaitPaused) {
-                foregroundWaitTimer = setTimeout(async () => {
-                    if (observationClosed || foregroundPaused)
-                        return;
-                    await checkRunState();
-                    if (observationClosed || foregroundPaused)
-                        return;
-                    const status = await this.getSessionRuntimeStatus(targetSessionKey || sessionKey);
-                    if (!observationClosed && !foregroundPaused)
-                        await handleTimeoutResult(new SessionWaitPaused(status));
-                }, timeoutMs);
-                foregroundWaitTimer.unref?.();
-            }
             // Bound local resources without cancelling an execution we cannot prove stuck.
             const observationHorizon = setTimeout(() => reject(new Error("LMA 本地监听达到 24 小时上限，结果未确认；未发送停止请求，请检查原运行。")), 24 * 60 * 60_000);
             observationHorizon.unref?.();
             cleanupObservation = () => {
                 observationClosed = true;
                 clearTimeout(idleTimer);
-                if (foregroundWaitTimer)
-                    clearTimeout(foregroundWaitTimer);
                 clearTimeout(observationHorizon);
                 clearInterval(poller);
                 if (chatFinalTimer)

package/dist/session-status.d.ts

@@ -1,4 +1,5 @@
-/** Frontend budget only; does not change Gateway execution limits. */
+/** Consecutive effective-activity silence, not a total foreground lifetime.
+ * Starts with accepted-request collection; does not change Gateway execution limits. */
 export declare const FOREGROUND_WAIT_MS: number;
 export type SessionRuntimeStatus = {
     status: string;
@@ -11,8 +12,9 @@ export declare const isWaitTimeout: (text: string) => boolean;
 export declare function normalizeSessionRuntimeStatus(value: any): SessionRuntimeStatus;
 /** Compact presentation only; never replaces the actual status/model values. */
 export declare function formatSessionFooter(snapshot: SessionRuntimeStatus): string;
-/** Local observation has ended, NOT an assertion that execution failed. */
+/** Foreground waiting paused, NOT an assertion that execution ended. */
 export declare class SessionWaitPaused extends Error {
     readonly snapshot: SessionRuntimeStatus;
-    constructor(snapshot: SessionRuntimeStatus, reportedTimeout?: boolean);
+    readonly reason: "timeout" | "yield";
+    constructor(snapshot: SessionRuntimeStatus, reportedTimeout?: boolean, reason?: "timeout" | "yield");
 }

package/dist/session-status.js

@@ -1,4 +1,5 @@
-/** Frontend budget only; does not change Gateway execution limits. */
+/** Consecutive effective-activity silence, not a total foreground lifetime.
+ * Starts with accepted-request collection; does not change Gateway execution limits. */
 export const FOREGROUND_WAIT_MS = 10 * 60_000;
 export const isWaitTimeout = (text) => /\btimeout\b|timed\s*out|超时/i.test(text) && !/invalid|validation|schema|malformed|permission denied|forbidden|unauthorized|authentication failed|quota|rate limit|无效参数|参数错误|校验失败/i.test(text);
 export function normalizeSessionRuntimeStatus(value) {
@@ -26,14 +27,18 @@ export function formatSessionFooter(snapshot) {
     const limitK = limit === undefined ? "?" : Math.max(1, Math.round(limit / 1000));
     return `${snapshot.status} · ${usedK}K/${limitK}K`;
 }
-/** Local observation has ended, NOT an assertion that execution failed. */
+/** Foreground waiting paused, NOT an assertion that execution ended. */
 export class SessionWaitPaused extends Error {
     snapshot;
-    constructor(snapshot, reportedTimeout = false) {
-        super(reportedTimeout
-            ? "⏳ 本轮返回了超时，LMA 已暂停本次等待，但不据此认定整个会话已经结束。会话状态见下方；你可以继续等待后续结果。"
-            : "⏳ 本次等待时间已到，LMA 暂停本轮等待，先返回会话状态供你判断。\n没有因此停止运行或自动重发本次请求；你可以继续等待后续结果。");
+    reason;
+    constructor(snapshot, reportedTimeout = false, reason = "timeout") {
+        super(reason === "yield"
+            ? "⏳ 本轮已转入后台等待；若有后续结果，将继续在此回复。未发送停止请求，也未自动重发请求。"
+            : reportedTimeout
+                ? "⏳ 本轮返回了超时，LMA 已暂停本次等待，但不据此认定整个会话已经结束。会话状态见下方；你可以继续等待后续结果。"
+                : "⏳ 本轮连续无有效进展的等待时间已到，LMA 暂停本轮等待，先返回会话状态供你判断。\n没有因此停止运行或自动重发本次请求；你可以继续等待后续结果。");
         this.snapshot = snapshot;
+        this.reason = reason;
         this.name = "SessionWaitPaused";
     }
 }

package/package.json

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