@xmanrui/dsh-im 4.29.1 → 4.30.0

package/plugin-src/host/channels/feishu/rpc.mjs

@@ -31,6 +31,10 @@ import {
   normalizeFeishuStepPushMode,
 } from '../../../../src/channels/feishu/step-push-mode.mjs';
 import { normalizeFeishuVoiceConfig } from '../../../../src/channels/feishu/voice-config.mjs';
+import {
+  isSlashPanelConfig,
+  normalizeSlashPanelConfig,
+} from '../../../../src/channels/feishu/slash-command-panel.mjs';
 import {
   FEISHU_ENDPOINTS as FEISHU_CLIENT_ENDPOINTS,
   FEISHU_RPC_CHANNEL,
@@ -305,10 +309,11 @@ function publicBotEntry(entry) {
     contextEnhancement: normalizeContextEnhancementConfig(source.contextEnhancement),
     accessPolicy: normalizeAccessPolicy(source.accessPolicy),
     groupResponseMode: normalizeFeishuGroupResponseMode(source.groupResponseMode),
-    groupTopicReply: source.groupTopicReply === true,
+    mentionTopicReply: source.mentionTopicReply !== false,
     stepPush: source.stepPush === true,
     stepPushMode: normalizeFeishuStepPushMode(source.stepPushMode),
     voice: normalizeFeishuVoiceConfig(source.voice),
+    slashPanel: normalizeSlashPanelConfig(source.slashPanel),
     groupMessagePermissionGranted: source.groupMessagePermissionGranted === true,
     bot: publicBot(source.bot),
     health: publicHealth(source, connected),
@@ -471,10 +476,10 @@ function validPayload(endpoint, payload) {
       ? null
       : '请选择群聊响应方式。';
   }
-  if (endpoint === FEISHU_ENDPOINTS.setGroupTopicReply) {
-    return hasOnlyKeys(payload, new Set(['botId', 'groupTopicReply']))
+  if (endpoint === FEISHU_ENDPOINTS.setMentionTopicReply) {
+    return hasOnlyKeys(payload, new Set(['botId', 'mentionTopicReply']))
       && safeOpaqueId(payload.botId)
-      && typeof payload.groupTopicReply === 'boolean'
+      && typeof payload.mentionTopicReply === 'boolean'
       ? null
       : '请选择是否以话题方式回复。';
   }
@@ -503,6 +508,13 @@ function validPayload(endpoint, payload) {
       ? null
       : '语音配置无效。';
   }
+  if (endpoint === FEISHU_ENDPOINTS.setSlashPanel) {
+    return hasOnlyKeys(payload, new Set(['botId', 'slashPanel']))
+      && safeOpaqueId(payload.botId)
+      && isSlashPanelConfig(payload.slashPanel)
+      ? null
+      : '请选择面板要显示的指令与顺序。';
+  }
   return 'Unknown Feishu endpoint.';
 }
 
@@ -786,12 +798,12 @@ export function createFeishuRpcHandler(controller, { encodeQr = qrCodeDataUrl }
           await controller.updateGroupResponseMode(payload.botId, payload.groupResponseMode),
           { encodeQr: cachedEncodeQr },
         );
-      } else if (endpoint === FEISHU_ENDPOINTS.setGroupTopicReply) {
-        if (typeof controller.updateGroupTopicReply !== 'function') {
-          throw new Error('Group topic reply update is unavailable');
+      } else if (endpoint === FEISHU_ENDPOINTS.setMentionTopicReply) {
+        if (typeof controller.updateMentionTopicReply !== 'function') {
+          throw new Error('Mention topic reply update is unavailable');
         }
         value = await toPublicFeishuStatus(
-          await controller.updateGroupTopicReply(payload.botId, payload.groupTopicReply),
+          await controller.updateMentionTopicReply(payload.botId, payload.mentionTopicReply),
           { encodeQr: cachedEncodeQr },
         );
       } else if (endpoint === FEISHU_ENDPOINTS.setStepPush) {
@@ -818,6 +830,14 @@ export function createFeishuRpcHandler(controller, { encodeQr = qrCodeDataUrl }
           await controller.updateVoice(payload.botId, payload.voice),
           { encodeQr: cachedEncodeQr },
         );
+      } else if (endpoint === FEISHU_ENDPOINTS.setSlashPanel) {
+        if (typeof controller.updateSlashPanel !== 'function') {
+          throw new Error('Slash panel update is unavailable');
+        }
+        value = await toPublicFeishuStatus(
+          await controller.updateSlashPanel(payload.botId, payload.slashPanel),
+          { encodeQr: cachedEncodeQr },
+        );
       } else {
         if (typeof controller.deleteBot !== 'function') throw new Error('Multi-bot delete is unavailable');
         value = await toPublicFeishuStatus(await controller.deleteBot(payload.botId), { encodeQr: cachedEncodeQr });

package/src/channels/feishu/bridge.mjs

@@ -1,12 +1,14 @@
 import QRCode from 'qrcode';
 import {
   conversationKey,
+  conversationScope,
   extractInboundMessage,
   extractText,
   isAllowedSender,
   isBotSender,
-  isTopicGroupKey,
-  managedGroupKey,
+  isTopicKey,
+  managedTopicKey,
+  managedTopicRoot,
   splitText,
 } from './message-utils.mjs';
 import {
@@ -331,6 +333,26 @@ function isBareMentionMenuRequest(event, text, {
   return !String(text ?? '').trim();
 }
 
+/**
+ * A message that is nothing but a mention of the bot, with no body of its own.
+ * There is no question to answer — a direct chat opens the menu card for it and
+ * a group gets the "text, image and file only" notice — so it must not open a
+ * topic either: an empty topic would leave an empty session behind, and every
+ * look at the menu would create another one.
+ *
+ * Mirrors the reply-reference test (`feishuReplyTargetId`): an explicit quote
+ * keeps the message a real question even when the mention is all the text it
+ * carries.
+ */
+function isBareMentionMessage(event) {
+  if (event?.message?.message_type !== 'text') return false;
+  const messageId = nonEmptyString(event?.message?.message_id);
+  const parentId = nonEmptyString(event?.message?.parent_id);
+  const rootId = nonEmptyString(event?.message?.root_id);
+  if (parentId || (rootId && rootId !== messageId)) return false;
+  return !String(extractText(event) ?? '').trim();
+}
+
 /** Canonical workspace/session help advertised by every bridge family. */
 const WORKSPACE_HELP_LINES = [
   '/workspace 工作区序号或绝对路径  切换工作区',
@@ -639,8 +661,13 @@ export class FeishuHarnessBridge {
   #appId;
   #botOpenId;
   #groupResponseMode;
-  /** When true, group replies that belong to a Feishu topic ask reply_in_thread. */
-  #groupTopicReply = false;
+  /**
+   * When true (the default), a question addressed to the bot opens a Feishu
+   * topic of its own — in groups and in direct chats alike — and the answer
+   * stays inside it. Turning it off keeps every question in the chat's main
+   * session and answers it in the main feed.
+   */
+  #mentionTopicReply = true;
   /** When true, streaming turns push tool calls and interim notes as discrete messages. */
   #stepPush = false;
   /** Step push presentation: discrete posts, a CardKit card, or native live CoT. */
@@ -706,7 +733,7 @@ export class FeishuHarnessBridge {
     appId,
     botOpenId,
     groupResponseMode = FEISHU_GROUP_RESPONSE_MODES.ALL,
-    groupTopicReply = false,
+    mentionTopicReply = true,
     stepPush = false,
     stepPushMode = FEISHU_STEP_PUSH_MODES.POST,
     stepPushClock = null,
@@ -764,7 +791,7 @@ export class FeishuHarnessBridge {
     this.#appId = nonEmptyString(appId);
     this.#botOpenId = nonEmptyString(botOpenId);
     this.#groupResponseMode = normalizeFeishuGroupResponseMode(groupResponseMode);
-    this.#groupTopicReply = groupTopicReply === true;
+    this.#mentionTopicReply = mentionTopicReply !== false;
     this.#stepPush = stepPush === true;
     this.#stepPushMode = normalizeFeishuStepPushMode(stepPushMode);
     this.#stepPushClock = stepPushClock ?? DEFAULT_STEP_PUSH_CLOCK;
@@ -850,8 +877,8 @@ export class FeishuHarnessBridge {
     this.#groupResponseMode = normalizeFeishuGroupResponseMode(value);
   }
 
-  setGroupTopicReply(value) {
-    this.#groupTopicReply = value === true;
+  setMentionTopicReply(value) {
+    this.#mentionTopicReply = value !== false;
   }
 
   setStepPush(value) {
@@ -872,6 +899,16 @@ export class FeishuHarnessBridge {
 
   #isAddressed(event) {
     if (event?.message?.chat_type === 'p2p') return true;
+    return this.#isMentioned(event);
+  }
+
+  /**
+   * Whether this message mentions the bot. Unlike #isAddressed — which answers
+   * "does this chat expect a reply at all" and is therefore always true in a
+   * direct chat — this asks the literal question, so a topic is only opened for
+   * a message the reader actually addressed to the bot.
+   */
+  #isMentioned(event) {
     const mentions = Array.isArray(event?.message?.mentions) ? event.message.mentions : [];
     if (!this.#botOpenId) return mentions.length > 0;
     return mentions.some((mention) => mention?.id?.open_id === this.#botOpenId
@@ -879,27 +916,31 @@ export class FeishuHarnessBridge {
   }
 
   /**
-   * Conversation key for one inbound event. When group-topic replies are on,
-   * a main-feed question addressed to the bot opens a fresh managed topic
-   * session instead of joining the shared group session, and messages inside
-   * a topic we already opened resolve back to that same managed session.
+   * Conversation key for one inbound event, for groups and direct chats alike.
+   *
+   * - A message inside a topic resolves back to the managed key when the bot
+   *   rooted that topic, so the whole topic keeps one session; every other
+   *   thread keeps the key the channel would have used without managed topics.
+   * - A main-feed message that mentions the bot opens a fresh managed topic
+   *   session instead of joining the chat's shared session. A bare "@bot" is
+   *   excluded: it is a menu request, not a question.
+   * - Everything else stays in the chat's shared session.
    */
   #resolveKey(event) {
-    const chatType = event?.message?.chat_type;
-    const chatId = nonEmptyString(event?.message?.chat_id);
-    if (chatType !== 'group') return conversationKey(event);
     const messageId = nonEmptyString(event?.message?.message_id);
     const threadId = nonEmptyString(event?.message?.thread_id);
     if (threadId) {
       const root = this.#state?.topicRootFor?.(threadId) ?? null;
-      return root && chatId
-        ? managedGroupKey(chatId, root.rootMessageId)
-        : `group:${chatId}:thread:${threadId}`;
+      if (root) return managedTopicKey(conversationScope(event), root.rootMessageId);
+      return conversationKey(event);
     }
-    if (this.#groupTopicReply && chatId && messageId && this.#isAddressed(event)) {
-      return managedGroupKey(chatId, messageId);
+    if (this.#mentionTopicReply
+      && messageId
+      && this.#isMentioned(event)
+      && !isBareMentionMessage(event)) {
+      return managedTopicKey(conversationScope(event), messageId);
     }
-    return `group:${chatId}`;
+    return conversationKey(event);
   }
 
   /**
@@ -911,7 +952,7 @@ export class FeishuHarnessBridge {
    */
   #rememberTopicReply(messageId, key) {
     if (!nonEmptyString(messageId)) return;
-    this.#anchorTopicReply.set(messageId, isTopicGroupKey(key));
+    this.#anchorTopicReply.set(messageId, isTopicKey(key));
     if (this.#anchorTopicReply.size > 2048) {
       const oldest = this.#anchorTopicReply.keys().next().value;
       if (oldest !== undefined) this.#anchorTopicReply.delete(oldest);
@@ -960,13 +1001,62 @@ export class FeishuHarnessBridge {
 
   /** Persist thread_id once Feishu auto-opened a topic from a managed root. */
   async #registerTopicFromReply(replyTo, chatId, response) {
-    const threadId = nonEmptyString(response?.data?.thread_id);
+    await this.#registerTopicReply(replyTo, chatId, response?.data?.thread_id);
+  }
+
+  /**
+   * Record the topic for a root this bot asked Feishu to open. The reply
+   * response carries the thread_id in most cases; when it does not — we have
+   * seen a topic come back without one — read it back from the message we
+   * replied to. Feishu opened the topic either way, and a topic left
+   * unrecorded would answer its follow-ups from the chat's own session instead
+   * of the topic's.
+   */
+  async #registerTopicReply(rootMessageId, chatId, threadId) {
+    const known = nonEmptyString(threadId);
+    if (known) {
+      await this.#registerTopicThreadId(known, rootMessageId, chatId);
+      return;
+    }
+    await this.#ensureTopicRegistered(rootMessageId, chatId);
+  }
+
+  /**
+   * Fallback for a threaded reply that reported no thread_id: ask Feishu which
+   * topic the replied-to message now belongs to. Only runs while that message
+   * is still a pending root candidate, so a topic already recorded — or a
+   * conversation that has no topics at all — costs no extra API call.
+   */
+  async #ensureTopicRegistered(rootMessageId, chatId) {
+    this.#pruneRootCandidates();
+    if (!nonEmptyString(rootMessageId) || !this.#rootCandidates.has(rootMessageId)) return;
+    const threadId = await this.#readTopicThreadId(rootMessageId);
     if (threadId) {
-      await this.#registerTopicThreadId(threadId, replyTo, chatId);
-    } else {
-      // No thread_id means the topic did not open; drop the candidate so a
-      // later addressed question opens a fresh session, not a stale slot.
-      this.#forgetTopicRoot(replyTo);
+      await this.#registerTopicThreadId(threadId, rootMessageId, chatId);
+      return;
+    }
+    // Still no topic: drop the candidate so a later addressed question opens a
+    // fresh session rather than reusing a stale slot.
+    this.#forgetTopicRoot(rootMessageId);
+  }
+
+  /** The topic a message belongs to, or null when it is not in one. */
+  async #readTopicThreadId(messageId) {
+    const read = this.#client?.im?.v1?.message?.get;
+    if (typeof read !== 'function') return null;
+    try {
+      const response = await read({ path: { message_id: messageId } });
+      if (response?.code && response.code !== 0) return null;
+      const items = Array.isArray(response?.data?.items) ? response.data.items : [];
+      const item = items.find((candidate) => nonEmptyString(candidate?.message_id) === messageId)
+        ?? items[0];
+      return nonEmptyString(item?.thread_id);
+    } catch (error) {
+      this.#logger.warn?.(
+        '[dsh-feishu] could not read the topic of a replied-to message:',
+        error?.message ?? String(error),
+      );
+      return null;
     }
   }
 
@@ -1053,10 +1143,9 @@ export class FeishuHarnessBridge {
     }
     // Register a managed-topic root only after access is allowed, so a
     // rejected or ignored question never reserves a candidate slot.
-    if (this.#groupTopicReply
-      && event?.message?.chat_type === 'group'
+    if (this.#mentionTopicReply
       && !nonEmptyString(event?.message?.thread_id)
-      && isTopicGroupKey(key)
+      && isTopicKey(key)
       && key.includes(':managed:')) {
       this.#rememberTopicRoot(messageId);
     }
@@ -3448,7 +3537,9 @@ export class FeishuHarnessBridge {
 
   async #deliverDeferredOutcome(entry, outcome) {
     this.#rememberTopicReply(entry.replyToMessageId, entry.key);
-    if (entry.key === managedGroupKey(entry.chatId, entry.replyToMessageId)) {
+    // A late answer still has to open the topic it was rooted at, so re-arm the
+    // root candidate: the key alone says whether this route was a managed topic.
+    if (managedTopicRoot(entry.key) === nonEmptyString(entry.replyToMessageId)) {
       this.#rememberTopicRoot(entry.replyToMessageId);
     }
     const text = deferredOutcomeText(outcome);
@@ -3470,10 +3561,10 @@ export class FeishuHarnessBridge {
           ...(replyToMessageId ? { replyTo: replyToMessageId } : {}),
           ...(this.#replyInThreadFor(replyToMessageId) ? {
             replyInThread: true,
-            onReplyThreadId: async (threadId) => this.#registerTopicThreadId(
-              threadId,
+            onReplyThreadId: async (threadId) => this.#registerTopicReply(
               replyToMessageId,
               chatId,
+              threadId,
             ),
           } : {}),
         });
@@ -4280,7 +4371,7 @@ export class FeishuHarnessBridge {
             replyTo,
             signal: this.#signal,
             ...(this.#replyInThreadFor(replyTo)
-              ? { replyInThread: true, onReplyThreadId: async (threadId) => this.#registerTopicThreadId(threadId, replyTo, chatId) }
+              ? { replyInThread: true, onReplyThreadId: async (threadId) => this.#registerTopicReply(replyTo, chatId, threadId) }
               : {}),
           })
         : undefined,
@@ -4289,7 +4380,7 @@ export class FeishuHarnessBridge {
             replyTo,
             signal: this.#signal,
             ...(this.#replyInThreadFor(replyTo)
-              ? { replyInThread: true, onReplyThreadId: async (threadId) => this.#registerTopicThreadId(threadId, replyTo, chatId) }
+              ? { replyInThread: true, onReplyThreadId: async (threadId) => this.#registerTopicReply(replyTo, chatId, threadId) }
               : {}),
           })
         : undefined,
@@ -4832,10 +4923,11 @@ export class FeishuHarnessBridge {
       error.feishuCode = response.code;
       throw error;
     }
-    const threadId = nonEmptyString(response?.data?.thread_id);
-    if (threadId) {
-      await this.#registerTopicThreadId(threadId, messageId, chatId);
-    }
+    // 与其他回复路径同一条登记逻辑：响应通常带 thread_id，没带就回读被回复的消息
+    // （#registerTopicReply → #ensureTopicRegistered）。逐步消息以前只认响应，
+    // 于是话题开出来了却没登记，话题内的追问会从托管键掉回聊天自己的会话。
+    // 两个分支都以「该消息仍是待开话题的候选根」为前提，不是候选就是空操作。
+    await this.#registerTopicReply(messageId, chatId, response?.data?.thread_id);
     return response;
   }
 
@@ -5539,7 +5631,7 @@ export class FeishuHarnessBridge {
       }, {
         replyTo: messageId,
         ...(this.#replyInThreadFor(messageId)
-          ? { replyInThread: true, onReplyThreadId: async (threadId) => this.#registerTopicThreadId(threadId, messageId, chatId) }
+          ? { replyInThread: true, onReplyThreadId: async (threadId) => this.#registerTopicReply(messageId, chatId, threadId) }
           : {}),
       });
     } catch (error) {

package/src/channels/feishu/feishu-channel.mjs

@@ -516,9 +516,12 @@ export class VerifiedFeishuChannel {
     if (typeof messageId !== 'string' || !messageId) {
       throw fileDeliveryError('message send', undefined, undefined, { uncertain: true });
     }
-    if (replyTo && typeof onReplyThreadId === 'function') {
+    if (replyTo && replyInThread && typeof onReplyThreadId === 'function') {
+      // The reply itself opens the topic, and the response reports its
+      // thread_id only sometimes (a direct-chat topic comes back without one).
+      // Hand over what we have and let the bridge read it back when missing.
       const threadId = response?.data?.thread_id;
-      if (typeof threadId === 'string' && threadId) await onReplyThreadId(threadId);
+      await onReplyThreadId(typeof threadId === 'string' && threadId ? threadId : null);
     }
     return createDeliveryReceipt({
       deliveryId: file.deliveryKey,
@@ -596,9 +599,11 @@ export class VerifiedFeishuChannel {
     assertApiSuccess('Feishu message send', response);
     const messageId = response?.data?.message_id;
     if (!messageId) throw new Error('Feishu message send returned no message_id');
-    if (replyTo && typeof options.onReplyThreadId === 'function') {
+    if (replyTo && replyInThread && typeof options.onReplyThreadId === 'function') {
+      // See #sendArtifact: the topic is created by the reply, but the response
+      // may omit its thread_id, so pass it through as it came.
       const threadId = response?.data?.thread_id;
-      if (typeof threadId === 'string' && threadId) await options.onReplyThreadId(threadId);
+      await options.onReplyThreadId(typeof threadId === 'string' && threadId ? threadId : null);
     }
     return messageId;
   }

package/src/channels/feishu/feishu-runtime.mjs

@@ -7,9 +7,10 @@ import { normalizeFeishuGroupResponseMode } from './group-response-mode.mjs';
 import { normalizeFeishuStepPushMode } from './step-push-mode.mjs';
 import { createVoice } from './voice.mjs';
 import {
-  registerSlashCommands,
+  syncSlashCommands,
   SLASH_COMMAND_MANIFEST,
 } from './slash-command-registry.mjs';
+import { normalizeSlashPanelConfig } from './slash-command-panel.mjs';
 import {
   connectionTestTargetUnavailable,
   sendRememberedConnectionTest,
@@ -95,6 +96,7 @@ export function createBridgeStatus({ allowedSenderCount = 1 } = {}) {
     slashCommandsRegistered: 0,
     slashCommandsExisting: 0,
     slashCommandsFailed: 0,
+    slashCommandsRemoved: 0,
     slashCommandsError: null,
   };
 }
@@ -113,7 +115,7 @@ export class FeishuRuntime {
   #domain;
   #botOpenId;
   #groupResponseMode;
-  #groupTopicReply;
+  #mentionTopicReply;
   #stepPush;
   #stepPushMode;
   #voice = null;
@@ -139,6 +141,19 @@ export class FeishuRuntime {
   #pendingCardActionProbes = new Map();
   #status;
   #slashCommands = true;
+  /** Which commands the "/" panel should offer, and in which order. */
+  #slashPanel = null;
+  /** HTTP instance kept for panel re-syncs after startup. */
+  #slashHttpInstance = null;
+  /**
+   * Bumped on every panel change: a sync started for an older config stops at
+   * its next checkpoint instead of racing the newer one (last writer wins).
+   */
+  #slashSyncEpoch = 0;
+  /** Cancels the panel sync in flight; it stops before its next request. */
+  #slashSyncCancel = null;
+  /** Panel syncs run one after another, so two plans never interleave. */
+  #slashSyncQueue = Promise.resolve();
 
   constructor({
     lark,
@@ -148,7 +163,7 @@ export class FeishuRuntime {
     domain = 'feishu',
     botOpenId,
     groupResponseMode,
-    groupTopicReply = false,
+    mentionTopicReply = true,
     stepPush = false,
     stepPushMode = 'post',
     voice = null,
@@ -164,6 +179,7 @@ export class FeishuRuntime {
     connectTimeoutMs = 15000,
     requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
     slashCommands = true,
+    slashPanel = null,
     wsAgent,
     logger = console,
   }) {
@@ -188,7 +204,7 @@ export class FeishuRuntime {
     this.#domain = domain;
     this.#botOpenId = nonEmptyString(botOpenId);
     this.#groupResponseMode = normalizeFeishuGroupResponseMode(groupResponseMode);
-    this.#groupTopicReply = groupTopicReply === true;
+    this.#mentionTopicReply = mentionTopicReply !== false;
     this.#stepPush = stepPush === true;
     this.#stepPushMode = normalizeFeishuStepPushMode(stepPushMode);
     // voice 为 { config, secret } 来源;凭据缺失时 createVoice 返回禁用对象,
@@ -209,6 +225,7 @@ export class FeishuRuntime {
     this.#connectTimeoutMs = connectTimeoutMs;
     this.#requestTimeoutMs = requestTimeoutMs;
     this.#slashCommands = Boolean(slashCommands);
+    this.#slashPanel = normalizeSlashPanelConfig(slashPanel);
     this.#wsAgent = wsAgent;
     this.#logger = logger; this.#diagnostics = createConnectionDiagnostics({ channel: 'feishu', logger });
     this.#status = createBridgeStatus({ allowedSenderCount: normalizedOwners.length });
@@ -223,9 +240,9 @@ export class FeishuRuntime {
     this.#bridge?.setGroupResponseMode(this.#groupResponseMode);
   }
 
-  setGroupTopicReply(value) {
-    this.#groupTopicReply = value === true;
-    this.#bridge?.setGroupTopicReply(this.#groupTopicReply);
+  setMentionTopicReply(value) {
+    this.#mentionTopicReply = value !== false;
+    this.#bridge?.setMentionTopicReply(this.#mentionTopicReply);
   }
 
   setStepPush(value) {
@@ -245,6 +262,17 @@ export class FeishuRuntime {
     this.#bridge?.setVoice(this.#voice);
   }
 
+  /**
+   * Record which commands the "/" panel should offer. The panel itself lives on
+   * Feishu's side, so a connected bot re-syncs it in the background; the newer
+   * config wins and any sync still running for the older one stops.
+   */
+  setSlashPanel(value) {
+    this.#slashPanel = normalizeSlashPanelConfig(value);
+    this.#slashSyncEpoch += 1;
+    this.#scheduleSlashPanelSync();
+  }
+
   async start() {
     while (true) {
       while (this.#stopping) await this.#stopping;
@@ -333,7 +361,7 @@ export class FeishuRuntime {
         appId: this.#appId,
         botOpenId: this.#botOpenId,
         groupResponseMode: this.#groupResponseMode,
-        groupTopicReply: this.#groupTopicReply,
+        mentionTopicReply: this.#mentionTopicReply,
         stepPush: this.#stepPush,
         stepPushMode: this.#stepPushMode,
         voice: this.#voice,
@@ -444,9 +472,11 @@ export class FeishuRuntime {
       assertCurrentStart();
       // Register the native Slash Command panel best-effort and asynchronously
       // so it never blocks the long-connection startup. The panel is only a
-      // client-side convenience; failure here must not take the bot down.
+      // client-side convenience; failure here must not take the bot down. The
+      // HTTP instance is kept so a later panel change can re-sync while running.
       if (this.#slashCommands && httpInstance) {
-        void this.#registerSlashCommands(httpInstance, isCurrentStart, signal);
+        this.#slashHttpInstance = httpInstance;
+        this.#scheduleSlashPanelSync();
       }
       return this.status;
     } catch (error) {
@@ -689,28 +719,69 @@ export class FeishuRuntime {
     return { sent: true };
   }
 
-  async #registerSlashCommands(httpInstance, isCurrentStart, signal) {
+  /**
+   * Queue one panel sync for the current config.
+   *
+   * Two saves in a row used to run two syncs concurrently, and the older one
+   * kept deleting and creating commands from a plan nobody wanted anymore. Here
+   * the run in flight is cancelled first — it stops at its next checkpoint while
+   * requests already sent are left to finish — and the new run starts only once
+   * it has settled, so the panel converges to the newest config.
+   */
+  #scheduleSlashPanelSync() {
+    const httpInstance = this.#slashHttpInstance;
+    const connectionSignal = this.#abortController?.signal;
+    if (!this.#slashCommands || !httpInstance || !connectionSignal || connectionSignal.aborted) return;
+    const epoch = this.#slashSyncEpoch;
+    this.#slashSyncCancel?.();
+    const controller = new AbortController();
+    const cancel = () => controller.abort();
+    const forwardAbort = () => cancel();
+    this.#slashSyncCancel = cancel;
+    connectionSignal.addEventListener('abort', forwardAbort, { once: true });
+    if (connectionSignal.aborted) cancel();
+    const run = this.#slashSyncQueue.then(() => this.#registerSlashCommands(
+      httpInstance,
+      () => !connectionSignal.aborted && this.#abortController?.signal === connectionSignal,
+      controller.signal,
+      epoch,
+    ));
+    const settled = run.then(() => {}, () => {});
+    this.#slashSyncQueue = settled;
+    void settled.then(() => {
+      connectionSignal.removeEventListener('abort', forwardAbort);
+      if (this.#slashSyncCancel === cancel) this.#slashSyncCancel = null;
+    });
+  }
+
+  async #registerSlashCommands(httpInstance, isCurrentStart, signal, epoch = this.#slashSyncEpoch) {
     this.#status.slashCommandRegistration = 'registering';
     this.#status.slashCommandsError = null;
     try {
-      const result = await registerSlashCommands({
+      const result = await syncSlashCommands({
         appId: this.#appId,
         appSecret: this.#appSecret,
         domain: this.#domain,
         httpInstance,
         signal,
         manifest: SLASH_COMMAND_MANIFEST,
+        config: this.#slashPanel,
       });
-      if (!isCurrentStart()) return;
+      // A newer panel config took over while this sync was running: its own run
+      // reports the outcome, so this one only stops.
+      if (!isCurrentStart() || epoch !== this.#slashSyncEpoch || result.superseded === true) return;
       this.#status.slashCommandRegistration = 'done';
       this.#status.slashCommandsRegistered = result.created.length;
       this.#status.slashCommandsExisting = result.existing.length;
       this.#status.slashCommandsFailed = result.failed.length;
+      this.#status.slashCommandsRemoved = result.deleted.length;
       this.#status.slashCommandsError = result.failed.length > 0
         ? result.failed.map((f) => `/${f.command}: ${f.error?.message ?? String(f.error)}`).join('; ')
         : null;
-      if (result.created.length > 0) {
-        this.#logger.info?.(`[dsh-feishu] registered ${result.created.length} slash command(s)`);
+      if (result.created.length > 0 || result.deleted.length > 0) {
+        this.#logger.info?.(
+          `[dsh-feishu] slash panel synced: ${result.created.length} added, ${result.deleted.length} removed`,
+        );
       }
       if (result.failed.length > 0) {
         this.#logger.warn?.(