openclaw-lark-multi-agent 1.0.13 → 1.0.15

package/dist/config.d.ts

@@ -1,8 +1,10 @@
+import { type Locale } from "./i18n.js";
 export interface BotConfig {
     name: string;
     appId: string;
     appSecret: string;
     model: string;
+    locale?: Locale;
 }
 export interface OpenClawConfig {
     baseUrl: string;
@@ -13,5 +15,7 @@ export interface AppConfig {
     bots: BotConfig[];
     /** Optional Feishu/Lark open_id for model-drift notifications */
     adminOpenId?: string;
+    /** Default UI/prompt language. Bot-level locale overrides this. */
+    locale?: Locale;
 }
 export declare function loadConfig(path?: string): AppConfig;

package/dist/config.js

@@ -1,5 +1,6 @@
 import { readFileSync } from "fs";
 import { resolve } from "path";
+import { normalizeLocale } from "./i18n.js";
 export function loadConfig(path) {
     const configPath = path || resolve(process.cwd(), "config.json");
     const raw = readFileSync(configPath, "utf-8");
@@ -15,6 +16,10 @@ export function loadConfig(path) {
             throw new Error(`Bot "${bot.name}" missing appId, appSecret, or model`);
         }
     }
+    config.locale = normalizeLocale(config.locale);
+    for (const bot of config.bots) {
+        bot.locale = normalizeLocale(bot.locale || config.locale);
+    }
     // Validate uniqueness
     const names = config.bots.map((b) => b.name);
     const appIds = config.bots.map((b) => b.appId);

package/dist/discussion-manager.d.ts

@@ -1,15 +1,24 @@
+import { type Locale } from "./i18n.js";
 export type ReplyResult = {
     botName: string;
     text: string;
     visible: boolean;
     error?: string;
 };
+export type DiscussionCompleteReason = "chairman_final" | "all_no_reply" | "max_rounds";
+export type DiscussionCompleteEvent = {
+    chatId: string;
+    reason: DiscussionCompleteReason;
+    chairmanName?: string;
+};
 type DiscussionSession = {
     id: string;
     chatId: string;
     rootMessageId: string;
     topic: string;
     participants: string[];
+    chairmanName?: string;
+    locale: Locale;
     currentRound: number;
     maxRounds: number;
     completedRounds: Array<{
@@ -26,9 +35,11 @@ export type DiscussionParticipant = {
     }): Promise<ReplyResult>;
 };
 export declare class DiscussionManager {
+    private defaultLocale;
     private sessions;
     private seenRoots;
     private readonly seenRootTtlMs;
+    constructor(defaultLocale?: Locale);
     isActive(chatId: string): boolean;
     stop(chatId: string): boolean;
     status(chatId: string): DiscussionSession | null;
@@ -38,10 +49,15 @@ export declare class DiscussionManager {
         topic: string;
         maxRounds: number;
         participants: DiscussionParticipant[];
+        chairman?: DiscussionParticipant;
         sendSystemMessage?: (text: string) => Promise<void>;
+        onComplete?: (event: DiscussionCompleteEvent) => Promise<void>;
+        locale?: Locale;
     }): boolean;
     private pruneSeenRoots;
     private runLoop;
+    private hasFinalSummaryMarker;
+    private buildChairmanPrompt;
     private buildPrompt;
 }
 export declare const discussionManager: DiscussionManager;

package/dist/discussion-manager.js

@@ -1,8 +1,13 @@
 import { randomUUID } from "crypto";
+import { getI18n } from "./i18n.js";
 export class DiscussionManager {
+    defaultLocale;
     sessions = new Map();
     seenRoots = new Map();
     seenRootTtlMs = 6 * 60 * 60 * 1000;
+    constructor(defaultLocale = "zh") {
+        this.defaultLocale = defaultLocale;
+    }
     isActive(chatId) {
         return this.sessions.get(chatId)?.status === "running";
     }
@@ -26,8 +31,11 @@ export class DiscussionManager {
         this.seenRoots.set(key, Date.now());
         if (this.isActive(params.chatId))
             this.stop(params.chatId);
-        const participants = params.participants.filter((p, index, arr) => arr.findIndex((x) => x.name === p.name) === index);
-        if (participants.length === 0) {
+        const chairman = params.chairman;
+        const participants = params.participants
+            .filter((p) => p.name !== chairman?.name)
+            .filter((p, index, arr) => arr.findIndex((x) => x.name === p.name) === index);
+        if (participants.length === 0 && !chairman) {
             this.seenRoots.delete(key);
             return false;
         }
@@ -36,14 +44,16 @@ export class DiscussionManager {
             chatId: params.chatId,
             rootMessageId: params.rootMessageId,
             topic: params.topic,
-            participants: participants.map((p) => p.name),
+            participants: [...participants.map((p) => p.name), ...(chairman ? [chairman.name] : [])],
+            chairmanName: chairman?.name,
+            locale: params.locale || this.defaultLocale,
             currentRound: 1,
             maxRounds: params.maxRounds,
             completedRounds: [],
             status: "running",
         };
         this.sessions.set(params.chatId, session);
-        void this.runLoop(session.id, participants, params.sendSystemMessage).catch((err) => {
+        void this.runLoop(session.id, participants, chairman, params.sendSystemMessage, params.onComplete).catch((err) => {
             console.warn(`[Discussion] loop failed for ${params.chatId}:`, err instanceof Error ? err.message : String(err));
             const current = this.sessions.get(params.chatId);
             if (current?.id === session.id)
@@ -57,7 +67,7 @@ export class DiscussionManager {
                 this.seenRoots.delete(key);
         }
     }
-    async runLoop(sessionId, participants, sendSystemMessage) {
+    async runLoop(sessionId, participants, chairman, sendSystemMessage, onComplete) {
         while (true) {
             const session = Array.from(this.sessions.values()).find((s) => s.id === sessionId);
             if (!session || session.status !== "running")
@@ -101,62 +111,88 @@ export class DiscussionManager {
             const errorNames = participants
                 .map((participant) => participant.name)
                 .filter((name) => (replies[name] || "").trim().startsWith("[ERROR]"));
-            const allNoReply = participants.every((participant) => {
+            const allNoReply = participants.length > 0 && participants.every((participant) => {
                 const text = (replies[participant.name] || "").trim();
                 return !text || text.toUpperCase() === "NO_REPLY" || text.startsWith("[ERROR]");
             });
             if (sendSystemMessage && !allNoReply && (noReplyNames.length > 0 || errorNames.length > 0)) {
                 const parts = [];
+                const t = getI18n(current.locale).labels;
                 if (noReplyNames.length > 0)
-                    parts.push(`${noReplyNames.join("、")} 无新增回复`);
+                    parts.push(`${noReplyNames.join("、")} ${t.noNewReply}`);
                 if (errorNames.length > 0)
-                    parts.push(`${errorNames.join("、")} 出错`);
-                await sendSystemMessage(`💬 第 ${current.currentRound}/${current.maxRounds} 轮：${parts.join("；")}`).catch(() => { });
+                    parts.push(`${errorNames.join("、")} ${t.error}`);
+                await sendSystemMessage(t.discussionRoundNotice(current.currentRound, current.maxRounds, parts.join(current.locale === "zh" ? "；" : "; "))).catch(() => { });
+            }
+            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 });
+                const chairText = (chairResult.text || "").trim();
+                replies[chairman.name] = chairText;
+                const latest = current.completedRounds[current.completedRounds.length - 1];
+                if (latest)
+                    latest.replies[chairman.name] = chairText;
+                const wantsFinal = this.hasFinalSummaryMarker(chairText);
+                if (mustFinish || wantsFinal) {
+                    current.status = "completed";
+                    this.sessions.delete(current.chatId);
+                    if (onComplete)
+                        await onComplete({ chatId: current.chatId, reason: "chairman_final", chairmanName: chairman.name }).catch(() => { });
+                    else if (sendSystemMessage)
+                        await sendSystemMessage(getI18n(current.locale).labels.discussEndedChairman(chairman.name)).catch(() => { });
+                    return;
+                }
             }
-            if (allNoReply) {
+            else if (allNoReply) {
                 current.status = "completed";
                 this.sessions.delete(current.chatId);
+                if (onComplete)
+                    await onComplete({ chatId: current.chatId, reason: "all_no_reply" }).catch(() => { });
                 if (sendSystemMessage)
-                    await sendSystemMessage(`💬 Discuss 已结束：第 ${current.currentRound} 轮没有新的有效补充。`).catch(() => { });
+                    await sendSystemMessage(getI18n(current.locale).labels.discussEndedNoNew(current.currentRound)).catch(() => { });
                 return;
             }
-            if (current.currentRound >= current.maxRounds) {
+            else if (current.currentRound >= current.maxRounds) {
                 current.status = "completed";
                 this.sessions.delete(current.chatId);
+                if (onComplete)
+                    await onComplete({ chatId: current.chatId, reason: "max_rounds" }).catch(() => { });
                 if (sendSystemMessage)
-                    await sendSystemMessage(`💬 Discuss 已完成：已达到 ${current.maxRounds} 轮。`).catch(() => { });
+                    await sendSystemMessage(getI18n(current.locale).labels.discussMaxRounds(current.maxRounds)).catch(() => { });
                 return;
             }
             current.currentRound += 1;
         }
     }
+    hasFinalSummaryMarker(text) {
+        return /(^|\n)\s*FINAL_SUMMARY\s*[:：]/i.test(text) || /(^|\n)\s*最终总结\s*[:：]/.test(text);
+    }
+    buildChairmanPrompt(session, replies, mustFinish) {
+        const t = getI18n(session.locale);
+        const lines = Object.entries(replies).map(([bot, text]) => `- ${bot}: ${text || "NO_REPLY"}`);
+        return t.chairmanPrompt({
+            topic: session.topic,
+            round: session.currentRound,
+            maxRounds: session.maxRounds,
+            replies: lines.length ? lines.join("\n") : t.labels.noRegularReplies,
+            mustFinish,
+        });
+    }
     buildPrompt(session) {
+        const t = getI18n(session.locale);
         const previous = session.completedRounds.length === 0
-            ? "（暂无，当前是第一轮）"
+            ? t.labels.noPreviousRounds
             : (() => {
                 const round = session.completedRounds[session.completedRounds.length - 1];
                 const lines = Object.entries(round.replies).map(([bot, text]) => `- ${bot}: ${text || "NO_REPLY"}`);
                 return `Round ${round.round}:\n${lines.join("\n")}`;
             })();
-        return [
-            "这是一个多智能体结构化讨论。",
-            "",
-            "话题：",
-            session.topic,
-            "",
-            `当前轮次：${session.currentRound}`,
-            "",
-            "已完成的轮次：",
+        return t.discussParticipantPrompt({
+            topic: session.topic,
+            round: session.currentRound,
             previous,
-            "",
-            "本轮其他 bot 的回复你暂时看不到，请基于同一份上下文独立给出观点。",
-            "",
-            "要求：",
-            "1. 不要重复前几轮已经说过的观点。",
-            "2. 只补充新的、有价值的信息。",
-            "3. 如果没有新东西，回复 NO_REPLY。",
-            "4. 简洁作答。",
-        ].join("\n");
+        });
     }
 }
 export const discussionManager = new DiscussionManager();

package/dist/feishu-bot.d.ts

@@ -36,6 +36,7 @@ export declare class FeishuBot {
     /** Active chatSend trigger target so final replies and proactive session.message share one delivery key. */
     private activeDeliveryTargets;
     private adminOpenId;
+    private locale;
     private static allBots;
     constructor(config: BotConfig, openclawClient: OpenClawClient, store: MessageStore, adminOpenId?: string);
     private handleMessageRecalled;
@@ -45,6 +46,8 @@ export declare class FeishuBot {
      * Format: lma-<botname>-<chatId>
      */
     getSessionKey(chatId: string): string;
+    private chatLocale;
+    private isEn;
     private lmaBridgePolicy;
     private injectBridgePolicy;
     /**
@@ -76,6 +79,7 @@ export declare class FeishuBot {
     private processQueueInner;
     private shouldHandleBridgeCommand;
     private shouldRespond;
+    private getRoutingIntent;
     private isMentioned;
     private isAllMention;
     private isAllMentionItem;
@@ -95,8 +99,12 @@ export declare class FeishuBot {
     private deliverySourceId;
     private enqueueAndDispatchDelivery;
     private dispatchPendingDeliveries;
+    private hasFreeModeBot;
+    private mentionedBotNames;
     private isDiscussionCoordinator;
     private getDiscussionParticipants;
+    private getChairmanParticipant;
+    private asDiscussionParticipant;
     private runDiscussionTurn;
     private replyMessage;
     private extractBridgeAttachments;
@@ -127,7 +135,9 @@ export declare class FeishuBot {
      * Finds the bot's own reaction of that type and deletes it.
      */
     private removeReaction;
+    private handleLocaleCommand;
     private handleDiscussCommand;
+    private handleChairmanCommand;
     /**
      * Handle /status command: show current session info.
      */

package/dist/feishu-bot.js

@@ -1,5 +1,6 @@
 import * as lark from "@larksuiteoapi/node-sdk";
 import { createRequire } from "module";
+import { getI18n, normalizeLocale } from "./i18n.js";
 import { existsSync, readFileSync, statSync } from "fs";
 import { basename, extname, resolve } from "path";
 import { getBridgeAttachmentsDir } from "./paths.js";
@@ -44,12 +45,14 @@ export class FeishuBot {
     /** Active chatSend trigger target so final replies and proactive session.message share one delivery key. */
     activeDeliveryTargets = new Map();
     adminOpenId;
+    locale;
     static allBots = new Map();
     constructor(config, openclawClient, store, adminOpenId) {
         this.config = config;
         this.openclawClient = openclawClient;
         this.store = store;
         this.adminOpenId = adminOpenId || null;
+        this.locale = normalizeLocale(config.locale);
         // Session keys are now per-chat: lma-<botname>-<chatId>
         this.client = new lark.Client({
             appId: config.appId,
@@ -100,13 +103,14 @@ export class FeishuBot {
     getSessionKey(chatId) {
         return `lma-${this.config.name.toLowerCase()}-${chatId}`;
     }
+    chatLocale(chatId) {
+        return normalizeLocale(chatId ? this.store.getChatLocale(chatId) || this.locale : this.locale);
+    }
+    isEn(chatId) {
+        return this.chatLocale(chatId) === "en";
+    }
     lmaBridgePolicy() {
-        return [
-            "[LMA bridge policy]",
-            "你正在 OpenClaw Lark Multi-Agent bridge 会话中。",
-            "不要调用 message、sessions_send、feishu_im_user_message 或任何主动向飞书/外部聊天发送消息的工具。",
-            "直接在当前回复中作答；LMA bridge 会负责把最终回复投递回原始飞书群。",
-        ].join("\n");
+        return getI18n(this.locale).bridgePolicy;
     }
     async injectBridgePolicy(sessionKey) {
         await this.openclawClient.injectAssistantMessage({
@@ -384,6 +388,7 @@ export class FeishuBot {
             }
             if (!cleanText.trim())
                 return;
+            const routing = this.getRoutingIntent(chatType, message, messageType === "text" ? (content.text || "") : "");
             // 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.
@@ -415,15 +420,34 @@ export class FeishuBot {
             // Single slash commands are handled by the bridge. Double slash commands were
             // already unescaped above and should pass through to OpenClaw instead.
             const isBridgeCommand = !commandText.startsWith("//");
-            const isCommand = isBridgeCommand && /^\/(help|status|compact|reset|verbose|free|mute|mode|discuss)/.test(cleanText.trim());
+            const isCommand = isBridgeCommand && /^\/(help|status|compact|reset|verbose|free|mute|mode|discuss|chairman|locale)/.test(cleanText.trim());
             if (isCommand) {
                 // In group chats, most bridge commands must be explicitly routed to this
                 // bot or @all. /discuss is a group-level command, so an unmentioned
                 // /discuss command is handled by one coordinator bot to avoid N replies.
                 const isDiscussCommand = cleanText.trim().startsWith("/discuss");
-                if (chatType !== "p2p" && !this.shouldHandleBridgeCommand(chatType, message, isBot, message.content)) {
-                    if (!(isDiscussCommand && this.isDiscussionCoordinator()))
+                const isChairmanCommand = cleanText.trim().startsWith("/chairman");
+                const isLocaleCommand = cleanText.trim().startsWith("/locale");
+                if (chatType !== "p2p") {
+                    if (isChairmanCommand || isLocaleCommand) {
+                        // Group-level settings; one coordinator handles them.
+                        if (!this.isDiscussionCoordinator())
+                            return;
+                    }
+                    else if (isDiscussCommand && !routing.hasTargetedMention) {
+                        // Untargeted or @all /discuss is group-level; one coordinator handles it.
+                        if (!this.isDiscussionCoordinator())
+                            return;
+                    }
+                    else if (routing.hasTargetedMention) {
+                        // Explicitly targeted commands belong only to the mentioned bot.
+                        if (!routing.isCurrentBotMentioned)
+                            return;
+                    }
+                    else if (!routing.isAllMention) {
+                        // Other bridge commands in a group need an explicit target or @all.
                         return;
+                    }
                 }
                 const markCommandSynced = () => {
                     if (insertedId > 0) {
@@ -443,10 +467,12 @@ export class FeishuBot {
                         `🧹 /compact — 压缩当前 bot 的 OpenClaw session`,
                         `🔄 /reset   — 重置当前 bot 的 OpenClaw session`,
                         `🔊 /verbose — 开关当前聊天里的 Tool Call 显示`,
-                        `🔓 /free   — 切换当前 bot 的 free 模式（不 @ 也可回复）`,
+                        `🔓 /free [on|off] — 开关当前 bot 的 free 模式（不 @ 也可回复）`,
                         `🤐 /mute   — 切换当前 bot 的 mute 模式（禁言，不转发 OpenClaw）`,
                         `🎛️ /mode   — 查看当前 bot 在当前群聊的模式`,
                         `💬 /discuss on|off|status|stop|rounds N — 群级多 bot 连续讨论`,
+                        `👑 /chairman @Bot|off — 设置/查看/清除本群唯一 Chairman`,
+                        `🌐 /locale zh|en — 设置/查看当前群语言`,
                         `❓ /help    — 显示此帮助信息`,
                         ``,
                         `OpenClaw 原生命令（双斜杠，会转成单斜杠发给 OpenClaw）`,
@@ -509,14 +535,24 @@ export class FeishuBot {
                         markCommandSynced();
                         return;
                     }
+                    const parts = cleanText.trim().split(/\s+/).filter(Boolean);
+                    const arg = (parts[1] || "toggle").toLowerCase();
+                    if (!["toggle", "on", "off"].includes(arg)) {
+                        await this.replyMessage(messageId, "❌ 用法：/free [on|off]");
+                        markCommandSynced();
+                        return;
+                    }
                     const current = this.store.getBotMode(this.config.name, chatId);
-                    const next = current === "free" ? "normal" : "free";
+                    const next = arg === "on" ? "free" : arg === "off" ? "normal" : current === "free" ? "normal" : "free";
                     this.store.setBotMode(this.config.name, chatId, next);
                     if (next === "free") {
-                        await this.replyMessage(messageId, `🔓 ${this.config.name} 已切换到 free 模式\n不需要 @ 也可以回复普通人类消息；如果消息明确 @ 了其他 bot 或普通人，我不会抢答。\n如需多轮自动讨论，请使用群级命令 /discuss on。`);
+                        await this.replyMessage(messageId, `🔓 ${this.config.name} 已切换到 free 模式
+不需要 @ 也可以回复普通人类消息；如果消息明确 @ 了其他 bot 或普通人，我不会抢答。
+如需多轮自动讨论，请使用群级命令 /discuss on。`);
                     }
                     else {
-                        await this.replyMessage(messageId, `🔒 ${this.config.name} 已切换到 normal 模式\n只有明确 @ 我才会回复`);
+                        await this.replyMessage(messageId, `🔒 ${this.config.name} 已切换到 normal 模式
+只有明确 @ 我才会回复`);
                     }
                     markCommandSynced();
                     return;
@@ -556,26 +592,53 @@ export class FeishuBot {
                     markCommandSynced();
                     return;
                 }
+                if (cleanText.trim().startsWith("/chairman")) {
+                    await this.handleChairmanCommand(chatId, chatType, messageId, message.mentions || [], cleanText.trim());
+                    markCommandSynced();
+                    return;
+                }
+                if (cleanText.trim().startsWith("/locale")) {
+                    await this.handleLocaleCommand(chatId, chatType, messageId, cleanText.trim());
+                    markCommandSynced();
+                    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) {
-                const mentions = message.mentions || [];
-                const hasTargetedMention = mentions.some((m) => !this.isAllMentionItem(m));
-                if (!hasTargetedMention) {
+                // Discuss mode owns ordinary and @all human messages. Explicit @bot/@human
+                // falls through to normal targeted routing.
+                if (!routing.hasTargetedMention) {
+                    const discussionLocale = this.chatLocale(chatId);
+                    const chairman = this.getChairmanParticipant(chatId);
                     const participants = this.getDiscussionParticipants(chatId);
-                    if (participants.length > 0) {
+                    if (participants.length > 0 || chairman) {
                         discussionManager.startIfAbsent({
                             chatId,
                             rootMessageId: messageId,
                             topic: cleanText,
-                            maxRounds: this.store.getChatInfo(chatId)?.discussMaxRounds || 3,
+                            maxRounds: this.store.getChatInfo(chatId)?.discussMaxRounds || 10,
                             participants,
+                            chairman,
                             sendSystemMessage: async (text) => { await this.sendMessage(chatId, text); },
+                            locale: discussionLocale,
+                            onComplete: async (event) => {
+                                if (event.reason === "chairman_final") {
+                                    this.store.setDiscussMode(event.chatId, false);
+                                    await this.sendMessage(event.chatId, this.isEn(event.chatId)
+                                        ? `💬 Discuss ended: Chairman ${event.chairmanName || ""} completed the final summary. Discuss mode has been turned off automatically.`
+                                        : `💬 Discuss 已结束：Chairman ${event.chairmanName || ""} 已完成总结，已自动关闭 Discuss 模式。`);
+                                }
+                            },
                         });
                     }
+                    else if (this.isDiscussionCoordinator()) {
+                        await this.sendMessage(chatId, this.isEn(chatId)
+                            ? "💬 Discuss is on, but there are no free bots or Chairman available. Use /free on or /chairman @Bot first."
+                            : "💬 Discuss 已开启，但当前没有 free bot 或 Chairman 可参与。请先使用 /free on 或 /chairman @Bot。");
+                    }
                     if (insertedId > 0)
                         this.store.markSynced(this.config.name, chatId, insertedId);
                     return;
@@ -583,7 +646,7 @@ export class FeishuBot {
             }
             // --- Mute mode: do not forward anything to OpenClaw. Only direct mentions get a local notice. ---
             if (chatType !== "p2p" && !isBot && this.store.getBotMode(this.config.name, chatId) === "mute") {
-                if (this.isMentioned(message.mentions || [])) {
+                if (routing.isCurrentBotMentioned) {
                     await this.replyMessage(messageId, `🤐 ${this.config.name} 当前处于 mute 模式，发送 /mute 可解除`);
                     if (insertedId > 0) {
                         this.store.markSynced(this.config.name, chatId, insertedId);
@@ -593,7 +656,7 @@ export class FeishuBot {
                 return;
             }
             // --- Should this bot respond? ---
-            if (!this.shouldRespond(chatType, message, isBot, chatId, message.content))
+            if (!this.shouldRespond(chatType, message, isBot, chatId, routing))
                 return;
             if (!isBot && insertedId > 0) {
                 this.store.markPendingTrigger(this.config.name, chatId, insertedId);
@@ -861,34 +924,47 @@ export class FeishuBot {
             return true;
         return this.isMentioned(mentions);
     }
-    shouldRespond(chatType, message, isBot, chatId, rawText) {
+    shouldRespond(chatType, _message, isBot, chatId, routing) {
         if (chatType === "p2p")
             return !isBot;
-        const mentions = message.mentions || [];
-        // Bot messages: only respond if this bot is mentioned
-        if (isBot) {
-            return this.isMentioned(mentions);
-        }
-        // @all in text: all bots respond
-        if (this.isAllMention(rawText, mentions))
-            return true;
-        // Check if this bot is explicitly mentioned
-        if (this.isMentioned(mentions))
+        // 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;
-        // Targeted mentions are exclusive. If a human mentions another person or
-        // another bot, free-mode bots must not steal that message. Free mode only
-        // applies to plain human messages with no targeted mentions.
-        const hasTargetedMention = mentions.some((m) => !this.isAllMentionItem(m));
-        if (hasTargetedMention)
+        // 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;
-        // No bot mentioned: check current per-bot mode
         if (chatId) {
             if (this.store.getBotMode(this.config.name, chatId) === "free")
                 return true;
+            // Chairman fallback: if nobody is in free mode, the unique chairman
+            // answers ordinary unmentioned messages for the group.
+            const chairman = this.store.getChairmanBot(chatId);
+            if (chairman === this.config.name && !this.hasFreeModeBot(chatId))
+                return true;
         }
-        // Default: don't respond without @
         return false;
     }
+    getRoutingIntent(chatType, message, rawText) {
+        const mentions = message.mentions || [];
+        const isAllMention = chatType !== "p2p" && this.isAllMention(rawText, mentions);
+        const targetedBotNames = this.mentionedBotNames(mentions);
+        const hasHumanMention = mentions.some((m) => !this.isAllMentionItem(m) && !this.mentionedBotName(m));
+        const hasTargetedMention = targetedBotNames.length > 0 || hasHumanMention;
+        return {
+            isAllMention,
+            targetedBotNames,
+            hasTargetedMention,
+            hasHumanMention,
+            isCurrentBotMentioned: targetedBotNames.includes(this.config.name),
+        };
+    }
     isMentioned(mentions) {
         return mentions.some((m) => this.mentionedBotName(m) === this.config.name);
     }
@@ -905,14 +981,24 @@ export class FeishuBot {
             return null;
         const candidates = [this, ...Array.from(FeishuBot.allBots.values()).filter((bot) => bot !== this)];
         for (const bot of candidates) {
-            if (mention.id?.app_id === bot.config.appId)
+            if (mention.id?.app_id && mention.id.app_id === bot.config.appId)
                 return bot.config.name;
-            if (bot.botOpenId && mention.id?.open_id === bot.botOpenId)
+            if (bot.botOpenId && mention.id?.open_id && mention.id.open_id === bot.botOpenId)
                 return bot.config.name;
-            if (typeof mention.name === "string") {
-                const n = mention.name.toLowerCase();
-                const botName = bot.config.name.toLowerCase();
-                if (n === botName || n.includes(`（${botName}）`) || n.includes(`(${botName})`))
+        }
+        // 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;
             }
         }
@@ -1112,6 +1198,16 @@ export class FeishuBot {
             });
         }
     }
+    hasFreeModeBot(chatId) {
+        return Array.from(FeishuBot.allBots.values())
+            .some((bot) => bot.store === this.store && bot.store.getBotMode(bot.config.name, chatId) === "free");
+    }
+    mentionedBotNames(mentions) {
+        const names = mentions
+            .map((mention) => this.mentionedBotName(mention))
+            .filter((name) => Boolean(name));
+        return Array.from(new Set(names));
+    }
     isDiscussionCoordinator() {
         const bots = Array.from(FeishuBot.allBots.values()).filter((bot) => bot.store === this.store);
         if (bots.length === 0)
@@ -1119,12 +1215,23 @@ export class FeishuBot {
         return bots[0] === this;
     }
     getDiscussionParticipants(chatId) {
+        const chairman = this.store.getChairmanBot(chatId);
         return Array.from(FeishuBot.allBots.values())
-            .filter((bot) => bot.store === this.store && bot.store.getBotMode(bot.config.name, chatId) === "free")
-            .map((bot) => ({
+            .filter((bot) => bot.store === this.store && bot.config.name !== chairman && bot.store.getBotMode(bot.config.name, chatId) === "free")
+            .map((bot) => this.asDiscussionParticipant(bot, chatId));
+    }
+    getChairmanParticipant(chatId) {
+        const chairman = this.store.getChairmanBot(chatId);
+        if (!chairman)
+            return undefined;
+        const bot = Array.from(FeishuBot.allBots.values()).find((candidate) => candidate.store === this.store && candidate.config.name === chairman);
+        return bot ? this.asDiscussionParticipant(bot, chatId) : undefined;
+    }
+    asDiscussionParticipant(bot, chatId) {
+        return {
             name: bot.config.name,
             runDiscussionTurn: async (_chatId, prompt, meta) => bot.runDiscussionTurn(chatId, prompt, meta),
-        }));
+        };
     }
     async runDiscussionTurn(chatId, prompt, meta) {
         const sessionKey = await this.ensureSession(chatId);
@@ -1151,8 +1258,12 @@ export class FeishuBot {
         const rawVisibleReply = parsedReply.text.trim();
         const discussionMarkerPattern = /\n*—— 第 \d+\/\d+ 轮 · .+$/;
         const cleanVisibleReply = rawVisibleReply.replace(discussionMarkerPattern, "").trim();
-        let displayReply = cleanVisibleReply;
-        const isVisible = cleanVisibleReply.length > 0 && cleanVisibleReply.toUpperCase() !== "NO_REPLY";
+        const userVisibleReply = cleanVisibleReply
+            .replace(/(^|\n)\s*(FINAL_SUMMARY|CHAIRMAN_NOTE)\s*[:：]\s*/gi, "$1")
+            .replace(/(^|\n)\s*最终总结\s*[:：]\s*/g, "$1")
+            .trim();
+        let displayReply = userVisibleReply;
+        const isVisible = userVisibleReply.length > 0 && userVisibleReply.toUpperCase() !== "NO_REPLY";
         if (isVisible && meta) {
             const roundMarker = `—— 第 ${meta.round}/${meta.maxRounds} 轮 · ${this.config.name}`;
             displayReply = `${displayReply}\n\n${roundMarker}`;
@@ -1448,49 +1559,125 @@ export class FeishuBot {
             // ignore
         }
     }
+    async handleLocaleCommand(chatId, chatType, messageId, text) {
+        if (chatType === "p2p") {
+            await this.replyMessage(messageId, "Locale is only configurable in group chats.");
+            return;
+        }
+        const parts = text.split(/\s+/).filter(Boolean);
+        const value = (parts[1] || "").toLowerCase();
+        if (!value) {
+            const locale = this.chatLocale(chatId);
+            await this.replyMessage(messageId, locale === "en" ? "🌐 Current locale: en" : "🌐 当前语言：zh");
+            return;
+        }
+        if (value !== "zh" && value !== "en") {
+            await this.replyMessage(messageId, "Usage: /locale zh|en");
+            return;
+        }
+        this.store.setChatLocale(chatId, value);
+        await this.replyMessage(messageId, value === "en" ? "🌐 Locale set to en" : "🌐 语言已设置为 zh");
+    }
     async handleDiscussCommand(chatId, chatType, messageId, text) {
         if (chatType === "p2p") {
-            await this.replyMessage(messageId, "❌ Discuss 模式只在群聊中可用");
+            await this.replyMessage(messageId, "Discuss mode is only available in group chats.");
             return;
         }
         const parts = text.split(/\s+/).filter(Boolean);
         const action = parts[1] || "status";
         if (action === "on") {
+            const chairman = this.store.getChairmanBot(chatId);
+            if (!chairman) {
+                await this.replyMessage(messageId, this.isEn(chatId)
+                    ? "❌ You must set a Chairman before enabling Discuss.\nUsage: /chairman @Bot"
+                    : "❌ 开启 Discuss 前必须先设置 Chairman。\n用法：/chairman @某个Bot");
+                return;
+            }
             this.store.setDiscussMode(chatId, true);
-            await this.replyMessage(messageId, `💬 Discuss 已开启\n参与者：当前群所有 free 模式 bot\n轮数：${this.store.getChatInfo(chatId)?.discussMaxRounds || 3}`);
+            await this.replyMessage(messageId, this.isEn(chatId)
+                ? `💬 Discuss enabled\nChairman: ${chairman}\nParticipants: all free-mode bots in this group + Chairman\nRounds: ${this.store.getChatInfo(chatId)?.discussMaxRounds || 10}`
+                : `💬 Discuss 已开启\nChairman：${chairman}\n参与者：当前群所有 free 模式 bot + Chairman\n轮数：${this.store.getChatInfo(chatId)?.discussMaxRounds || 10}`);
             return;
         }
         if (action === "off") {
             this.store.setDiscussMode(chatId, false);
             discussionManager.stop(chatId);
-            await this.replyMessage(messageId, "💬 Discuss 已关闭");
+            await this.replyMessage(messageId, this.isEn(chatId) ? "💬 Discuss disabled" : "💬 Discuss 已关闭");
             return;
         }
         if (action === "stop") {
             const stopped = discussionManager.stop(chatId);
-            await this.replyMessage(messageId, stopped ? "💬 当前 discuss 已停止" : "💬 当前没有运行中的 discuss");
+            await this.replyMessage(messageId, this.isEn(chatId)
+                ? (stopped ? "💬 Current discuss stopped" : "💬 No active discuss")
+                : (stopped ? "💬 当前 discuss 已停止" : "💬 当前没有运行中的 discuss"));
             return;
         }
         if (action === "rounds") {
             const n = Number.parseInt(parts[2] || "", 10);
             if (!Number.isFinite(n)) {
-                await this.replyMessage(messageId, "❌ 用法：/discuss rounds <1-10>");
+                await this.replyMessage(messageId, "❌ Usage: /discuss rounds <1-10>");
                 return;
             }
             this.store.setDiscussMaxRounds(chatId, n);
-            await this.replyMessage(messageId, `💬 Discuss 轮数已设置为 ${this.store.getChatInfo(chatId)?.discussMaxRounds || n}`);
+            await this.replyMessage(messageId, this.isEn(chatId)
+                ? `💬 Discuss rounds set to ${this.store.getChatInfo(chatId)?.discussMaxRounds || n}`
+                : `💬 Discuss 轮数已设置为 ${this.store.getChatInfo(chatId)?.discussMaxRounds || n}`);
             return;
         }
         const info = this.store.getChatInfo(chatId);
         const active = discussionManager.status(chatId);
         const participants = this.getDiscussionParticipants(chatId).map((p) => p.name);
-        await this.replyMessage(messageId, [
+        await this.replyMessage(messageId, this.isEn(chatId) ? [
             `💬 Discuss: ${info?.discuss ? "on" : "off"}`,
-            `轮数：${info?.discussMaxRounds || 3}`,
-            `参与者：${participants.length ? participants.join(", ") : "（无 free bot）"}`,
+            `Rounds: ${info?.discussMaxRounds || 10}`,
+            `Chairman: ${info?.chairmanBot || "not set"}`,
+            `Participants: ${participants.length ? participants.join(", ") : "(no free bot / chairman)"}`,
+            active ? `Active: round ${active.currentRound}/${active.maxRounds}, topic=${active.topic.slice(0, 80)}` : "Active: none",
+        ].join("\n") : [
+            `💬 Discuss: ${info?.discuss ? "on" : "off"}`,
+            `轮数：${info?.discussMaxRounds || 10}`,
+            `Chairman：${info?.chairmanBot || "未设置"}`,
+            `参与者：${participants.length ? participants.join(", ") : "（无 free bot / chairman）"}`,
             active ? `运行中：第 ${active.currentRound}/${active.maxRounds} 轮，topic=${active.topic.slice(0, 80)}` : "运行中：无",
         ].join("\n"));
     }
+    async handleChairmanCommand(chatId, chatType, messageId, mentions, text) {
+        if (chatType === "p2p") {
+            await this.replyMessage(messageId, "❌ Chairman 只在群聊中可用");
+            return;
+        }
+        const parts = text.split(/\s+/).filter(Boolean);
+        const action = (parts[1] || "status").toLowerCase();
+        if (["off", "clear", "none"].includes(action)) {
+            const previous = this.store.getChairmanBot(chatId);
+            this.store.clearChairmanBot(chatId);
+            await this.replyMessage(messageId, previous ? `✅ 已清除当前群 Chairman（原 ${previous}）` : "✅ 当前群没有 Chairman");
+            return;
+        }
+        const botNames = this.mentionedBotNames(mentions);
+        if (botNames.length === 0) {
+            const current = this.store.getChairmanBot(chatId);
+            await this.replyMessage(messageId, current
+                ? `👑 当前 Chairman：${current}\n作用：普通消息无人 free 时由 TA 回答；Discuss 模式下负责主持、调停和最终总结。`
+                : "👑 当前没有 Chairman\n用法：/chairman @某个Bot");
+            return;
+        }
+        if (botNames.length > 1) {
+            await this.replyMessage(messageId, "❌ 一个群只能设置一个 Chairman。请只 @ 一个 bot。");
+            return;
+        }
+        const next = botNames[0];
+        const previous = this.store.getChairmanBot(chatId);
+        this.store.setChairmanBot(chatId, next);
+        const mode = this.store.getBotMode(next, chatId);
+        const lines = [previous && previous !== next ? `✅ Chairman 已从 ${previous} 切换为 ${next}` : `✅ Chairman 已设置为 ${next}`];
+        lines.push("作用：");
+        lines.push("- 当没有 free bot 且普通消息无人被 @ 时，Chairman 会负责回答");
+        lines.push("- Discuss 模式下，Chairman 会参与主持、调停并做最终总结");
+        if (mode === "mute")
+            lines.push(`⚠️ ${next} 当前是 mute，但 Chairman 场景下仍会发言`);
+        await this.replyMessage(messageId, lines.join("\n"));
+    }
     /**
      * Handle /status command: show current session info.
      */
@@ -1520,6 +1707,13 @@ export class FeishuBot {
         const status = session?.status || "unknown";
         const verboseStatus = this.store.getBotVerbose(this.config.name, chatId) ? "🔊 开启" : "🔇 关闭";
         const mode = chatType === "p2p" ? "normal" : this.store.getBotMode(this.config.name, chatId);
+        const chairman = chatType === "p2p" ? "" : this.store.getChairmanBot(chatId);
+        const chairmanStatus = chatType === "p2p"
+            ? "不适用"
+            : chairman
+                ? chairman === this.config.name ? `👑 是（${chairman}）` : `否（当前：${chairman}）`
+                : "未设置";
+        const localeStatus = chatType === "p2p" ? this.locale : this.chatLocale(chatId);
         const statusText = [
             `📊 ${this.config.name} Bot Status`,
             `━━━━━━━━━━━━━━━━━━`,
@@ -1534,6 +1728,8 @@ export class FeishuBot {
             `📥 输入: ${fmtK(inputTokens)} | 📤 输出: ${fmtK(outputTokens)}`,
             `🔧 Verbose: ${verboseStatus}`,
             `🎛️ Mode: ${mode}`,
+            `👑 Chairman: ${chairmanStatus}`,
+            `🌐 Locale: ${localeStatus}`,
         ].join("\n");
         await this.replyMessage(messageId, statusText);
     }
@@ -1593,7 +1789,7 @@ export class FeishuBot {
                     freeDiscussion: this.store.getChatInfo(chatId)?.freeDiscussion || false,
                     verbose: this.store.getChatInfo(chatId)?.verbose || false,
                     discuss: this.store.getChatInfo(chatId)?.discuss || false,
-                    discussMaxRounds: this.store.getChatInfo(chatId)?.discussMaxRounds || 3,
+                    discussMaxRounds: this.store.getChatInfo(chatId)?.discussMaxRounds || 10,
                     updatedAt: Date.now(),
                 });
                 return;
@@ -1632,7 +1828,7 @@ export class FeishuBot {
                 freeDiscussion: this.store.getChatInfo(chatId)?.freeDiscussion || false,
                 verbose: this.store.getChatInfo(chatId)?.verbose || false,
                 discuss: this.store.getChatInfo(chatId)?.discuss || false,
-                discussMaxRounds: this.store.getChatInfo(chatId)?.discussMaxRounds || 3,
+                discussMaxRounds: this.store.getChatInfo(chatId)?.discussMaxRounds || 10,
                 updatedAt: Date.now(),
             });
             console.log(`[${this.config.name}] Cached chat info: ${chatName} (${chatId.slice(-8)})`);

package/dist/i18n.d.ts

@@ -0,0 +1,60 @@
+export type Locale = "zh" | "en";
+export declare function normalizeLocale(value?: string | null): Locale;
+export declare function isLocale(value: string): value is Locale;
+declare const dict: {
+    readonly zh: {
+        readonly bridgePolicy: string;
+        readonly discussParticipantPrompt: (p: {
+            topic: string;
+            round: number;
+            previous: string;
+        }) => string;
+        readonly chairmanPrompt: (p: {
+            topic: string;
+            round: number;
+            maxRounds: number;
+            replies: string;
+            mustFinish: boolean;
+        }) => string;
+        readonly labels: {
+            readonly noPreviousRounds: "（暂无，当前是第一轮）";
+            readonly noRegularReplies: "（本轮没有普通参与者发言）";
+            readonly noNewReply: "无新增回复";
+            readonly error: "出错";
+            readonly discussionRoundNotice: (round: number, max: number, parts: string) => string;
+            readonly round: "轮";
+            readonly discussEndedChairman: (name: string) => string;
+            readonly discussEndedNoNew: (round: number) => string;
+            readonly discussMaxRounds: (max: number) => string;
+        };
+    };
+    readonly en: {
+        readonly bridgePolicy: string;
+        readonly discussParticipantPrompt: (p: {
+            topic: string;
+            round: number;
+            previous: string;
+        }) => string;
+        readonly chairmanPrompt: (p: {
+            topic: string;
+            round: number;
+            maxRounds: number;
+            replies: string;
+            mustFinish: boolean;
+        }) => string;
+        readonly labels: {
+            readonly noPreviousRounds: "(None yet; this is the first round)";
+            readonly noRegularReplies: "(No regular participant replies in this round)";
+            readonly noNewReply: "no new reply";
+            readonly error: "error";
+            readonly discussionRoundNotice: (round: number, max: number, parts: string) => string;
+            readonly round: "round";
+            readonly discussEndedChairman: (name: string) => string;
+            readonly discussEndedNoNew: (round: number) => string;
+            readonly discussMaxRounds: (max: number) => string;
+        };
+    };
+};
+export type I18n = typeof dict[Locale];
+export declare function getI18n(locale?: string | null): I18n;
+export {};

package/dist/i18n.js

@@ -0,0 +1,140 @@
+export function normalizeLocale(value) {
+    const normalized = (value || "").trim().toLowerCase();
+    if (normalized.startsWith("en"))
+        return "en";
+    return "zh";
+}
+export function isLocale(value) {
+    return value === "zh" || value === "en";
+}
+const dict = {
+    zh: {
+        bridgePolicy: [
+            "[LMA bridge policy]",
+            "你正在 OpenClaw Lark Multi-Agent bridge 会话中。",
+            "不要调用 message、sessions_send、feishu_im_user_message 或任何主动向飞书/外部聊天发送消息的工具。",
+            "直接在当前回复中作答；LMA bridge 会负责把最终回复投递回原始飞书群。",
+        ].join("\n"),
+        discussParticipantPrompt: (p) => [
+            "这是一个多智能体结构化讨论。",
+            "",
+            "话题：",
+            p.topic,
+            "",
+            `当前轮次：${p.round}`,
+            "",
+            "已完成的轮次：",
+            p.previous,
+            "",
+            "本轮其他 bot 的回复你暂时看不到，请基于同一份上下文独立给出观点。",
+            "",
+            "要求：",
+            "1. 不要重复前几轮已经说过的观点。",
+            "2. 只补充新的、有价值的信息。",
+            "3. 如果没有新东西，回复 NO_REPLY。",
+            "4. 简洁作答。",
+        ].join("\n"),
+        chairmanPrompt: (p) => [
+            "这是一个多智能体结构化讨论。你是本群的 Chairman / 主席。",
+            "",
+            "话题：",
+            p.topic,
+            "",
+            `当前轮次：${p.round}/${p.maxRounds}`,
+            "",
+            "本轮发言：",
+            p.replies || "（本轮没有普通参与者发言）",
+            "",
+            "你的职责：",
+            "1. 先发表你自己的实质观点和判断，不要只做中立转述。",
+            "2. 识别大家已经达成的共识。",
+            "3. 扮演质疑者：主动检查薄弱证据、跳跃结论、未验证假设、遗漏风险和可能错误。",
+            "4. 识别还没解决的关键分歧。",
+            "5. 如果观点冲突，要调停并指出下一轮应聚焦的问题。",
+            "6. 如果已经足够清楚，或者本轮必须结束，请做最终总结。",
+            "",
+            p.mustFinish
+                ? "本轮必须结束。请以 `FINAL_SUMMARY:` 开头，先给出你的个人判断，再指出你认为仍需警惕的问题/薄弱点，最后给出最终总结、共识、分歧和下一步建议。"
+                : "如果应继续讨论，请以 `CHAIRMAN_NOTE:` 开头，先给出你的个人判断，再提出必要质疑（薄弱证据、跳跃结论、未验证假设、遗漏风险），最后简要调停并提出下一轮聚焦问题；如果已经可以结束，请以 `FINAL_SUMMARY:` 开头，先给出你的个人判断和必要质疑，再做最终总结。",
+            "",
+            "请简洁、有主持感，但必须包含你自己的观点；在需要时要敢于质疑，不要只做中立转述，也不要只重复普通参与者的长篇内容。",
+        ].join("\n"),
+        labels: {
+            noPreviousRounds: "（暂无，当前是第一轮）",
+            noRegularReplies: "（本轮没有普通参与者发言）",
+            noNewReply: "无新增回复",
+            error: "出错",
+            discussionRoundNotice: (round, max, parts) => `💬 第 ${round}/${max} 轮：${parts}`,
+            round: "轮",
+            discussEndedChairman: (name) => `💬 Discuss 已结束：Chairman ${name} 已完成总结。`,
+            discussEndedNoNew: (round) => `💬 Discuss 已结束：第 ${round} 轮没有新的有效补充。`,
+            discussMaxRounds: (max) => `💬 Discuss 已完成：已达到 ${max} 轮。`,
+        },
+    },
+    en: {
+        bridgePolicy: [
+            "[LMA bridge policy]",
+            "You are in an OpenClaw Lark Multi-Agent bridge session.",
+            "Do not call message, sessions_send, feishu_im_user_message, or any proactive external-chat sending tool.",
+            "Reply directly in the current assistant response; the LMA bridge will deliver the final reply back to the original Feishu chat.",
+        ].join("\n"),
+        discussParticipantPrompt: (p) => [
+            "This is a structured multi-agent discussion.",
+            "",
+            "Topic:",
+            p.topic,
+            "",
+            `Current round: ${p.round}`,
+            "",
+            "Completed rounds:",
+            p.previous,
+            "",
+            "You cannot see other bots' replies in this round yet. Give an independent view based on the same context.",
+            "",
+            "Rules:",
+            "1. Do not repeat points already made in previous rounds.",
+            "2. Only add new, useful information.",
+            "3. If you have nothing new, reply exactly NO_REPLY.",
+            "4. Be concise.",
+        ].join("\n"),
+        chairmanPrompt: (p) => [
+            "This is a structured multi-agent discussion. You are the Chairman of this group.",
+            "",
+            "Topic:",
+            p.topic,
+            "",
+            `Current round: ${p.round}/${p.maxRounds}`,
+            "",
+            "This round's replies:",
+            p.replies || "(No regular participant replies in this round)",
+            "",
+            "Your responsibilities:",
+            "1. First state your own substantive view and judgment; do not merely summarize neutrally.",
+            "2. Identify the consensus already reached.",
+            "3. Act as a challenger: inspect weak evidence, logical jumps, unverified assumptions, missed risks, and possible mistakes.",
+            "4. Identify unresolved key disagreements.",
+            "5. If views conflict, mediate and specify what the next round should focus on.",
+            "6. If the discussion is sufficiently clear, or this round must finish, provide a final summary.",
+            "",
+            p.mustFinish
+                ? "This round must finish. Start with `FINAL_SUMMARY:`. First give your own judgment, then point out remaining caveats/weak spots, then provide the final summary, consensus, disagreements, and next steps."
+                : "If the discussion should continue, start with `CHAIRMAN_NOTE:`. First give your own judgment, then raise necessary challenges (weak evidence, logical jumps, unverified assumptions, missed risks), then mediate briefly and propose the next focus. If it can end now, start with `FINAL_SUMMARY:`, give your own judgment and necessary challenges first, then provide the final summary.",
+            "",
+            "Be concise and chair-like, but include your own view. Challenge when needed; do not merely restate participants' long answers.",
+        ].join("\n"),
+        labels: {
+            noPreviousRounds: "(None yet; this is the first round)",
+            noRegularReplies: "(No regular participant replies in this round)",
+            noNewReply: "no new reply",
+            error: "error",
+            discussionRoundNotice: (round, max, parts) => `💬 Round ${round}/${max}: ${parts}`,
+            round: "round",
+            discussEndedChairman: (name) => `💬 Discuss ended: Chairman ${name} completed the final summary.`,
+            discussEndedNoNew: (round) => `💬 Discuss ended: round ${round} had no new useful additions.`,
+            discussMaxRounds: (max) => `💬 Discuss completed: reached ${max} rounds.`,
+        },
+    },
+};
+export function getI18n(locale) {
+    return dict[normalizeLocale(locale)];
+}

package/dist/message-store.d.ts

@@ -14,6 +14,9 @@ export interface ChatInfo {
     verbose: boolean;
     discuss: boolean;
     discussMaxRounds: number;
+    /** Group-level chairman bot name. Empty means no chairman. */
+    chairmanBot?: string;
+    locale?: string;
     updatedAt: number;
 }
 export interface ChatMessage {
@@ -101,6 +104,11 @@ export declare class MessageStore {
     setVerbose(chatId: string, verbose: boolean): void;
     setDiscussMode(chatId: string, on: boolean): void;
     setDiscussMaxRounds(chatId: string, rounds: number): void;
+    setChatLocale(chatId: string, locale: string): void;
+    getChatLocale(chatId: string): string;
+    setChairmanBot(chatId: string, botName: string): void;
+    clearChairmanBot(chatId: string): void;
+    getChairmanBot(chatId: string): string;
     setBotVerbose(botName: string, chatId: string, verbose: boolean): void;
     getBotVerbose(botName: string, chatId: string): boolean;
     setBotMode(botName: string, chatId: string, mode: BotChatMode): void;

package/dist/message-store.js

@@ -33,7 +33,9 @@ export class MessageStore {
         member_names TEXT NOT NULL DEFAULT '',
         verbose INTEGER NOT NULL DEFAULT 0,
         discuss INTEGER NOT NULL DEFAULT 0,
-        discuss_max_rounds INTEGER NOT NULL DEFAULT 3,
+        discuss_max_rounds INTEGER NOT NULL DEFAULT 10,
+        chairman_bot TEXT NOT NULL DEFAULT '',
+        locale TEXT NOT NULL DEFAULT '',
         updated_at INTEGER NOT NULL DEFAULT 0
       );
 
@@ -181,6 +183,20 @@ export class MessageStore {
         catch {
             // Column already exists
         }
+        // Migration: add locale column if missing
+        try {
+            this.db.exec(`ALTER TABLE chat_info ADD COLUMN locale TEXT NOT NULL DEFAULT ''`);
+        }
+        catch {
+            // Column already exists
+        }
+        // Migration: add chairman column if missing
+        try {
+            this.db.exec(`ALTER TABLE chat_info ADD COLUMN chairman_bot TEXT NOT NULL DEFAULT ''`);
+        }
+        catch {
+            // Column already exists
+        }
         // Migration: add discuss columns if missing
         try {
             this.db.exec(`ALTER TABLE chat_info ADD COLUMN discuss INTEGER NOT NULL DEFAULT 0`);
@@ -189,11 +205,14 @@ export class MessageStore {
             // Column already exists
         }
         try {
-            this.db.exec(`ALTER TABLE chat_info ADD COLUMN discuss_max_rounds INTEGER NOT NULL DEFAULT 3`);
+            this.db.exec(`ALTER TABLE chat_info ADD COLUMN discuss_max_rounds INTEGER NOT NULL DEFAULT 10`);
         }
         catch {
             // Column already exists
         }
+        // Migration: promote the old discuss default (3 rounds) to the new default
+        // (10 rounds). Explicit non-default values such as 1/2/5/8 are preserved.
+        this.db.prepare(`UPDATE chat_info SET discuss_max_rounds = 10 WHERE discuss_max_rounds = 3`).run();
         // Migration: add owner_bot column if missing
         try {
             this.db.exec(`ALTER TABLE chat_info ADD COLUMN owner_bot TEXT NOT NULL DEFAULT ''`);
@@ -540,8 +559,8 @@ export class MessageStore {
     // --- Chat info ---
     upsertChatInfo(info) {
         this.db.prepare(`
-      INSERT INTO chat_info (chat_id, chat_type, chat_name, members, member_names, verbose, free_discussion, owner_bot, discuss, discuss_max_rounds, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO chat_info (chat_id, chat_type, chat_name, members, member_names, verbose, free_discussion, owner_bot, discuss, discuss_max_rounds, chairman_bot, locale, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT (chat_id) DO UPDATE SET
         chat_type = excluded.chat_type,
         chat_name = excluded.chat_name,
@@ -551,9 +570,11 @@ export class MessageStore {
         free_discussion = excluded.free_discussion,
         owner_bot = CASE WHEN excluded.owner_bot != '' THEN excluded.owner_bot ELSE chat_info.owner_bot END,
         discuss = CASE WHEN excluded.discuss != 0 THEN excluded.discuss ELSE chat_info.discuss END,
-        discuss_max_rounds = CASE WHEN excluded.discuss_max_rounds != 3 THEN excluded.discuss_max_rounds ELSE chat_info.discuss_max_rounds END,
+        discuss_max_rounds = CASE WHEN excluded.discuss_max_rounds != 10 THEN excluded.discuss_max_rounds ELSE chat_info.discuss_max_rounds END,
+        chairman_bot = CASE WHEN excluded.chairman_bot != '' THEN excluded.chairman_bot ELSE chat_info.chairman_bot END,
+        locale = CASE WHEN excluded.locale != '' THEN excluded.locale ELSE chat_info.locale END,
         updated_at = excluded.updated_at
-    `).run(info.chatId, info.chatType, info.chatName, info.members, info.memberNames, info.verbose ? 1 : 0, info.freeDiscussion ? 1 : 0, info.ownerBot || '', info.discuss ? 1 : 0, info.discussMaxRounds || 3, info.updatedAt);
+    `).run(info.chatId, info.chatType, info.chatName, info.members, info.memberNames, info.verbose ? 1 : 0, info.freeDiscussion ? 1 : 0, info.ownerBot || '', info.discuss ? 1 : 0, info.discussMaxRounds || 10, info.chairmanBot || '', info.locale || '', info.updatedAt);
     }
     setFreeDiscussion(chatId, on) {
         this.db.prepare(`UPDATE chat_info SET free_discussion = ? WHERE chat_id = ?`).run(on ? 1 : 0, chatId);
@@ -566,7 +587,7 @@ export class MessageStore {
     setDiscussMode(chatId, on) {
         this.db.prepare(`
       INSERT INTO chat_info (chat_id, chat_type, chat_name, discuss, discuss_max_rounds, updated_at)
-      VALUES (?, 'group', '', ?, 3, ?)
+      VALUES (?, 'group', '', ?, 10, ?)
       ON CONFLICT (chat_id) DO UPDATE SET discuss = excluded.discuss, updated_at = excluded.updated_at
     `).run(chatId, on ? 1 : 0, Date.now());
     }
@@ -578,6 +599,31 @@ export class MessageStore {
       ON CONFLICT (chat_id) DO UPDATE SET discuss_max_rounds = excluded.discuss_max_rounds, updated_at = excluded.updated_at
     `).run(chatId, normalized, Date.now());
     }
+    setChatLocale(chatId, locale) {
+        this.db.prepare(`
+      INSERT INTO chat_info (chat_id, chat_type, chat_name, locale, updated_at)
+      VALUES (?, 'group', '', ?, ?)
+      ON CONFLICT (chat_id) DO UPDATE SET locale = excluded.locale, updated_at = excluded.updated_at
+    `).run(chatId, locale, Date.now());
+    }
+    getChatLocale(chatId) {
+        const row = this.db.prepare(`SELECT locale FROM chat_info WHERE chat_id = ?`).get(chatId);
+        return row?.locale || '';
+    }
+    setChairmanBot(chatId, botName) {
+        this.db.prepare(`
+      INSERT INTO chat_info (chat_id, chat_type, chat_name, chairman_bot, updated_at)
+      VALUES (?, 'group', '', ?, ?)
+      ON CONFLICT (chat_id) DO UPDATE SET chairman_bot = excluded.chairman_bot, updated_at = excluded.updated_at
+    `).run(chatId, botName, Date.now());
+    }
+    clearChairmanBot(chatId) {
+        this.setChairmanBot(chatId, '');
+    }
+    getChairmanBot(chatId) {
+        const row = this.db.prepare(`SELECT chairman_bot FROM chat_info WHERE chat_id = ?`).get(chatId);
+        return row?.chairman_bot || '';
+    }
     setBotVerbose(botName, chatId, verbose) {
         this.db.prepare(`
       INSERT INTO bot_chat_settings (bot_name, chat_id, verbose, updated_at)
@@ -634,7 +680,9 @@ export class MessageStore {
             freeDiscussion: !!row.free_discussion,
             verbose: !!row.verbose,
             discuss: !!row.discuss,
-            discussMaxRounds: row.discuss_max_rounds || 3,
+            discussMaxRounds: row.discuss_max_rounds || 10,
+            chairmanBot: row.chairman_bot || '',
+            locale: row.locale || '',
             updatedAt: row.updated_at,
         };
     }
@@ -650,7 +698,9 @@ export class MessageStore {
             freeDiscussion: !!r.free_discussion,
             verbose: !!r.verbose,
             discuss: !!r.discuss,
-            discussMaxRounds: r.discuss_max_rounds || 3,
+            discussMaxRounds: r.discuss_max_rounds || 10,
+            chairmanBot: r.chairman_bot || '',
+            locale: r.locale || '',
             updatedAt: r.updated_at,
         }));
     }

package/package.json

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