openclaw-lark-multi-agent 1.4.10 → 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,

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";
@@ -759,7 +759,6 @@ export class OpenClawClient {
             let foregroundPaused = false;
             let foregroundYielded = false;
             let turnYielded = false;
-            let foregroundWaitTimer;
             const handleTimeoutResult = async (error) => {
                 if (observationClosed)
                     return;
@@ -771,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 {
@@ -789,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;
@@ -815,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;
                             }
                         }
@@ -831,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 || {};
@@ -920,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);
@@ -974,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") {
@@ -1045,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.
@@ -1115,7 +1182,7 @@ export class OpenClawClient {
                                 }
                                 // Finish scanning this batch first so an already-arrived real
                                 // final/error wins over a stale waiting notice. No status RPC
-                                // (or ten-minute budget) is needed to confirm this wire fact.
+                                // (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;
@@ -1233,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;
                             }
@@ -1291,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;
@@ -1323,7 +1388,8 @@ export class OpenClawClient {
                         }
                     }
                 }
-            }, 50);
+            };
+            const poller = setInterval(collectEvents, 50);
             const observationKey = targetSessionKey ? this.canonicalSessionKey(targetSessionKey) : "";
             const checkAfterNoActiveRun = async () => {
                 await checkRunState();
@@ -1342,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;

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) {
@@ -35,7 +36,7 @@ export class SessionWaitPaused extends Error {
             ? "⏳ 本轮已转入后台等待；若有后续结果，将继续在此回复。未发送停止请求，也未自动重发请求。"
             : reportedTimeout
                 ? "⏳ 本轮返回了超时，LMA 已暂停本次等待，但不据此认定整个会话已经结束。会话状态见下方；你可以继续等待后续结果。"
-                : "⏳ 本次等待时间已到，LMA 暂停本轮等待，先返回会话状态供你判断。\n没有因此停止运行或自动重发本次请求；你可以继续等待后续结果。");
+                : "⏳ 本轮连续无有效进展的等待时间已到，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.10",
+  "version": "1.4.11",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {