openclaw-lark-multi-agent 1.4.11 → 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`
 

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` 语言
 

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) {
@@ -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/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/package.json

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