openclaw-lark-multi-agent 1.4.10 → 1.4.12

package/README.md

@@ -306,14 +306,22 @@ By default, a bot responds when:
 
 - it is directly mentioned;
 - `@all` / `@_all` appears in the message;
-- this bot's Free mode is enabled and the message is a plain human message with no targeted mentions.
+- a Chairman is set for this group, and this bot's Free mode is enabled for a plain human message with no mentions;
+- a Chairman is set, no bot is Free, and this bot is the Chairman (even if muted).
 
 Free mode is intentionally per-bot and conservative:
 
-- Free mode lets a bot reply to ordinary human messages without being mentioned.
+- Free mode lets a bot reply to ordinary unmentioned human messages **only while this group has a Chairman**.
 - If a human message mentions another bot, only that bot may respond. Other Free-mode bots stay silent.
 - If a human message mentions a regular person, Free-mode bots stay silent.
-- `@all` remains a broadcast trigger and may activate every eligible bot.
+- `@all` remains a broadcast trigger and may activate every eligible bot. If the message also targets somebody else but not this bot, target exclusivity wins.
+- These rules apply equally to one-bot and multi-bot groups, including local commands such as `/help` and `/free`: no coordinator or single-bot fallback may answer a mention addressed elsewhere.
+- Mention identity requires a matching configured `app_id` or an already probed bot `open_id`. Known conflicting app/open IDs veto a match; neither wins by order. An unprobed open ID cannot establish identity (a matching app ID still can). Display names, including exact names and parenthesized suffixes, never establish identity. Message metadata never updates probed identities.
+- Structured rich-post `at` nodes can supply an already known open ID when mention metadata is absent; they cannot override conflicting metadata. Missing/unresolved mentions or standalone `@name`/platform placeholders fail closed. Embedded `@` in email addresses or ordinary text is not a command or identity signal.
+
+**Clearing Chairman is not mute.** `/chairman off` (also `clear` / `none`) atomically clears the canonical group Chairman and persists Discuss off, stops not-yet-started discussion turns, and blocks **new unmentioned group model triggers**, including Free bots and stale Discuss-on state after reopening the database. It does not abort an executing agent, change an existing queue task's identity, or suppress its eventual result. Explicit verified self/multi-target mentions, standalone `@all`, and private chats retain their normal behavior. Free/mute settings are not reset.
+
+Local management commands are evaluated before the ordinary-chat gate. Use `/chairman <exact configured bot name>` without mentions, or a verified `/chairman @Bot`, to restore the group; Free/Chairman fallback then works again. `/discuss on` still requires a Chairman and must be enabled again after off. Bare group help/settings retain their existing single-coordinator routing; bare `/chairman` shows usage, not status (use `/status`).
 
 Mention-only routing is supported. If a user first sends content and then sends only a bot mention, for example:
 
@@ -344,7 +352,7 @@ Persistent constraints (such as "do not call Feishu send tools directly" and the
 
 `/discuss` is an explicit group-level multi-agent discussion scheduler. It is separate from Free mode:
 
-- `/free` controls whether a single bot may answer plain human messages.
+- `/free` controls whether a single bot may answer plain human messages in a group with a Chairman.
 - `/discuss on` requires a chairman to be set first (`/chairman @Bot`). It lets one coordinator take over plain human messages and run all non-muted bots plus the chairman in barrier-style rounds. Free mode is ignored inside discussion: every bot that is not muted participates regardless of its Free setting.
 - Targeted mentions still fall through to normal routing, so `@GPT hello` works even while discuss mode is enabled.
 - Each participant receives the same round prompt and does not see other participants' replies from the current round until the next round.
@@ -373,11 +381,11 @@ Each group can have exactly one chairman, set with `/chairman @Bot`. Setting a n
 
 ```text
 /chairman @Bot   set the chairman
-/chairman        show the current chairman
+/chairman        show usage (use /status for current chairman)
 /chairman off    clear the chairman
 ```
 
-`/chairman` is a group-level command handled by one coordinator bot, so it produces a single reply.
+`/chairman` is a group-level command: the verified target handles targeted setup, and the coordinator handles untargeted management. Multiple-target errors belong to the first verified target, never an unmentioned coordinator.
 
 ### `/locale`
 
@@ -601,10 +609,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

@@ -236,7 +236,7 @@ openclaw-lark-multi-agent install-windows-service
 - `/mute` — 开关当前 bot 在当前群聊里的 mute 模式
 - `/mode` — 查看当前 bot 在当前聊天里的模式
 - `/discuss on|off|status|stop|rounds N` — 控制群级多 bot 讨论模式（需先设置 Chairman；默认 10 轮）
-- `/chairman [@Bot|off]` — 设置/查看/清除本群唯一 Chairman
+- `/chairman [@Bot|配置名|off]` — 设置/切换/清除本群唯一 Chairman
 - `/locale [zh|en]` — 设置/查看当前群语言
 
 如果你想把 slash command 直接发给 OpenClaw，可以用双斜杠转义：
@@ -284,14 +284,22 @@ openclaw-lark-multi-agent install-windows-service
 
 - 被直接 @；
 - 消息里出现 `@all` / `@_all`；
-- 当前 bot 开启了 Free 模式，并且这是一条没有定向 @ 的普通人类消息。
+- 本群已设置 Chairman、当前 bot 开启了 Free 模式，且这是一条无 @ 的普通人类消息；
+- 本群已设置 Chairman、没有 Free bot，由 Chairman 兜底（即使 Chairman 是 mute）。
 
 Free 模式是 per-bot 且保守的：
 
-- Free 模式允许 bot 在没有被 @ 时回复普通人类消息。
+- Free 模式**仅在本群已设置 Chairman 时**允许 bot 回复无 @ 的普通人类消息。
 - 如果人类消息 @ 了另一个 bot，只有被 @ 的 bot 可以回复，其他 Free 模式 bot 保持静默。
 - 如果人类消息 @ 了普通人，Free 模式 bot 保持静默。
-- `@all` 仍然是广播触发，可激活所有符合条件的 bot。
+- `@all` 仍然是广播触发，可激活所有符合条件的 bot；但同时定向 @ 其他人/bot 且没有 @ 当前 bot 时，定向排他优先。
+- 单 bot 和多 bot 群、Free/Chairman/Discuss、`/help`、`/free` 等本地命令统一遵循定向排他规则；coordinator 或单 bot 不能兜底抢答。
+- 点名身份仅由匹配的配置 `app_id` 或启动探测已确认的 bot `open_id` 确定。已知 app/open ID 冲突时拒绝匹配，不按顺序让其中一个优先；尚未探测的 open ID 不能独立确认身份，但匹配的 app ID 仍可确认。名字、同名人/外部机器人、括号后缀不构成身份依据，消息元数据不会覆盖已探测身份。
+- 富文本结构化 `at` 节点只在缺少 mention 元数据时可按已知 open ID 确认目标，不能覆盖冲突元数据。缺元数据的 `@name` / 平台占位符及无法确认的目标保持安静；邮箱或普通文字内嵌的 `@` 不当作指令或身份信号。
+
+**Chairman off 不是 mute，但禁止无 @ 的普通新消息触发模型。** `/chairman off`（也支持 `clear` / `none`）原子持久化清空群 Chairman 并关闭 Discuss，停止尚未开始的讨论轮次；即使 bot 原来 Free 或数据库遗留 Discuss on，无 Chairman 时普通新消息也不会触发。不会 abort 已执行 agent、改变旧队列任务身份或阻止其最终结果回传；明确 @ 自己/多目标含自己、单独 `@all`、私聊仍按原规则，Free/mute 设置不清除。
+
+本地管理命令先于普通聊天门禁处理。可无 @ 发送 `/chairman 精确配置名`，或通过可靠点名 `/chairman @Bot` 恢复；之后 Free/Chairman 兜底恢复原行为。Discuss 需重新 `/discuss on` 且必须已有 Chairman。无目标管理命令保留原 coordinator 规则；裸 `/chairman` 返回用法，查看状态用 `/status`。
 
 支持“纯 @ 触发”。例如用户先发：
 
@@ -323,8 +331,8 @@ catch-up 上下文是 bot 随当前消息一起拿到的群里未看到的发言
 
 `/discuss` 是显式的群级多智能体讨论调度器，和 Free 模式分工不同：
 
-- `/free` 控制单个 bot 是否可以响应普通人类消息。
-- `/discuss on` 需先设置 Chairman（`/chairman @Bot`）。它让一个 coordinator 接管普通人类消息，并按 barrier-style round 调度所有 Free 模式 bot 加上 Chairman。
+- `/free` 控制单个 bot 是否可以在已设 Chairman 的群响应普通人类消息。
+- `/discuss on` 需先设置 Chairman（`/chairman @Bot`）。它让一个 coordinator 接管普通人类消息，并按 barrier-style round 调度所有非 mute bot 加上 Chairman，忽略 Free 开关。
 - 定向 @ 仍然走普通路由，所以 discuss 开启时 `@GPT hello` 仍会只触发 GPT。
 - 每个参与 bot 在同一轮拿到相同 prompt，本轮内看不到其他 bot 的回复，下一轮才会看到上一轮结果。
 - Chairman 每轮最后发言：先给出自己的观点，质疑薄弱点，调停分歧，并决定继续还是总结。
@@ -352,11 +360,11 @@ catch-up 上下文是 bot 随当前消息一起拿到的群里未看到的发言
 
 ```text
 /chairman @Bot   设置 Chairman
-/chairman        查看当前 Chairman
+/chairman        显示设置用法；查看状态请用 /status
 /chairman off    清除 Chairman
 ```
 
-`/chairman` 是群级命令，由一个 coordinator bot 统一处理，只产生一条回复。
+`/chairman` 是群级命令：定向设置由目标 bot 处理，无目标管理由 coordinator 处理；多目标错误由第一个可靠目标回复，未被点名的 coordinator 不抢答。
 
 ### `/locale` 语言
 
@@ -509,8 +517,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/discussion-manager.js

@@ -124,10 +124,17 @@ export class DiscussionManager {
                     parts.push(`${errorNames.join("、")} ${t.error}`);
                 await sendSystemMessage(t.discussionRoundNotice(current.currentRound, current.maxRounds, parts.join(current.locale === "zh" ? "；" : "; "))).catch(() => { });
             }
+            // stop/preemption may occur while a system notice is being delivered.
+            if (this.sessions.get(session.chatId)?.id !== sessionId || current.status !== "running")
+                return;
             const mustFinish = allNoReply || current.currentRound >= current.maxRounds;
             if (chairman) {
                 const chairmanPrompt = this.buildChairmanPrompt(current, replies, mustFinish);
                 const chairResult = await chairman.runDiscussionTurn(current.chatId, chairmanPrompt, { round: current.currentRound, maxRounds: current.maxRounds });
+                // An old in-flight Chairman may finish after stop or replacement. Its
+                // delivery belongs to that turn, but it must not mutate the new session.
+                if (this.sessions.get(session.chatId)?.id !== sessionId || current.status !== "running")
+                    return;
                 const chairText = (chairResult.text || "").trim();
                 replies[chairman.name] = chairText;
                 const latest = current.completedRounds[current.completedRounds.length - 1];

package/dist/feishu-bot.d.ts

@@ -128,7 +128,6 @@ export declare class FeishuBot {
     private isAllMention;
     private isAllMentionItem;
     private mentionedBotName;
-    private escapeRegExp;
     private resolveBotName;
     private resolveHumanName;
     private cleanMentions;
@@ -206,16 +205,6 @@ export declare class FeishuBot {
     private dispatchPendingDeliveries;
     private hasFreeModeBot;
     private mentionedBotNames;
-    private mentionedBotNamesFromChairmanText;
-    /**
-     * Resolve the target bot name(s) for a /chairman command using every signal
-     * available, in priority order:
-     *   1. Feishu mention metadata (app_id / open_id / name).
-     *   2. Text fallback: "@Bot" or "Bot" written in the message body.
-     *
-     * This keeps /chairman working even when a Feishu client or bridge omits
-     * mention metadata. Returns a de-duplicated, order-preserving list.
-     */
     private resolveChairmanTargets;
     private isDiscussionCoordinator;
     private static markBotSeenInChat;

package/dist/feishu-bot.js

@@ -414,15 +414,8 @@ export class FeishuBot {
             const messageType = message.message_type;
             const messageId = message.message_id;
             const isBot = sender?.sender_type === "app";
-            // Extract bot open_id from mentions
-            if (message.mentions) {
-                for (const m of message.mentions) {
-                    const bot = FeishuBot.allBots.get(m.id?.app_id || "");
-                    if (bot && m.id?.open_id) {
-                        bot.botOpenId = m.id.open_id;
-                    }
-                }
-            }
+            // Identity comes from the startup probe, never from message mentions:
+            // a conflicting app_id/open_id pair must not overwrite a known identity.
             if (messageType !== "text" && messageType !== "image" && messageType !== "file" && messageType !== "audio" && messageType !== "sticker" && messageType !== "post" && messageType !== "share_doc")
                 return;
             // --- Dedup: atomically claim this message for this bot before any await.
@@ -512,7 +505,7 @@ export class FeishuBot {
             cleanText = await this.hydrateFeishuDocsInMessage(cleanText, content, messageId);
             if (!cleanText.trim())
                 return;
-            const routing = this.getRoutingIntent(chatType, message, messageType === "text" ? (content.text || "") : "");
+            const routing = this.getRoutingIntent(chatType, message, messageType === "text" ? (content.text || "") : "", content);
             // Commands may be prefixed by @all / @bot in group chats. Strip those
             // leading routing mentions before deciding whether this is a bridge command
             // or an escaped OpenClaw command.
@@ -551,6 +544,10 @@ export class FeishuBot {
             });
             if (insertedId < 0)
                 insertedId = this.store.getMessageId(messageId) || -1;
+            // Target exclusivity precedes ALL group command/coordinator, broadcast,
+            // single-bot, mute, Free and Discuss paths. Unknown targets are not self.
+            if (chatType !== "p2p" && routing.hasTargetedMention && !routing.isCurrentBotMentioned)
+                return;
             // --- Commands: in p2p always respond; in group, check shouldRespond first ---
             // Single slash commands are handled by the bridge. Double slash commands were
             // already unescaped above and should pass through to OpenClaw instead.
@@ -589,35 +586,28 @@ export class FeishuBot {
                         }
                     }
                     else if (isChairmanCommand) {
-                        // /chairman @Bot is owned by the mentioned bot itself. This avoids
-                        // requiring a coordinator to parse another bot's mention metadata,
-                        // which can vary across Feishu clients/bridges. Untargeted/status,
-                        // @all, and clear/off remain coordinator-owned group commands.
-                        //
-                        // Target resolution uses both Feishu mention metadata AND a text
-                        // fallback (parsing "@Bot" / "Bot" from the raw message), so a
-                        // /chairman that arrives without mention metadata still routes to
-                        // the intended bot instead of silently failing.
+                        // Verified mentions belong to the targeted bot. Bare configured
+                        // names remain local management arguments, not mention identity.
                         const chairmanArg = this.stripLeadingCommandMentions(this.cleanMentions(rawText)).replace(/^\s*\/chairman\b/i, "").trim().toLowerCase();
                         const isClearArg = ["off", "clear", "none"].includes(chairmanArg.split(/\s+/)[0] || "");
                         const hasMentionMeta = (message.mentions || []).some((m) => !this.isAllMentionItem(m));
-                        const targets = this.resolveChairmanTargets(message.mentions || [], cleanText, rawText);
+                        const targets = routing.hasTargetedMention ? routing.targetedBotNames : this.resolveChairmanTargets(message.mentions || [], cleanText, rawText);
                         // A pure status query: no clear keyword, no mention metadata, and no
                         // textual argument at all. Anything else is a set/route attempt.
                         const isStatusArg = !isClearArg && !hasMentionMeta && chairmanArg.length === 0;
                         if (isClearArg || isStatusArg) {
-                            // Group-level status/clear: one coordinator handles it.
-                            if (!this.isDiscussionCoordinator())
+                            // One eligible owner: first verified target, or bare coordinator.
+                            if (routing.hasTargetedMention ? routing.targetedBotNames[0] !== this.config.name : !this.isDiscussionCoordinator())
                                 return;
                         }
                         else if (targets.length >= 1) {
                             // Targets resolved: only the (single) targeted bot acts. If
-                            // multiple distinct targets resolved, the coordinator handles
-                            // the "only one chairman" error once.
+                            // multiple distinct targets resolved, the first target handles
+                            // the "only one chairman" error once (never an unmentioned bot).
                             const uniqueTargets = Array.from(new Set(targets));
                             const targetedSelf = uniqueTargets.includes(this.config.name);
                             if (uniqueTargets.length > 1) {
-                                if (!this.isDiscussionCoordinator())
+                                if (uniqueTargets[0] !== this.config.name)
                                     return;
                             }
                             else if (!targetedSelf) {
@@ -800,6 +790,7 @@ export class FeishuBot {
                     if (next === "free") {
                         await this.replyMessage(messageId, `🔓 ${this.config.name} 已切换到 free 模式
 不需要 @ 也可以回复普通人类消息；如果消息明确 @ 了其他 bot 或普通人，我不会抢答。
+需先设置本群 Chairman，Free 才会回答无 @ 的普通消息。
 如需多轮自动讨论，请使用群级命令 /discuss on。`);
                     }
                     else {
@@ -845,7 +836,7 @@ export class FeishuBot {
                     return;
                 }
                 if (commandName === "/chairman") {
-                    await this.handleChairmanCommand(chatId, chatType, messageId, message.mentions || [], cleanText.trim(), rawText);
+                    await this.handleChairmanCommand(chatId, chatType, messageId, message.mentions || [], cleanText.trim(), rawText, routing.hasTargetedMention ? routing.targetedBotNames : undefined);
                     markCommandSynced();
                     return;
                 }
@@ -855,11 +846,16 @@ export class FeishuBot {
                     return;
                 }
             }
+            // Local management commands above can restore Chairman. Only NEW
+            // unmentioned human triggers are gated; existing queue/delivery owners stay.
+            if (chatType !== "p2p" && !isBot && !routing.hasTargetedMention && !routing.isAllMention
+                && !this.store.getChairmanBot(chatId))
+                return;
             // --- Discuss mode: group-level multi-bot round scheduler. It takes over
             // plain human messages so normal Free mode does not duplicate Round 1.
             // Targeted mentions must fall through to normal routing so @GPT still
             // works while discuss mode is enabled.
-            if (chatType !== "p2p" && !isBot && this.store.getChatInfo(chatId)?.discuss) {
+            if (chatType !== "p2p" && !isBot && this.store.getChairmanBot(chatId) && this.store.getChatInfo(chatId)?.discuss) {
                 // Discuss mode owns ordinary and @all human messages. Explicit @bot/@human
                 // falls through to normal targeted routing.
                 if (!routing.hasTargetedMention) {
@@ -1361,8 +1357,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,
@@ -1702,10 +1698,8 @@ export class FeishuBot {
             return !isBot;
         if (isBot)
             return false;
-        const mentions = message.mentions || [];
-        if (this.isAllMention(rawText, mentions))
-            return true;
-        return this.isMentioned(mentions);
+        const routing = this.getRoutingIntent(chatType, message, rawText);
+        return routing.hasTargetedMention ? routing.isCurrentBotMentioned : routing.isAllMention;
     }
     shouldRespond(chatType, _message, isBot, chatId, routing) {
         if (chatType === "p2p")
@@ -1713,17 +1707,16 @@ export class FeishuBot {
         // Bot messages: only respond if this bot is explicitly mentioned.
         if (isBot)
             return routing.isCurrentBotMentioned;
-        // @all is an explicit broadcast to all non-muted bots.
-        if (routing.isAllMention)
-            return true;
         // Explicit targeted mentions are exclusive. If this bot is not one of the
         // mentioned bots, free/chairman must not steal the turn.
         if (routing.hasTargetedMention)
             return routing.isCurrentBotMentioned;
-        // Human-only mentions are also exclusive; free/chairman should not jump in.
-        if (routing.hasHumanMention)
-            return false;
+        // @all alone is an explicit broadcast, not an unmentioned message.
+        if (routing.isAllMention)
+            return true;
         if (chatId) {
+            if (!this.store.getChairmanBot(chatId))
+                return false;
             if (this.store.getBotMode(this.config.name, chatId) === "free")
                 return true;
             // Chairman fallback: if nobody is in free mode, the unique chairman
@@ -1734,12 +1727,46 @@ export class FeishuBot {
         }
         return false;
     }
-    getRoutingIntent(chatType, message, rawText) {
-        const mentions = message.mentions || [];
+    getRoutingIntent(chatType, message, rawText = "", content) {
+        const metadata = message.mentions || [];
+        const mentions = [...metadata];
+        const mentionTexts = [rawText];
+        if (message.message_type === "post") {
+            // Only structured post nodes carry mention semantics; do not interpret
+            // arbitrary JSON strings as identity or broaden attachment handling.
+            const posts = [content, ...Object.values(content || {})];
+            for (const post of posts) {
+                if (!Array.isArray(post?.content))
+                    continue;
+                if (typeof post.title === "string")
+                    mentionTexts.push(post.title);
+                for (const paragraph of post.content) {
+                    if (!Array.isArray(paragraph))
+                        continue;
+                    for (const node of paragraph) {
+                        if (node?.tag === "text" && typeof node.text === "string")
+                            mentionTexts.push(node.text);
+                        if (node?.tag !== "at")
+                            continue;
+                        // Rich-post user_id is matched only to an already probed open_id.
+                        mentions.push({ id: { open_id: node.user_id }, name: node.user_name });
+                    }
+                }
+            }
+        }
         const isAllMention = chatType !== "p2p" && this.isAllMention(rawText, mentions);
-        const targetedBotNames = this.mentionedBotNames(mentions);
+        // Structured nodes fill missing metadata, not override conflicting metadata.
+        const targetedBotNames = this.mentionedBotNames(metadata.length ? metadata : mentions);
+        // Missing metadata must not turn a platform placeholder or standalone @name
+        // into an unmentioned Free/Chairman trigger. This grants NO identity. Emails
+        // and embedded @ characters remain ordinary text, not commands or mentions.
+        const unresolvedTextMention = mentionTexts.some(text => {
+            const withoutAllPlaceholders = text.replace(/@_user_\d+/g, key => metadata.some(m => m.key === key && this.isAllMentionItem(m)) ? " " : key);
+            return /@_user_\d+/.test(withoutAllPlaceholders)
+                || /(^|\s)@(?!(?:_all|all|所有人)(?=\s|$))[^\s@]+/iu.test(withoutAllPlaceholders);
+        });
         const hasHumanMention = mentions.some((m) => !this.isAllMentionItem(m) && !this.mentionedBotName(m));
-        const hasTargetedMention = targetedBotNames.length > 0 || hasHumanMention;
+        const hasTargetedMention = targetedBotNames.length > 0 || hasHumanMention || unresolvedTextMention;
         return {
             isAllMention,
             targetedBotNames,
@@ -1757,44 +1784,32 @@ export class FeishuBot {
         return mentions.some((m) => this.isAllMentionItem(m));
     }
     isAllMentionItem(mention) {
-        return mention.key === "all" || mention.key === "@_all" || mention.id?.user_id === "all" || mention.id?.open_id === "all" || mention.name === "所有人";
+        const id = mention.id || {};
+        // A display name cannot override a concrete non-broadcast identity.
+        if (id.app_id || (id.open_id && id.open_id !== "all") || (id.user_id && id.user_id !== "all"))
+            return false;
+        return mention.key === "all" || mention.key === "@_all" || id.user_id === "all" || id.open_id === "all";
     }
     mentionedBotName(mention) {
         if (this.isAllMentionItem(mention))
             return null;
-        const candidates = [this, ...Array.from(FeishuBot.allBots.values()).filter((bot) => bot !== this)];
-        for (const bot of candidates) {
-            if (mention.id?.app_id && mention.id.app_id === bot.config.appId)
-                return bot.config.name;
-            if (bot.botOpenId && mention.id?.open_id && mention.id.open_id === bot.botOpenId)
-                return bot.config.name;
-        }
-        // Name is only a fallback because Feishu should normally provide app_id/open_id.
-        // Keep it exact to avoid shared-prefix bots like 万万（GPT） / 万万（Claude）
-        // stealing each other's mentions.
-        if (typeof mention.name === "string") {
-            const raw = mention.name.trim().replace(/^@+/, "").replace(/\s+/g, "").toLowerCase();
-            for (const bot of candidates) {
-                const botName = bot.config.name.trim().replace(/\s+/g, "").toLowerCase();
-                const exactNames = [
-                    botName,
-                    `万万（${botName}）`,
-                    `万万(${botName})`,
-                ];
-                if (exactNames.includes(raw))
-                    return bot.config.name;
-                // Generic display-name fallback: many deployments name bots like
-                // "光子 (Claude)" or "万万（GPT）". Match only when the parenthesized
-                // suffix is exactly the configured bot name, avoiding loose substring
-                // matches that caused shared-prefix bots to steal each other's mentions.
-                if (new RegExp(`^[^()（）]+[（(]${this.escapeRegExp(botName)}[）)]$`, "i").test(raw))
-                    return bot.config.name;
-            }
-        }
-        return null;
-    }
-    escapeRegExp(value) {
-        return value.replace(/[.*+?^${}()|[\]\\-]/g, "\\$&");
+        const id = mention.id || {};
+        const candidates = [this, ...Array.from(FeishuBot.allBots.values()).filter((bot) => bot !== this && bot.store === this.store)];
+        const matches = candidates.filter((bot) => {
+            // Known conflicting app/open credentials veto, regardless of order. An
+            // unprobed open_id cannot establish identity, but a matching app_id can.
+            if (id.app_id && id.app_id !== bot.config.appId)
+                return false;
+            if (id.open_id && bot.botOpenId && id.open_id !== bot.botOpenId)
+                return false;
+            if (id.open_id && candidates.some((other) => other !== bot && other.botOpenId === id.open_id))
+                return false;
+            return (id.app_id && id.app_id === bot.config.appId)
+                || (id.open_id && bot.botOpenId && id.open_id === bot.botOpenId);
+        });
+        // Names (including exact/parenthesized suffixes) and unverified user/union
+        // IDs never establish bot identity. Ambiguous matches fail closed.
+        return matches.length === 1 ? matches[0].config.name : null;
     }
     resolveBotName(sender) {
         const openId = sender?.sender_id?.open_id;
@@ -2531,48 +2546,17 @@ export class FeishuBot {
             .filter((name) => Boolean(name));
         return Array.from(new Set(names));
     }
-    mentionedBotNamesFromChairmanText(...texts) {
-        const normalizedTexts = texts
-            .filter(Boolean)
-            .map((text) => text.replace(/^\s*\/chairman\b/i, "").trim())
-            .filter(Boolean)
-            .map((text) => text.replace(/^@+/, "").replace(/\s+/g, "").toLowerCase());
-        if (normalizedTexts.length === 0)
-            return [];
-        const names = [];
-        const candidates = [this, ...Array.from(FeishuBot.allBots.values()).filter((bot) => bot !== this && bot.store === this.store)];
-        for (const raw of normalizedTexts) {
-            for (const bot of candidates) {
-                const botName = bot.config.name.trim().replace(/\s+/g, "").toLowerCase();
-                const displayNames = [
-                    botName,
-                    `@${botName}`,
-                    `万万（${botName}）`,
-                    `@万万（${botName}）`,
-                    `万万(${botName})`,
-                    `@万万(${botName})`,
-                ];
-                if (displayNames.includes(raw) || new RegExp(`^@?[^()（）]+[（(]${this.escapeRegExp(botName)}[）)]$`, "i").test(raw)) {
-                    names.push(bot.config.name);
-                }
-            }
-        }
-        return Array.from(new Set(names));
-    }
-    /**
-     * Resolve the target bot name(s) for a /chairman command using every signal
-     * available, in priority order:
-     *   1. Feishu mention metadata (app_id / open_id / name).
-     *   2. Text fallback: "@Bot" or "Bot" written in the message body.
-     *
-     * This keeps /chairman working even when a Feishu client or bridge omits
-     * mention metadata. Returns a de-duplicated, order-preserving list.
-     */
     resolveChairmanTargets(mentions, text, rawText = "") {
-        const fromMeta = this.mentionedBotNames(mentions);
-        if (fromMeta.length > 0)
-            return fromMeta;
-        return this.mentionedBotNamesFromChairmanText(text, rawText);
+        if (mentions.some((m) => !this.isAllMentionItem(m)))
+            return this.mentionedBotNames(mentions);
+        // Only a bare, exact configured name is a local management argument. Never
+        // reinterpret an unresolved @name/placeholder as authority to target a bot.
+        const argument = text.replace(/^\s*\/chairman\b/i, "").trim().toLowerCase();
+        if (/(^|\s)@(?!(?:_all|all|所有人)(?=\s|$))[^\s@]+/iu.test(rawText) || argument.includes("@"))
+            return [];
+        return [this, ...Array.from(FeishuBot.allBots.values()).filter((bot) => bot !== this && bot.store === this.store)]
+            .filter((bot) => bot.config.name.toLowerCase() === argument)
+            .map((bot) => bot.config.name);
     }
     isDiscussionCoordinator() {
         const bots = Array.from(FeishuBot.allBots.values()).filter((bot) => bot.store === this.store);
@@ -3480,7 +3464,7 @@ export class FeishuBot {
             active ? `运行中：第 ${active.currentRound}/${active.maxRounds} 轮，topic=${active.topic.slice(0, 80)}` : "运行中：无",
         ].join("\n"));
     }
-    async handleChairmanCommand(chatId, chatType, messageId, mentions, text, rawText = "") {
+    async handleChairmanCommand(chatId, chatType, messageId, mentions, text, rawText = "", routedTargets) {
         if (chatType === "p2p") {
             await this.replyMessage(messageId, "❌ Chairman 只在群聊中可用");
             return;
@@ -3490,10 +3474,12 @@ export class FeishuBot {
         if (["off", "clear", "none"].includes(action)) {
             const previous = this.store.getChairmanBot(chatId);
             this.store.clearChairmanBot(chatId);
-            await this.replyMessage(messageId, previous ? `✅ 已清除当前群 Chairman（原 ${previous}）` : "✅ 当前群没有 Chairman");
+            discussionManager.stop(chatId); // Stop future turns; never abort in-flight agents.
+            await this.replyMessage(messageId, (previous ? `✅ 已清除当前群 Chairman（原 ${previous}）` : "✅ 当前群没有 Chairman")
+                + "\nDiscuss 已关闭；无 @ 的普通新消息不再触发回复（含 Free）。这不是 mute，明确 @ 仍按原规则处理；已执行任务不被中止。");
             return;
         }
-        const resolvedBotNames = this.resolveChairmanTargets(mentions, text, rawText);
+        const resolvedBotNames = routedTargets ?? this.resolveChairmanTargets(mentions, text, rawText);
         if (resolvedBotNames.length === 0) {
             // /chairman is intentionally not a status query. Status lives in /status;
             // this command is only for switching or clearing the Chairman. Keeping the

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/message-store.js

@@ -891,7 +891,12 @@ export class MessageStore {
     `).run(chatId, botName, Date.now());
     }
     clearChairmanBot(chatId) {
-        this.setChairmanBot(chatId, '');
+        // Persist both fields atomically so reopening cannot revive Discuss after off.
+        this.db.prepare(`
+      INSERT INTO chat_info (chat_id, chat_type, chat_name, chairman_bot, discuss, updated_at)
+      VALUES (?, 'group', '', '', 0, ?)
+      ON CONFLICT (chat_id) DO UPDATE SET chairman_bot = '', discuss = 0, updated_at = excluded.updated_at
+    `).run(chatId, Date.now());
     }
     getChairmanBot(chatId) {
         const row = this.db.prepare(`SELECT chairman_bot FROM chat_info WHERE chat_id = ?`).get(chatId);

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.12",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {