@xmanrui/dsh-im 2.0.1 → 2.1.0

package/src/channels/feishu/bridge.mjs

@@ -44,10 +44,18 @@ import {
 } from '../shared/semantic/delivery.mjs';
 import {
   MENU_PAGE_SIZE,
+  PRESET_FOLLOW_DEFAULT_SENTINEL,
+  STEER_CUSTOM_SENTINEL,
   completionCard,
+  customSteerCard,
+  helpCard,
   menuCard,
   menuHelpText,
+  modelCard,
+  presetCard,
   sessionListCard,
+  statusCard,
+  steerCard,
   watchListCard,
   workspaceListCard,
 } from './feishu-cards.mjs';
@@ -74,6 +82,22 @@ const NUMBER_REPLY = /^\d{1,2}$/;
 /** A displayed menu stays number-tappable for this long. */
 const MENU_TTL_MS = 10 * 60_000;
 const MAX_TRACKED_MENUS = 50;
+/** Bound callback work per conversation so retries cannot exhaust Host RPCs. */
+const MAX_PENDING_CARD_ACTIONS_PER_KEY = 8;
+/** Bound actual stop/steer submissions independently from ordinary card UI work. */
+const MAX_PENDING_CARD_CONTROLS_PER_KEY = 8;
+/** Provider retries may arrive after the original callback has already settled. */
+const CARD_ACTION_DEDUPE_TTL_MS = 10 * 60_000;
+const MAX_COMPLETED_CARD_ACTIONS = 400;
+/** Keep pre-persistence completion arrivals long enough for a new watch to baseline. */
+const COMPLETION_OBSERVATION_TTL_MS = 10 * 60_000;
+const MAX_OBSERVED_COMPLETION_SESSIONS = 100;
+const MAX_OBSERVED_COMPLETIONS_PER_SESSION = 50;
+const MAX_OBSERVED_COMPLETIONS = 500;
+/** Collapse callback-flood notices instead of amplifying overload into more API calls. */
+const CARD_OVERLOAD_NOTICE_COOLDOWN_MS = 5_000;
+/** Cards should degrade promptly when one optional Host data source is slow. */
+const CARD_DATA_TIMEOUT_MS = 5_000;
 const REPAIR_LINK_WAIT_MS = 15_000;
 const REPAIR_POLL_INTERVAL_MS = 1_000;
 const REPAIR_ACTIVE_STATES = new Set([
@@ -89,39 +113,16 @@ const REPAIR_URL_HOSTS = new Set([
   'open.larksuite.com',
 ]);
 
-// Built lazily: t() must run after setImHostLanguage, not at import time.
-function helpText() {
-  return [
-    t('北汇星河 AIOS 已连接 DeepSeek Harness。'),
-    '',
-    t('直接发送文字、图片或文件即可继续当前会话。'),
-    t('/new  开启一个全新会话'),
-    t('/compact  压缩当前会话的较早上下文'),
-    t('/workspace 工作区绝对路径  切换工作区'),
-    t('/workspacelist  列出工作区绝对路径'),
-    t('/sessionlist [工作区序号或绝对路径]  列出会话 ID 和标题'),
-    t('/session Session ID 或当前工作区序号  将当前聊天绑定到指定会话'),
-    t('/models  按序号列出所有可用模型'),
-    t('/model [序号或完整模型ID]  查看或切换当前会话模型'),
-    t('示例：先发 /models，再发 /model 2'),
-    t('/presetlist  按序号列出可用 Agent Preset'),
-    t('/preset [序号或完整ID]  查看或设置当前机器人 Agent Preset'),
-    t('纯数字 ID：/preset id:<ID>'),
-    t('/preset --default  跟随 Host 默认'),
-    t('/stop  停止当前任务'),
-    t('/steer 补充指令  纠偏当前任务'),
-    t('/status  检查连接状态'),
-    t('/repair  修复卡片按钮回调'),
-    t('/m（或 /menu）  打开交互卡片菜单'),
-    t('/watch [Session ID 或序号]  关注会话，任务完成自动推送'),
-    t('/unwatch [Session ID 或序号]  取消关注'),
-    t('/watchlist  查看关注列表'),
-    t('/archived on|off  会话列表是否包含归档会话'),
-    t('/help  显示本帮助'),
-  ].join('\n');
-}
-
 const ARCHIVED_COMMAND = /^\/archived(?:\s+(on|off))?$/i;
+/** Matches fast card commands that should not be queued behind a running task. */
+const CARD_COMMAND = /^\/(?:m(?:enu)?|new|help|status|compact|sessionlist(?:\s|$)|workspacelist|watchlist|archived(?:\s+(on|off))?)$/i;
+
+/** Canonical workspace/session help advertised by every bridge family. */
+const WORKSPACE_HELP_LINES = [
+  '/session Session ID 或当前工作区序号  将当前聊天绑定到指定会话',
+  '/workspacelist  列出工作区绝对路径',
+  '/sessionlist [工作区序号或绝对路径]  列出会话 ID 和标题',
+];
 
 /** Safe user-facing text for bind/workspace failures (no raw messages). */
 function safeErrorText(error) {
@@ -170,10 +171,88 @@ function nonEmptyString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
 
+/** Accept SDK payload fields that may already be objects or JSON strings. */
+function callbackObject(value) {
+  if (value && typeof value === 'object' && !Array.isArray(value)) return value;
+  if (typeof value !== 'string' || !value.trim()) return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+/** Normalize a single-select value without corrupting valid commas in an id/path. */
+function callbackSingleOption(value) {
+  if (value === null || value === undefined) return null;
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      const selected = callbackSingleOption(entry);
+      if (selected !== null) return selected;
+    }
+    return null;
+  }
+  if (value && typeof value === 'object') {
+    if ('value' in value) return callbackSingleOption(value.value);
+    if ('option' in value) return callbackSingleOption(value.option);
+    return null;
+  }
+  if (typeof value !== 'string') return null;
+  const source = value.trim();
+  if (!source) return null;
+  if (source.startsWith('[') || source.startsWith('{') || source.startsWith('"')) {
+    try {
+      const parsed = JSON.parse(source);
+      if (parsed !== value) return callbackSingleOption(parsed);
+    } catch { /* plain value below */ }
+  }
+  return source;
+}
+
+/** Normalize multi-select values across current and legacy SDK shapes. */
+function callbackMultiOptionValues(value) {
+  if (value === null || value === undefined) return [];
+  if (Array.isArray(value)) return value.flatMap((entry) => callbackMultiOptionValues(entry));
+  if (value && typeof value === 'object') {
+    if ('value' in value) return callbackMultiOptionValues(value.value);
+    if ('option' in value) return callbackMultiOptionValues(value.option);
+    return [];
+  }
+  if (typeof value !== 'string') return [];
+  const source = value.trim();
+  if (!source) return [];
+  if (source.startsWith('[') || source.startsWith('{') || source.startsWith('"')) {
+    try {
+      const parsed = JSON.parse(source);
+      if (parsed !== value) return callbackMultiOptionValues(parsed);
+    } catch { /* plain value below */ }
+  }
+  return source.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+
+function validLastSeq(value) {
+  return Number.isSafeInteger(value) && value >= -1;
+}
+
+function validEventSeq(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+
+function watchBoundary(entry) {
+  return Number.isSafeInteger(entry?.watchStartedAt) && entry.watchStartedAt >= 0
+    ? entry.watchStartedAt
+    : null;
+}
+
+function watchNeedsBaseline(entry) {
+  return entry && (watchBoundary(entry) !== null || !validLastSeq(entry.lastSeq));
+}
+
 function orderedHistoryEvents(history) {
   return (Array.isArray(history?.events) ? history.events : [])
     .map((entry) => entry?.event ?? entry)
-    .filter((entry) => entry && typeof entry === 'object' && Number.isFinite(entry.seq))
+    .filter((entry) => entry && typeof entry === 'object' && validEventSeq(entry.seq))
     .sort((left, right) => left.seq - right.seq);
 }
 
@@ -293,6 +372,26 @@ export class FeishuHarnessBridge {
   #acceptedMessageIds = new Set();
   #interactionTasks = new Set();
   #commandTasks = new Set();
+  /** All accepted card work, including tasks waiting behind an earlier click. */
+  #cardActionTasks = new Set();
+  /** Per-conversation navigation/configuration serialization tails. */
+  #cardActionTails = new Map();
+  /** Per-conversation serialization for actual stop/steer side effects. */
+  #cardControlTails = new Map();
+  /** Pending callback count per conversation, used for bounded backpressure. */
+  #cardActionCounts = new Map();
+  /** Pending control count per conversation, isolated from ordinary UI work. */
+  #cardControlCounts = new Map();
+  /** Same callback retry joins the original task instead of repeating side effects. */
+  #cardActionInFlight = new Map();
+  /** Stop is idempotent per conversation; coalesce floods while one stop is pending. */
+  #cardStopInFlight = new Map();
+  /** Stable ids coalesced into a stop move to the completed cache when it settles. */
+  #cardStopFollowers = new Map();
+  /** Settled provider event ids stay deduplicated for a bounded retry window. */
+  #completedCardActions = new Map();
+  /** Last overload notice time per conversation. */
+  #cardOverloadNoticeAt = new Map();
   #approvals;
   #status;
   #allowedSenderOpenIds;
@@ -315,10 +414,15 @@ export class FeishuHarnessBridge {
   #cardKeys = new Map();
   /** The global event-mux watcher (one per bridge). */
   #eventWatcher = null;
-  /** Serializes live completions and reconnect compensation. */
-  #eventTail = Promise.resolve();
+  /** Serializes completion work per session without blocking unrelated sessions. */
+  #eventTails = new Map();
+  /** Coalesces baseline compensation and records whether a trailing pass is needed. */
+  #pendingCompensations = new Map();
+  /** Bounded live arrivals bridge target-list, persistence, and history-projection races. */
+  #observedCompletionEvents = new Map();
   /** Earliest completion that still needs delivery for each watch. */
   #failedWatchSeqs = new Map();
+  #cardDataTimeoutMs;
 
   constructor({
     client,
@@ -335,6 +439,7 @@ export class FeishuHarnessBridge {
     repairOwnerOpenIds,
     repairPollIntervalMs = REPAIR_POLL_INTERVAL_MS,
     repairLinkWaitMs = REPAIR_LINK_WAIT_MS,
+    cardDataTimeoutMs = CARD_DATA_TIMEOUT_MS,
     replyTimeoutMs = 600_000,
     logger = console,
     signal,
@@ -353,8 +458,9 @@ export class FeishuHarnessBridge {
       }
     }
     if (!Number.isFinite(repairPollIntervalMs) || repairPollIntervalMs <= 0
-      || !Number.isFinite(repairLinkWaitMs) || repairLinkWaitMs <= 0) {
-      throw new TypeError('Feishu repair timing values must be positive numbers');
+      || !Number.isFinite(repairLinkWaitMs) || repairLinkWaitMs <= 0
+      || !Number.isFinite(cardDataTimeoutMs) || cardDataTimeoutMs <= 0) {
+      throw new TypeError('Feishu timing values must be positive numbers');
     }
     this.#client = client;
     this.#channel = channel;
@@ -373,6 +479,7 @@ export class FeishuHarnessBridge {
     );
     this.#repairPollIntervalMs = repairPollIntervalMs;
     this.#repairLinkWaitMs = repairLinkWaitMs;
+    this.#cardDataTimeoutMs = cardDataTimeoutMs;
     this.#replyTimeoutMs = replyTimeoutMs;
     this.#logger = logger;
     this.#approvals = new HarnessApprovalQueue({ label: 'Feishu', logger });
@@ -435,6 +542,21 @@ export class FeishuHarnessBridge {
     const processingReaction = this.#addReaction(messageId, 'OnIt');
     const commandMessage = extractInboundMessage(event, this.#client);
     const commandText = nonEmptyString(commandMessage.content) ?? '';
+    // Card commands (/m, /help, /status, etc.) bypass the queue so they
+    // respond immediately even when a harness task is still streaming.
+    if (CARD_COMMAND.test(commandText)) {
+      const processing = Promise.resolve()
+        .then(() => this.#handle(event, key, { alreadyRecorded: false }))
+        .then(() => this.#finishReaction(messageId, processingReaction, 'DONE'))
+        .catch((error) => this.#handleMessageFailure(
+          event,
+          messageId,
+          processingReaction,
+          error,
+        ))
+        .finally(() => this.#acceptedMessageIds.delete(messageId));
+      return processing;
+    }
     const commandRunner = hasInboundFiles(commandMessage) ? null : isControlCommand(commandText)
       ? runControlCommand
       : (isModelCommand(commandText)
@@ -621,15 +743,39 @@ export class FeishuHarnessBridge {
   }
 
   async waitForIdle() {
-    await Promise.allSettled([
-      ...this.#queues.values(),
-      ...[...this.#pendingInteractions.values()].flatMap((pending) => (
-        pending.queue ? [pending.queue] : []
-      )),
-      ...this.#interactionTasks,
-      ...this.#commandTasks,
-      this.#eventTail,
-    ]);
+    // Drain to a fixed point: awaited work can register compensation or
+    // another serialized tail before it settles.
+    for (;;) {
+      const tasks = [
+        ...this.#queues.values(),
+        ...[...this.#pendingInteractions.values()].flatMap((pending) => (
+          pending.queue ? [pending.queue] : []
+        )),
+        ...this.#interactionTasks,
+        ...this.#commandTasks,
+        ...this.#cardActionTasks,
+        ...this.#eventTails.values(),
+        ...[...this.#pendingCompensations.values()].map((pending) => pending.promise),
+      ];
+      if (tasks.length === 0) return;
+      await Promise.allSettled(tasks);
+      if (this.#queues.size === 0
+        && this.#interactionTasks.size === 0
+        && this.#commandTasks.size === 0
+        && this.#cardActionTasks.size === 0
+        && this.#eventTails.size === 0
+        && this.#pendingCompensations.size === 0
+        && ![...this.#pendingInteractions.values()].some((pending) => pending.queue)) return;
+    }
+  }
+
+  #cardDataSignal() {
+    const timeout = AbortSignal.timeout(this.#cardDataTimeoutMs);
+    return this.#signal ? AbortSignal.any([this.#signal, timeout]) : timeout;
+  }
+
+  #hasPendingInteraction(key) {
+    return this.#pendingInteractions.has(key) || this.#approvals.hasPending(key);
   }
 
   async #processFastCommand(event, messageId, key, message, runner) {
@@ -647,8 +793,7 @@ export class FeishuHarnessBridge {
         signal: this.#signal,
         hasImages: hasInboundImages(message),
         hasFiles: hasInboundFiles(message),
-        pendingInteraction: this.#pendingInteractions.has(key)
-          || this.#approvals.hasPending(key),
+        pendingInteraction: this.#hasPendingInteraction(key),
         control: { owner: this, key },
       },
     );
@@ -689,22 +834,35 @@ export class FeishuHarnessBridge {
       return;
     }
     if (commandText === '/help') {
-      await this.#send(event.message.chat_id, helpText());
+      await this.#send(event.message.chat_id, menuHelpText());
       return;
     }
     if (MENU_COMMAND.test(commandText)) {
-      this.#rememberMenu(key, { kind: 'menu', chatId: event.message.chat_id });
-      await this.#sendCard(event.message.chat_id, menuCard(), { key });
+      await this.#sendMenuCard(key, event.message.chat_id);
       return;
     }
     if (commandText === '/new') {
+      if (this.#queues.has(key) || this.#hasPendingInteraction(key)) {
+        await this.#send(
+          event.message.chat_id,
+          t('当前任务仍在运行，请先停止任务或等待任务完成后再开启新会话。'),
+        );
+        return;
+      }
       await this.#state.clearSession(key);
       await this.#send(event.message.chat_id, t('已开启全新 Harness 会话。'));
+      await this.#sendMenuCard(key, event.message.chat_id);
       return;
     }
     if (commandText === '/status') {
-      await this.#harness.ensureRunning({ signal: this.#signal });
-      await this.#send(event.message.chat_id, t('飞书机器人与 DeepSeek Harness 连接正常。'));
+      await this.#showStatusText(key, event.message.chat_id);
+      return;
+    }
+    if (commandText === '/compact') {
+      const compactCommand = await runCompactCommand(commandText, this.#harness, this.#state, key, { signal: this.#signal });
+      if (compactCommand) {
+        await this.#send(event.message.chat_id, compactCommand.message);
+      }
       return;
     }
     if (SESSION_LIST_PREFIX.test(commandText)) {
@@ -1124,77 +1282,477 @@ export class FeishuHarnessBridge {
       // Keep accepting the legacy nested shape while preferring the current
       // card.action.trigger v2 payload used by the official SDK.
       ?? nonEmptyString(event?.operator?.operator_id?.open_id)
-      ?? nonEmptyString(event?.operator?.operator_id?.user_id);
+      ?? nonEmptyString(event?.operator?.operator_id?.user_id)
+      ?? nonEmptyString(event?.open_id)
+      ?? nonEmptyString(event?.user_id);
     const operatorAllowed = operatorOpenId !== null
       && (this.#allowedSenderOpenIds.has('*') || this.#allowedSenderOpenIds.has(operatorOpenId));
     if (!operatorAllowed) {
       this.#logger.warn?.('[dsh-feishu] ignoring card action from an unallowed sender');
       return Promise.resolve();
     }
-    const action = typeof event?.action?.value?.action === 'string'
-      ? event.action.value.action
-      : null;
+    const actionValue = callbackObject(event?.action?.value);
+    const formValue = callbackObject(event?.action?.form_value);
+    const action = nonEmptyString(actionValue.action)
+      ?? nonEmptyString(event?.action?.action);
     if (!action) return Promise.resolve();
-    const messageId = nonEmptyString(event?.context?.open_message_id);
-    const entry = messageId ? this.#cardKeys.get(messageId) : null;
-    if (!entry) {
+    // select_static dropdown: resolve pickers to their target actions
+    const option = callbackSingleOption(event?.action?.option)
+      ?? (action.endsWith('_pick') ? callbackMultiOptionValues(event?.action?.options)[0] : null);
+    // The official Card 2.0 callback currently uses a comma-separated string
+    // for multi-select values; older SDKs emitted arrays or value objects.
+    const multiValues = [...new Set([
+      ...callbackMultiOptionValues(actionValue.options),
+      ...callbackMultiOptionValues(event?.action?.options),
+      ...callbackMultiOptionValues(formValue[action]),
+      ...(action === 'watch_add' || action === 'watch_remove'
+        ? callbackMultiOptionValues(event?.action?.option)
+        : []),
+    ])];
+    const resolvedAction = action === 'workspace_pick' && typeof option === 'string'
+      ? `workspace:${option}`
+      : action === 'session_pick' && typeof option === 'string'
+        ? `use:${option}`
+        : action === 'preset_pick' && typeof option === 'string'
+          ? `preset:select:${option}`
+          : action === 'model_pick' && typeof option === 'string'
+            ? `model:select:${option}`
+            : action === 'archive_pick' && typeof option === 'string'
+              ? `archive:${option}`
+              : action === 'steer_pick' && typeof option === 'string'
+                ? `steer:${option}`
+                : action;
+    const messageId = nonEmptyString(event?.context?.open_message_id)
+      ?? nonEmptyString(event?.open_message_id)
+      ?? nonEmptyString(event?.message_id);
+    const route = messageId ? this.#cardKeys.get(messageId) : null;
+    if (!route) {
       // The card predates this process (the in-memory mapping resets on
       // restart) or never came from us: nudge instead of staying silent.
-      const chatId = nonEmptyString(event?.context?.open_chat_id);
+      const chatId = nonEmptyString(event?.context?.open_chat_id)
+        ?? nonEmptyString(event?.open_chat_id)
+        ?? nonEmptyString(event?.chat_id);
       if (chatId) {
         this.#send(chatId, t('这个菜单已过期，请回复 /m 重新打开。')).catch(() => undefined);
       }
       return Promise.resolve();
     }
-    // The promise is returned so tests (and future callers) can await the
-    // action; the runtime dispatcher ignores it.
-    return this.#handleCardAction(action, entry).catch((error) => {
-      this.#logger.warn?.('[dsh-feishu] card action failed:', error.message);
+    // A used card is recent even if it was first created long ago.
+    this.#cardKeys.delete(messageId);
+    this.#cardKeys.set(messageId, route);
+    const entry = { ...route, messageId, selections: multiValues, operatorOpenId };
+    const source = nonEmptyString(actionValue.source);
+    const formText = nonEmptyString(formValue.steer_text);
+    const eventId = nonEmptyString(event?.event_id)
+      ?? nonEmptyString(event?.header?.event_id)
+      ?? nonEmptyString(event?.uuid)
+      ?? nonEmptyString(event?.header?.uuid);
+    const identity = JSON.stringify({
+      messageId,
+      resolvedAction,
+      option,
+      multiValues,
+      source,
+      formText,
+    });
+    const isStop = resolvedAction === 'stop';
+    const rawSteer = resolvedAction.startsWith('steer:')
+      ? resolvedAction.slice('steer:'.length)
+      : null;
+    const isCustomSteer = rawSteer === 'custom' || rawSteer === STEER_CUSTOM_SENTINEL;
+    const isRealSteer = (action === 'steer'
+      && source === 'quick'
+      && option !== null
+      && option !== STEER_CUSTOM_SENTINEL)
+      || (action === 'steer' && source === 'form' && formText !== null)
+      || (rawSteer !== null && rawSteer !== '' && !isCustomSteer);
+
+    return this.#queueCardAction(entry, identity, async () => {
+      // 补充指令卡片：快捷下拉(source=quick, option=指令) / 表单提交(source=form)
+      if (action === 'steer') {
+        if (source === 'quick' && option) {
+          if (option === STEER_CUSTOM_SENTINEL) {
+            await this.#sendCard(entry.chatId, customSteerCard(), {
+              key: entry.key,
+              updateMessageId: entry.messageId,
+            });
+            return;
+          }
+          await this.#sendSteer(entry, option);
+          return;
+        }
+        if (source === 'form') {
+          if (formText) {
+            await this.#sendSteer(entry, formText);
+            return;
+          }
+          await this.#send(entry.chatId, t('请输入补充指令后再提交。'));
+          return;
+        }
+      }
+      await this.#handleCardAction(resolvedAction, entry);
+    }, {
+      lane: isStop || isRealSteer ? 'control' : 'regular',
+      coalesceStop: isStop,
+      eventId,
+      operatorOpenId,
     });
   }
 
-  async #handleCardAction(action, { chatId, key, sessionWorkspace = null }) {
+  #pruneCompletedCardActions(now = Date.now()) {
+    for (const [key, expiresAt] of this.#completedCardActions) {
+      if (expiresAt <= now) this.#completedCardActions.delete(key);
+    }
+    while (this.#completedCardActions.size > MAX_COMPLETED_CARD_ACTIONS) {
+      const oldest = this.#completedCardActions.keys().next().value;
+      if (oldest === undefined) break;
+      this.#completedCardActions.delete(oldest);
+    }
+  }
+
+  #rememberCompletedCardAction(key, now = Date.now()) {
+    if (!key) return;
+    this.#completedCardActions.delete(key);
+    this.#completedCardActions.set(key, now + CARD_ACTION_DEDUPE_TTL_MS);
+    this.#pruneCompletedCardActions(now);
+  }
+
+  #notifyCardOverflow(entry) {
+    const conversation = entry.key;
+    const now = Date.now();
+    const existing = this.#cardOverloadNoticeAt.get(conversation);
+    if (existing?.task || (existing && now - existing.at < CARD_OVERLOAD_NOTICE_COOLDOWN_MS)) {
+      return existing?.task ?? Promise.resolve();
+    }
+    this.#logger.warn?.('[dsh-feishu] card action queue is full; dropping callbacks');
+    let tracked;
+    tracked = this.#send(entry.chatId, t('操作过于频繁，请稍后再试。'))
+      .catch(() => undefined)
+      .finally(() => {
+        this.#cardActionTasks.delete(tracked);
+        const current = this.#cardOverloadNoticeAt.get(conversation);
+        if (current?.task === tracked) this.#cardOverloadNoticeAt.set(conversation, { at: current.at, task: null });
+      });
+    this.#cardOverloadNoticeAt.delete(conversation);
+    this.#cardOverloadNoticeAt.set(conversation, { at: now, task: tracked });
+    this.#cardActionTasks.add(tracked);
+    while (this.#cardOverloadNoticeAt.size > 200) {
+      const oldest = this.#cardOverloadNoticeAt.keys().next().value;
+      if (oldest === undefined) break;
+      this.#cardOverloadNoticeAt.delete(oldest);
+    }
+    return tracked;
+  }
+
+  #queueCardAction(entry, identity, task, {
+    lane = 'regular',
+    coalesceStop = false,
+    eventId = null,
+    operatorOpenId = null,
+  } = {}) {
+    const conversation = entry.key;
+    const completedKey = eventId
+      ? `${conversation}\0${operatorOpenId ?? ''}\0event:${eventId}`
+      : null;
+    const dedupeKey = completedKey
+      ?? `${conversation}\0${operatorOpenId ?? ''}\0action:${identity}`;
+    const now = Date.now();
+    this.#pruneCompletedCardActions(now);
+    if (completedKey && (this.#completedCardActions.get(completedKey) ?? 0) > now) {
+      return Promise.resolve();
+    }
+    const duplicate = this.#cardActionInFlight.get(dedupeKey);
+    if (duplicate) return duplicate;
+    if (coalesceStop) {
+      const pendingStop = this.#cardStopInFlight.get(conversation);
+      if (pendingStop) {
+        if (completedKey) {
+          // Remember only a bounded LRU of provider ids while the shared stop
+          // is unresolved. They become completed only after that stop settles.
+          this.#cardStopFollowers.delete(completedKey);
+          this.#cardStopFollowers.set(completedKey, pendingStop);
+          while (this.#cardStopFollowers.size > MAX_COMPLETED_CARD_ACTIONS) {
+            const oldest = this.#cardStopFollowers.keys().next().value;
+            if (oldest === undefined) break;
+            this.#cardStopFollowers.delete(oldest);
+          }
+        }
+        return pendingStop;
+      }
+    }
+
+    const control = lane === 'control';
+    const tails = control ? this.#cardControlTails : this.#cardActionTails;
+    const counts = control ? this.#cardControlCounts : this.#cardActionCounts;
+    const limit = control ? MAX_PENDING_CARD_CONTROLS_PER_KEY : MAX_PENDING_CARD_ACTIONS_PER_KEY;
+    const pending = counts.get(conversation) ?? 0;
+    // Reserve one bounded control slot for stop. All further stop clicks join
+    // that task, so a flood cannot grow the queue beyond limit + 1.
+    const pendingLimit = coalesceStop ? limit + 1 : limit;
+    if (pending >= pendingLimit) {
+      return this.#notifyCardOverflow(entry);
+    }
+
+    const previous = tails.get(conversation) ?? Promise.resolve();
+    counts.set(conversation, pending + 1);
+
+    let tracked;
+    let started = false;
+    tracked = previous
+      .catch(() => undefined)
+      .then(async () => {
+        this.#signal?.throwIfAborted();
+        started = true;
+        await task();
+      })
+      .catch(async (error) => {
+        if (this.#signal?.aborted) return;
+        this.#logger.warn?.('[dsh-feishu] card action failed:', error?.message ?? String(error));
+        this.#status.lastError = error?.message ?? String(error);
+        await this.#send(entry.chatId, t('卡片操作失败，请稍后重试。')).catch(() => undefined);
+      })
+      .finally(() => {
+        if (this.#cardActionInFlight.get(dedupeKey) === tracked) {
+          this.#cardActionInFlight.delete(dedupeKey);
+        }
+        if (started && completedKey) {
+          this.#rememberCompletedCardAction(completedKey);
+        }
+        if (coalesceStop && this.#cardStopInFlight.get(conversation) === tracked) {
+          this.#cardStopInFlight.delete(conversation);
+        }
+        if (coalesceStop) {
+          const settledAt = Date.now();
+          for (const [followerKey, pendingStop] of this.#cardStopFollowers) {
+            if (pendingStop !== tracked) continue;
+            this.#cardStopFollowers.delete(followerKey);
+            this.#rememberCompletedCardAction(followerKey, settledAt);
+          }
+        }
+        if (tails.get(conversation) === tracked) tails.delete(conversation);
+        const remaining = (counts.get(conversation) ?? 1) - 1;
+        if (remaining > 0) counts.set(conversation, remaining);
+        else counts.delete(conversation);
+        this.#cardActionTasks.delete(tracked);
+      });
+    this.#cardActionInFlight.set(dedupeKey, tracked);
+    if (coalesceStop) this.#cardStopInFlight.set(conversation, tracked);
+    this.#cardActionTasks.add(tracked);
+    tails.set(conversation, tracked);
+    return tracked;
+  }
+
+  async #handleCardAction(action, {
+    chatId,
+    key,
+    messageId = null,
+    sessionWorkspace = null,
+    sessionPage = 0,
+    selections = [],
+  }) {
     if (action === 'sessions' || /^sessions:\d+$/.test(action)) {
       const page = action === 'sessions' ? 0 : Number(action.slice('sessions:'.length));
-      await this.#showSessions({ chatId, key }, sessionWorkspace, page);
+      await this.#showSessions(
+        { chatId, key },
+        sessionWorkspace,
+        page,
+        { updateMessageId: messageId },
+      );
       return;
     }
     if (action === 'workspaces') {
-      await this.#showWorkspaces({ chatId, key });
+      await this.#showWorkspaces({ chatId, key }, { updateMessageId: messageId });
       return;
     }
     if (action === 'watchlist') {
-      await this.#showWatchList(key, chatId);
+      await this.#showWatchList(key, chatId, { updateMessageId: messageId });
+      return;
+    }
+    // 多选关注下拉：action=watch_add / watch_remove，选中项在 selections 数组
+    if (action === 'watch_add' || action === 'watch_remove') {
+      if (selections.length === 0) {
+        await this.#send(chatId, t('请先选择至少一个会话。'));
+        return;
+      }
+      let changed = 0;
+      let failed = 0;
+      if (action === 'watch_add') {
+        let freshTargets = new Map();
+        try {
+          freshTargets = await this.#freshWatchTargets(sessionWorkspace);
+        } catch (error) {
+          this.#logger.warn?.('[dsh-feishu] batch watch validation failed:', error.message);
+        }
+        for (const sessionId of selections) {
+          const validatedTarget = freshTargets.get(sessionId);
+          if (!validatedTarget) {
+            failed += 1;
+            continue;
+          }
+          const result = await this.#runWatch(key, chatId, sessionId, {
+            notify: false,
+            validatedTarget,
+          });
+          if (result.changed) changed += 1;
+          else if (!result.ok) failed += 1;
+        }
+      } else {
+        for (const sessionId of selections) {
+          const result = await this.#runUnwatch(key, chatId, sessionId, { notify: false });
+          if (result.changed) changed += 1;
+          else if (!result.ok) failed += 1;
+        }
+      }
+      const summary = changed > 0 && failed > 0
+        ? action === 'watch_add'
+          ? t('已批量关注 {count} 个会话，另有 {failed} 个未成功。', { count: changed, failed })
+          : t('已取消关注 {count} 个会话，另有 {failed} 个未成功。', { count: changed, failed })
+        : changed > 0
+          ? action === 'watch_add'
+            ? t('已批量关注 {count} 个会话。', { count: changed })
+            : t('已取消关注 {count} 个会话。', { count: changed })
+          : failed > 0
+            ? t('所选会话均未处理成功，请稍后重试。')
+            : action === 'watch_add'
+              ? t('所选会话已在关注列表中。')
+              : t('所选会话已不在关注列表中。');
+      try {
+        await this.#showWatchList(key, chatId, { updateMessageId: messageId });
+      } catch (error) {
+        this.#logger.warn?.('[dsh-feishu] watch list refresh failed:', error.message);
+      }
+      await this.#send(chatId, summary).catch((error) => {
+        this.#logger.warn?.('[dsh-feishu] watch batch summary failed:', error.message);
+      });
       return;
     }
     if (action === 'new') {
+      if (this.#queues.has(key) || this.#hasPendingInteraction(key)) {
+        await this.#send(chatId, t('当前任务仍在运行，请先停止任务或等待任务完成后再开启新会话。'));
+        return;
+      }
       await this.#state.clearSession(key);
       await this.#send(chatId, t('已开启全新 Harness 会话。'));
+      await this.#sendMenuCard(key, chatId, { updateMessageId: messageId });
+      return;
+    }
+    if (action === 'use:current') {
+      const sessionId = this.#state.sessionFor(key);
+      if (typeof sessionId !== 'string' || !sessionId) {
+        await this.#send(chatId, t('当前没有绑定的会话，请先从会话列表选择。'));
+        return;
+      }
+      await this.#send(chatId, t('已就绪，直接发消息即可继续当前会话。'));
+      return;
+    }
+    if (action === 'archive_toggle' || action === 'archive:on' || action === 'archive:off') {
+      const next = action === 'archive:on' ? true : action === 'archive:off' ? false : !(this.#state?.includesArchivedSessions?.() ?? false);
+      await this.#state?.setIncludeArchivedSessions?.(next);
+      await this.#send(
+        chatId,
+        next ? t('已开启：会话列表包含归档会话。') : t('已关闭：会话列表隐藏归档会话。'),
+      );
+      await this.#sendMenuCard(key, chatId, { updateMessageId: messageId });
+      return;
+    }
+    if (action === 'repair') {
+      await this.#send(chatId, t('修复需在私聊中验证接入者身份，请直接发送 /repair 开始。'));
+      return;
+    }
+    if (action === 'compact') {
+      await this.#handleCompact(key, chatId);
+      return;
+    }
+    if (action === 'stop') {
+      await this.#handleStop(key, chatId);
+      return;
+    }
+    if (action === 'steer') {
+      await this.#showSteerCard(key, chatId, { updateMessageId: messageId });
+      return;
+    }
+    // 主菜单「补充指令」下拉：option = steer:<指令> / steer:custom
+    if (action.startsWith('steer:')) {
+      const raw = action.slice('steer:'.length);
+      if (raw === 'custom') {
+        await this.#sendCard(chatId, customSteerCard(), { key, updateMessageId: messageId });
+        return;
+      }
+      await this.#sendSteer({ key, chatId }, raw);
+      return;
+    }
+    if (action === 'presets') {
+      await this.#showPresetCard(key, chatId, { updateMessageId: messageId });
+      return;
+    }
+    if (action === 'models') {
+      await this.#showModelCard(key, chatId, { updateMessageId: messageId });
       return;
     }
     if (action === 'status') {
-      await this.#harness.ensureRunning({ signal: this.#signal });
-      await this.#send(chatId, t('飞书机器人与 DeepSeek Harness 连接正常。'));
+      await this.#showStatusCard(key, chatId, { updateMessageId: messageId });
       return;
     }
     if (action === 'help') {
-      await this.#send(chatId, menuHelpText());
+      await this.#showHelpCard(key, chatId, { updateMessageId: messageId });
+      return;
+    }
+    if (action === 'back_to_menu') {
+      await this.#sendMenuCard(key, chatId, { updateMessageId: messageId });
+      return;
+    }
+    if (action === 'preset_default') {
+      await this.#handlePresetDefault(key, chatId, { updateMessageId: messageId });
+      return;
+    }
+    if (action.startsWith('preset:select:')) {
+      const presetId = action.slice('preset:select:'.length);
+      // 哨兵值 = 用户在预设下拉里选了「跟随默认」
+      if (presetId === PRESET_FOLLOW_DEFAULT_SENTINEL) {
+        await this.#handlePresetDefault(key, chatId, { updateMessageId: messageId });
+        return;
+      }
+      await this.#handlePresetSelect(key, chatId, presetId, { updateMessageId: messageId });
+      return;
+    }
+    if (action.startsWith('model:select:')) {
+      const modelId = action.slice('model:select:'.length);
+      await this.#handleModelSelect(key, chatId, modelId, { updateMessageId: messageId });
       return;
     }
     if (action.startsWith('use:')) {
-      await this.#bindSession(key, chatId, action.slice('use:'.length));
+      await this.#bindSession(key, chatId, action.slice('use:'.length), { updateMessageId: messageId });
       return;
     }
     if (action.startsWith('workspace:')) {
-      await this.#switchWorkspace(key, chatId, action.slice('workspace:'.length));
+      await this.#switchWorkspace(key, chatId, action.slice('workspace:'.length), { updateMessageId: messageId });
       return;
     }
     if (action.startsWith('unwatch:')) {
-      await this.#runUnwatch(key, chatId, action.slice('unwatch:'.length));
+      const result = await this.#runUnwatch(key, chatId, action.slice('unwatch:'.length));
+      if (result.ok && messageId) {
+        await this.#showSessions(
+          { chatId, key },
+          sessionWorkspace,
+          sessionPage,
+          { updateMessageId: messageId },
+        );
+      }
       return;
     }
     if (action.startsWith('watch:')) {
-      await this.#runWatch(key, chatId, action.slice('watch:'.length));
+      const sessionId = action.slice('watch:'.length);
+      const result = await this.#runWatch(key, chatId, sessionId, {
+        workspaceHint: sessionWorkspace,
+      });
+      if (result.ok && messageId) {
+        await this.#showSessions(
+          { chatId, key },
+          sessionWorkspace,
+          sessionPage,
+          { updateMessageId: messageId },
+        );
+      }
     }
   }
 
@@ -1219,7 +1777,10 @@ export class FeishuHarnessBridge {
 
   async #handleMenuPick(menu, number, { chatId, key, event }) {
     if (menu.kind === 'menu') {
-      const action = ['sessions', 'workspaces', 'new', 'status', 'help', 'repair', 'watchlist'][number - 1];
+      // Number fallback for the total menu:
+      // 1=工作区列表 2=新会话 3=会话列表 4=状态 5=修复 6=帮助
+      const actions = ['workspaces', 'new', 'sessions', 'status', 'repair', 'help'];
+      const action = actions[number - 1];
       if (!action) {
         await this.#send(chatId, t('菜单没有这个编号，回复 /m 重新打开。'));
         return;
@@ -1268,14 +1829,20 @@ export class FeishuHarnessBridge {
     return sessions;
   }
 
-  async #showSessions({ chatId, key }, selector, page = 0) {
+  async #showSessions(
+    { chatId, key },
+    selector,
+    page = 0,
+    { updateMessageId = null } = {},
+  ) {
     try {
-      const resolved = await resolveSessionListWorkspace(selector ?? '', this.#harness);
+      const signal = this.#cardDataSignal();
+      const resolved = await resolveSessionListWorkspace(selector ?? '', this.#harness, { signal });
       if (resolved.error) {
         await this.#send(chatId, resolved.error);
         return;
       }
-      const listed = await this.#harness.listWorkspaceSessions(resolved.workspace);
+      const listed = await this.#harness.listWorkspaceSessions(resolved.workspace, { signal });
       const sessions = this.#visibleSessions(Array.isArray(listed?.sessions) ? listed.sessions : []);
       const workspace = listed?.workspace ?? resolved.workspace;
       if (sessions.length === 0) {
@@ -1297,9 +1864,11 @@ export class FeishuHarnessBridge {
         sessionListCard(workspace, sessions, safePage, sessions.length, watchedSet),
         {
           key,
+          updateMessageId,
           // Keep the canonical selector result for later page callbacks. The
           // list response's workspace is display data and is not authoritative.
           sessionWorkspace: resolved.workspace,
+          sessionPage: safePage,
         },
       );
     } catch (error) {
@@ -1308,37 +1877,83 @@ export class FeishuHarnessBridge {
     }
   }
 
-  async #showWorkspaces({ chatId, key }) {
+  async #showWorkspaces({ chatId, key }, { updateMessageId = null } = {}) {
     try {
-      const { current, paths } = await workspacePathSnapshot(this.#harness);
+      const { current, paths } = await workspacePathSnapshot(
+        this.#harness,
+        { signal: this.#cardDataSignal() },
+      );
       this.#rememberMenu(key, { kind: 'workspaces', paths });
-      await this.#sendCard(chatId, workspaceListCard(paths, current), { key });
+      await this.#sendCard(
+        chatId,
+        workspaceListCard(paths, current),
+        { key, updateMessageId },
+      );
     } catch (error) {
       this.#logger.warn?.('[dsh-feishu] workspace list failed:', error.message);
       await this.#send(chatId, t('暂时无法获取工作区列表，请稍后重试。'));
     }
   }
 
-  async #bindSession(key, chatId, sessionId) {
+  async #bindSession(key, chatId, sessionId, { updateMessageId = null } = {}) {
     try {
       const bound = await this.#harness.bindWorkspaceSession(key, sessionId);
       const title = String(bound?.title ?? '').replace(/\s+/gu, ' ').trim() || t('暂无标题');
       await this.#send(chatId, t('已绑定会话「{title}」\nID：{id}', { title, id: bound?.sessionId ?? sessionId }));
+      await this.#sendMenuCard(key, chatId, { updateMessageId });
     } catch (error) {
       await this.#send(chatId, t('绑定失败：{message}', { message: safeErrorText(error) }));
     }
   }
 
-  async #switchWorkspace(key, chatId, workspace) {
+  async #switchWorkspace(key, chatId, workspace, { updateMessageId = null } = {}) {
     try {
       const current = await this.#harness.switchWorkspace(workspace);
       await this.#send(chatId, t('工作区已切换为：{workspace}', { workspace: current }));
+      await this.#sendMenuCard(key, chatId, { updateMessageId });
     } catch (error) {
       await this.#send(chatId, t('切换失败：{message}', { message: safeErrorText(error) }));
     }
   }
 
+  #rememberCardRoute(messageId, chatId, options) {
+    if (!options.key || !messageId) return;
+    this.#cardKeys.delete(messageId);
+    this.#cardKeys.set(messageId, {
+      key: options.key,
+      chatId,
+      sessionWorkspace: typeof options.sessionWorkspace === 'string' && options.sessionWorkspace
+        ? options.sessionWorkspace
+        : null,
+      sessionPage: Number.isSafeInteger(options.sessionPage) && options.sessionPage >= 0
+        ? options.sessionPage
+        : 0,
+    });
+    if (this.#cardKeys.size > 200) {
+      const oldest = this.#cardKeys.keys().next().value;
+      if (oldest !== undefined) this.#cardKeys.delete(oldest);
+    }
+  }
+
   async #sendCard(chatId, cardJson, options = {}) {
+    const updateMessageId = nonEmptyString(options.updateMessageId);
+
+    if (updateMessageId) {
+      try {
+        const response = await this.#client.im.v1.message.patch({
+          path: { message_id: updateMessageId },
+          data: { content: cardJson },
+        });
+        if (response?.code && response.code !== 0) {
+          throw new Error(`Feishu card update failed: ${response.msg || response.code}`);
+        }
+        this.#rememberCardRoute(updateMessageId, chatId, options);
+        return updateMessageId;
+      } catch (error) {
+        this.#logger.warn?.('[dsh-feishu] card update failed:', error?.code ?? error?.message ?? error, 'sending new');
+      }
+    }
+
     const response = await this.#client.im.v1.message.create({
       params: { receive_id_type: 'chat_id' },
       data: { receive_id: chatId, msg_type: 'interactive', content: cardJson },
@@ -1347,20 +1962,420 @@ export class FeishuHarnessBridge {
       throw new Error(`Feishu card send failed: ${response.msg || response.code}`);
     }
     const messageId = nonEmptyString(response?.data?.message_id);
-    if (options.key && messageId) {
-      this.#cardKeys.set(messageId, {
-        key: options.key,
-        chatId,
-        sessionWorkspace: typeof options.sessionWorkspace === 'string' && options.sessionWorkspace
-          ? options.sessionWorkspace
-          : null,
+    this.#rememberCardRoute(messageId, chatId, options);
+    return messageId;
+  }
+
+  async #sendMenuCard(key, chatId, { updateMessageId = null } = {}) {
+    let currentSessionId = null;
+    let directSessionTitle = null;
+    try {
+      const sessionId = this.#state.sessionFor(key);
+      if (typeof sessionId === 'string' && sessionId) {
+        currentSessionId = sessionId;
+        const session = this.#harness.workspaceSession?.(sessionId);
+        directSessionTitle = nonEmptyString(session?.title)
+          ?? nonEmptyString(session?.name)
+          ?? nonEmptyString(session?.displayName);
+      }
+    } catch { /* render without a selected session */ }
+
+    const dataSignal = this.#cardDataSignal();
+    // Independent sections start together. Each one degrades on its own so a
+    // slow preset/model RPC cannot force redundant session-list scans.
+    const workspaceTask = workspacePathSnapshot(this.#harness, { signal: dataSignal })
+      .catch(() => {
+        const current = typeof this.#harness.currentWorkspace === 'function'
+          ? this.#harness.currentWorkspace()
+          : null;
+        return { current, paths: current ? [current] : [] };
       });
-      if (this.#cardKeys.size > 200) {
-        const oldest = this.#cardKeys.keys().next().value;
-        if (oldest !== undefined) this.#cardKeys.delete(oldest);
+    const sessionTask = (async () => {
+      const current = typeof this.#harness.currentWorkspace === 'function'
+        ? this.#harness.currentWorkspace()
+        : null;
+      if (!current || typeof this.#harness.listWorkspaceSessions !== 'function') return [];
+      try {
+        const listed = await this.#harness.listWorkspaceSessions(current, { signal: dataSignal });
+        return this.#visibleSessions(Array.isArray(listed?.sessions) ? listed.sessions : []);
+      } catch {
+        return [];
+      }
+    })();
+    const presetTask = (async () => {
+      try {
+        const settings = await this.#harness.agentPresetSettings({ signal: dataSignal });
+        return { ...settings.agentPresetCatalog, _currentId: settings.agentPreset };
+      } catch {
+        return null;
+      }
+    })();
+    const modelTask = (async () => {
+      try {
+        if (currentSessionId) {
+          const session = this.#harness.workspaceSession?.(currentSessionId);
+          if (typeof session?.models === 'function') {
+            return await session.models({ signal: dataSignal });
+          }
+        }
+        return await this.#harness.listModels({ signal: dataSignal });
+      } catch {
+        return null;
+      }
+    })();
+
+    const [snapshot, listedSessions, presetCatalog, modelCatalog] = await Promise.all([
+      workspaceTask,
+      sessionTask,
+      presetTask,
+      modelTask,
+    ]);
+    const workspaces = Array.isArray(snapshot.paths) ? snapshot.paths : [];
+    const currentWorkspace = snapshot.current ?? null;
+    const currentMatch = listedSessions.find((session) => session.sessionId === currentSessionId);
+    const currentSessionTitle = currentSessionId
+      ? nonEmptyString(currentMatch?.title)
+        ?? nonEmptyString(currentMatch?.name)
+        ?? directSessionTitle
+        ?? currentSessionId
+      : null;
+    let sessions = listedSessions
+      .map((session) => ({
+        id: session.sessionId,
+        title: session.title ?? session.name ?? session.sessionId,
+      }))
+      .slice(0, 20);
+    // 确保当前绑定会话始终出现在下拉最前（它可能不在最近列表里），
+    // 否则 initial_index 找不到默认展示项，下拉会显示占位文本。
+    if (currentSessionId) {
+      sessions = sessions.filter((s) => s.id !== currentSessionId);
+      sessions.unshift({ id: currentSessionId, title: currentSessionTitle ?? currentSessionId });
+      sessions = sessions.slice(0, 20);
+    }
+    const archiveVisible = this.#state?.includesArchivedSessions?.() ?? false;
+    this.#rememberMenu(key, { kind: 'menu', chatId });
+    await this.#sendCard(
+      chatId,
+      menuCard({
+        workspaces, currentWorkspace,
+        currentSession: currentSessionId ? { id: currentSessionId, title: currentSessionTitle } : null,
+        sessions, archiveVisible, presetCatalog, modelCatalog,
+      }),
+      { key, updateMessageId },
+    );
+  }
+
+  /**
+   * Resolve a human-readable title for a bound session when available.
+   * Attempts the workspace-session object first, then falls back to the
+   * current workspace's session list. Returns null on any failure.
+   */
+  async #resolveSessionTitle(key, sessionId) {
+    try {
+      if (typeof this.#harness.workspaceSession === 'function') {
+        const session = this.#harness.workspaceSession(sessionId);
+        if (session && typeof session === 'object') {
+          const direct = nonEmptyString(session.title)
+            ?? nonEmptyString(session.name)
+            ?? nonEmptyString(session.displayName);
+          if (direct) return direct;
+        }
+      }
+      // Fallback: scan the current workspace session list for this id
+      const current = typeof this.#harness.currentWorkspace === 'function'
+        ? this.#harness.currentWorkspace()
+        : null;
+      if (current && typeof this.#harness.listWorkspaceSessions === 'function') {
+        const listed = await this.#harness.listWorkspaceSessions(current);
+        const match = (Array.isArray(listed?.sessions) ? listed.sessions : [])
+          .find((s) => s.sessionId === sessionId);
+        if (match) {
+          const title = nonEmptyString(match.title) ?? nonEmptyString(match.name);
+          if (title) return title;
+        }
       }
+    } catch { /* best-effort */ }
+    return null;
+  }
+
+  // ── Sub-card handlers: preset, model, status, help, compact ──────────────
+
+  /**
+   * Fetch the preset catalog and show the preset selection card.
+   */
+  async #showPresetCard(key, chatId, { updateMessageId = null } = {}) {
+    try {
+      const settings = await this.#harness.agentPresetSettings({ signal: this.#cardDataSignal() });
+      const catalog = settings.agentPresetCatalog;
+      // Inject the current preset id so the card can render the selection
+      catalog._currentId = settings.agentPreset;
+      await this.#sendCard(chatId, presetCard(catalog), { key, updateMessageId });
+    } catch (error) {
+      this.#logger.warn?.('[dsh-feishu] preset card failed:', error.message);
+      await this.#send(chatId, t('暂时无法获取预设列表，请稍后重试。'));
+    }
+  }
+
+  /**
+   * Fetch the model catalog and show the model selection card.
+   */
+  async #showModelCard(key, chatId, { updateMessageId = null } = {}) {
+    try {
+      const signal = this.#cardDataSignal();
+      await this.#harness.ensureRunning({ signal });
+      // Try to get the session-bound catalog first, fall back to harness-level
+      const sessionId = this.#state?.sessionFor?.(key);
+      let catalog;
+      if (typeof sessionId === 'string' && sessionId) {
+        const session = this.#harness.workspaceSession(sessionId);
+        if (session?.models) {
+          catalog = await session.models({ signal });
+        }
+      }
+      if (!catalog) {
+        catalog = await this.#harness.listModels({ signal });
+      }
+      await this.#sendCard(chatId, modelCard(catalog), { key, updateMessageId });
+    } catch (error) {
+      this.#logger.warn?.('[dsh-feishu] model card failed:', error.message);
+      await this.#send(chatId, t('暂时无法获取模型列表，请稍后重试。'));
+    }
+  }
+
+  /**
+   * Gather system status and show the status card.
+   */
+  async #showStatusText(key, chatId) {
+    try {
+      await this.#harness.ensureRunning({ signal: this.#signal });
+      const lines = [t('连接正常')];
+      const ws = typeof this.#harness.currentWorkspace === 'function'
+        ? this.#harness.currentWorkspace()
+        : null;
+      if (ws) lines.push(t('工作区：{workspace}', { workspace: ws }));
+      const settings = typeof this.#harness.agentPresetSettings === 'function'
+        ? await this.#harness.agentPresetSettings({ signal: this.#signal }).catch(() => null)
+        : null;
+      if (settings) {
+        const item = settings.agentPresetCatalog?.items?.find((i) => i.id === settings.agentPreset);
+        lines.push(t('预设：{preset}', {
+          preset: item
+            ? `${item.label}（${item.id}）`
+            : (settings.agentPreset || t('跟随默认')),
+        }));
+      }
+      await this.#send(chatId, lines.join('\n'));
+    } catch (error) {
+      this.#logger.warn?.('[dsh-feishu] status text failed:', error.message);
+      await this.#send(chatId, t('暂时无法获取系统状态，请稍后重试。'));
+    }
+  }
+
+  async #showStatusCard(key, chatId, { updateMessageId = null } = {}) {
+    try {
+      const signal = this.#cardDataSignal();
+      await this.#harness.ensureRunning({ signal });
+      const info = { connected: true, workspace: null, preset: null, model: null, sessionCount: 0 };
+
+      // Current workspace
+      try {
+        const ws = typeof this.#harness.currentWorkspace === 'function'
+          ? this.#harness.currentWorkspace()
+          : null;
+        info.workspace = ws || t('未知');
+      } catch { /* ignore */ }
+
+      // Preset
+      try {
+        const settings = await this.#harness.agentPresetSettings({ signal });
+        const item = settings.agentPresetCatalog.items.find((i) => i.id === settings.agentPreset);
+        info.preset = item
+          ? `${item.label}（${item.id}）`
+          : (settings.agentPreset || t('跟随默认'));
+      } catch { /* ignore */ }
+
+      // Model (from bound session or harness)
+      try {
+        const sessionId = this.#state?.sessionFor?.(key);
+        if (typeof sessionId === 'string' && sessionId) {
+          const session = this.#harness.workspaceSession(sessionId);
+          if (session?.models) {
+            const cat = await session.models({ signal });
+            if (cat.current) info.model = `${cat.current.provider}/${cat.current.model}`;
+          }
+        }
+      } catch { /* ignore */ }
+
+      // Session count
+      try {
+        const ws = typeof this.#harness.currentWorkspace === 'function'
+          ? this.#harness.currentWorkspace()
+          : null;
+        if (ws) {
+          const listed = await this.#harness.listWorkspaceSessions(ws, { signal });
+          if (Array.isArray(listed?.sessions)) info.sessionCount = listed.sessions.length;
+        }
+      } catch { /* ignore */ }
+
+      await this.#sendCard(chatId, statusCard(info), { key, updateMessageId });
+    } catch (error) {
+      this.#logger.warn?.('[dsh-feishu] status card failed:', error.message);
+      await this.#send(chatId, t('暂时无法获取系统状态，请稍后重试。'));
+    }
+  }
+
+  /**
+   * Show the help card with all command descriptions.
+   */
+  async #showHelpCard(key, chatId, { updateMessageId = null } = {}) {
+    await this.#sendCard(
+      chatId,
+      helpCard(WORKSPACE_HELP_LINES.map((line) => t(line))),
+      { key, updateMessageId },
+    );
+  }
+
+  /**
+   * Run the /compact command and show the result.
+   */
+  async #handleCompact(key, chatId) {
+    try {
+      const result = await runCompactCommand(
+        '/compact', this.#harness, this.#state, key, { signal: this.#signal },
+      );
+      await this.#send(chatId, result?.message || t('上下文压缩失败。'));
+    } catch (error) {
+      this.#logger.warn?.('[dsh-feishu] compact failed:', error.message, error.code);
+      await this.#send(chatId, t('上下文压缩失败，请稍后重试。'));
+    }
+  }
+
+  /**
+   * Stop the running task in the bound session (mirrors `/stop`).
+   */
+  async #handleStop(key, chatId) {
+    try {
+      const result = await runControlCommand(
+        '/stop', this.#harness, this.#state, key, {
+          signal: this.#signal,
+          control: { owner: this, key },
+        },
+      );
+      if (result?.stopped) {
+        await Promise.allSettled([
+          this.#cancelPendingInteraction(key),
+          this.#approvals.closeRoute(key),
+        ]);
+      }
+      await this.#send(chatId, result?.message || t('/stop 执行完成。'));
+    } catch (error) {
+      this.#logger.warn?.('[dsh-feishu] stop failed:', error.message);
+      await this.#send(chatId, t('停止任务失败，请稍后重试。'));
+    }
+  }
+
+  /**
+   * Show the steer card (quick-select dropdown + free-text input).
+   */
+  async #showSteerCard(key, chatId, { updateMessageId = null } = {}) {
+    const hasSession = Boolean(this.#state.sessionFor?.(key));
+    this.#rememberMenu(key, { kind: 'steer' });
+    await this.#sendCard(chatId, steerCard({ hasSession }), { key, updateMessageId });
+  }
+
+  /**
+   * Send a steer instruction to the bound session (mirrors `/steer <text>`).
+   */
+  async #sendSteer(entry, text) {
+    const { key, chatId } = entry;
+    const result = await runControlCommand(
+      `/steer ${text}`, this.#harness, this.#state, key, {
+        signal: this.#signal,
+        pendingInteraction: this.#hasPendingInteraction(key),
+        control: { owner: this, key },
+      },
+    );
+    await this.#send(chatId, result?.message || t('已提交补充指令。'));
+  }
+
+  /**
+   * Reset the preset to follow the Host default.
+   */
+  async #handlePresetDefault(key, chatId, { updateMessageId = null } = {}) {
+    try {
+      const result = await runPresetCommand(
+        '/preset --default', this.#harness, this.#state, key, { signal: this.#signal },
+      );
+      for (const reply of result?.messages ?? [result?.message]) {
+        if (reply) await this.#send(chatId, reply);
+      }
+    } catch (error) {
+      this.#logger.warn?.('[dsh-feishu] preset default failed:', error.message);
+      await this.#send(chatId, t('预设重置失败，请稍后重试。'));
+      return;
+    }
+    try {
+      await this.#sendMenuCard(key, chatId, { updateMessageId });
+    } catch (error) {
+      this.#logger.warn?.('[dsh-feishu] menu refresh failed after preset reset:', error.message);
+    }
+  }
+
+  /**
+   * Handle preset selection from the preset dropdown.
+   */
+  async #handlePresetSelect(key, chatId, presetId, { updateMessageId = null } = {}) {
+    try {
+      const selector = /^\d+$/u.test(presetId) ? `id:${presetId}` : presetId;
+      const result = await runPresetCommand(
+        `/preset ${selector}`, this.#harness, this.#state, key, { signal: this.#signal },
+      );
+      for (const reply of result?.messages ?? [result?.message]) {
+        if (reply) await this.#send(chatId, reply);
+      }
+    } catch (error) {
+      this.#logger.warn?.('[dsh-feishu] preset select failed:', error.message);
+      await this.#send(chatId, t('预设切换失败，请稍后重试。'));
+      return;
+    }
+    try {
+      await this.#sendMenuCard(key, chatId, { updateMessageId });
+    } catch (error) {
+      this.#logger.warn?.('[dsh-feishu] menu refresh failed after preset select:', error.message);
+    }
+  }
+
+  /**
+   * Handle model selection from the model dropdown.
+   *
+   * Reuses `runModelCommand` (the same path as the `/model <id>` text
+   * command) so model IDs containing `/` (e.g.
+   * `openrouter/anthropic/claude-sonnet-4`) keep working, and all the
+   * catalog validation, busy checks, pending-interaction checks and the
+   * session binding lock stay in one place.
+   */
+  async #handleModelSelect(key, chatId, modelId, { updateMessageId = null } = {}) {
+    try {
+      const result = await runModelCommand(
+        `/model ${modelId}`, this.#harness, this.#state, key, {
+          signal: this.#signal,
+          pendingInteraction: this.#hasPendingInteraction(key),
+          control: { owner: this, key },
+        },
+      );
+      for (const reply of result?.messages ?? [result?.message]) {
+        if (reply) await this.#send(chatId, reply);
+      }
+    } catch (error) {
+      this.#logger.warn?.('[dsh-feishu] model select failed:', error.message);
+      await this.#send(chatId, t('模型切换失败，请稍后重试。'));
+      return;
+    }
+    try {
+      await this.#sendMenuCard(key, chatId, { updateMessageId });
+    } catch (error) {
+      this.#logger.warn?.('[dsh-feishu] menu refresh failed after model select:', error.message);
     }
-    return messageId;
   }
 
   // ── Watches: read-only session tracking + completion pushes ─────────────
@@ -1375,7 +2390,7 @@ export class FeishuHarnessBridge {
         signal,
         onSessionEvent: (payload) => this.#onHarnessEvent(payload),
         onReconnect: () => {
-          void this.#queueEventTask(() => this.#compensateMissedEvents());
+          void this.#compensateMissedEvents();
         },
       });
       Promise.resolve(this.#eventWatcher).catch((error) => {
@@ -1389,22 +2404,91 @@ export class FeishuHarnessBridge {
     }
   }
 
-  #queueEventTask(task) {
-    const next = this.#eventTail.then(task, task).catch((error) => {
+  #queueEventTask(sessionId, task) {
+    const previous = this.#eventTails.get(sessionId) ?? Promise.resolve();
+    let next;
+    next = previous.then(task, task).catch((error) => {
       if (!this.#signal?.aborted) {
         this.#logger.warn?.('[dsh-feishu] completion event failed:', error.message);
       }
+    }).finally(() => {
+      if (this.#eventTails.get(sessionId) === next) this.#eventTails.delete(sessionId);
     });
-    this.#eventTail = next;
+    this.#eventTails.set(sessionId, next);
     return next;
   }
 
+  #pruneObservedCompletionEvents(now = Date.now()) {
+    let total = 0;
+    for (const [sessionId, observed] of this.#observedCompletionEvents) {
+      for (const [seq, record] of observed) {
+        if (!Number.isSafeInteger(record?.arrivalAt)
+          || record.arrivalAt < 0
+          || record.arrivalAt + COMPLETION_OBSERVATION_TTL_MS <= now) {
+          observed.delete(seq);
+        }
+      }
+      while (observed.size > MAX_OBSERVED_COMPLETIONS_PER_SESSION) {
+        const oldest = observed.keys().next().value;
+        if (oldest === undefined) break;
+        observed.delete(oldest);
+      }
+      if (observed.size === 0) this.#observedCompletionEvents.delete(sessionId);
+      else total += observed.size;
+    }
+    while (this.#observedCompletionEvents.size > MAX_OBSERVED_COMPLETION_SESSIONS) {
+      const oldestSessionId = this.#observedCompletionEvents.keys().next().value;
+      if (oldestSessionId === undefined) break;
+      total -= this.#observedCompletionEvents.get(oldestSessionId)?.size ?? 0;
+      this.#observedCompletionEvents.delete(oldestSessionId);
+    }
+    while (total > MAX_OBSERVED_COMPLETIONS) {
+      const oldestSessionId = this.#observedCompletionEvents.keys().next().value;
+      if (oldestSessionId === undefined) break;
+      const observed = this.#observedCompletionEvents.get(oldestSessionId);
+      const oldestSeq = observed?.keys().next().value;
+      if (oldestSeq === undefined) {
+        this.#observedCompletionEvents.delete(oldestSessionId);
+        continue;
+      }
+      observed.delete(oldestSeq);
+      total -= 1;
+      if (observed.size === 0) this.#observedCompletionEvents.delete(oldestSessionId);
+    }
+  }
+
+  #recordObservedCompletion(sessionId, event, now = Date.now()) {
+    this.#pruneObservedCompletionEvents(now);
+    let observed = this.#observedCompletionEvents.get(sessionId);
+    if (!observed) observed = new Map();
+    const rawReason = event?.data?.reason;
+    const reason = typeof rawReason === 'string'
+      ? rawReason
+      : typeof rawReason?.kind === 'string'
+        ? { kind: rawReason.kind }
+        : null;
+    observed.delete(event.seq);
+    observed.set(event.seq, {
+      arrivalAt: now,
+      event: {
+        type: 'turn/end',
+        seq: event.seq,
+        ...(Number.isSafeInteger(event.time) && event.time >= 0 ? { time: event.time } : {}),
+        data: { reason },
+      },
+    });
+    // Refresh the session as a unit so both session and entry eviction are LRU.
+    this.#observedCompletionEvents.delete(sessionId);
+    this.#observedCompletionEvents.set(sessionId, observed);
+    this.#pruneObservedCompletionEvents(now);
+  }
+
   /**
    * Resolve a /watch target READ-ONLY: a session id is validated against
    * the registered workspaces' listings, an index against the current
    * workspace. Nothing is bound and no workspace is switched.
    */
-  async #resolveWatchTarget(target) {
+  async #resolveWatchTarget(target, { workspaceHint = null, signal = this.#signal } = {}) {
     if (typeof target !== 'string' || target === '') {
       return { error: t('用法：/watch <Session ID 或当前工作区序号>') };
     }
@@ -1413,7 +2497,7 @@ export class FeishuHarnessBridge {
       ? this.#harness.currentWorkspace()
       : null;
     const listSessions = async (workspace) => {
-      const listed = await this.#harness.listWorkspaceSessions(workspace);
+      const listed = await this.#harness.listWorkspaceSessions(workspace, { signal });
       return Array.isArray(listed?.sessions) ? listed.sessions : [];
     };
     if (numeric !== null) {
@@ -1423,94 +2507,217 @@ export class FeishuHarnessBridge {
       if (!session?.sessionId) {
         return { error: t('当前工作区只有 {count} 个会话。', { count: sessions.length }) };
       }
-      return { sessionId: session.sessionId, title: session.title ?? t('暂无标题') };
+      return {
+        sessionId: session.sessionId,
+        title: session.title ?? t('暂无标题'),
+        workspace: currentPath,
+        ...(validLastSeq(session.lastSeq) ? { lastSeq: session.lastSeq } : {}),
+      };
+    }
+    let paths;
+    if (nonEmptyString(workspaceHint)) {
+      paths = [workspaceHint];
+    } else {
+      const extraPaths = typeof this.#harness?.listWorkspaces === 'function'
+        ? (await this.#harness.listWorkspaces({ signal })).filter((path) => path !== currentPath)
+        : [];
+      paths = [currentPath, ...extraPaths].filter(Boolean);
     }
-    const extraPaths = typeof this.#harness?.listWorkspaces === 'function'
-      ? (await this.#harness.listWorkspaces()).filter((path) => path !== currentPath)
-      : [];
-    const paths = [currentPath, ...extraPaths].filter(Boolean);
     for (const workspace of paths) {
       const sessions = await listSessions(workspace);
       const session = sessions.find((candidate) => candidate.sessionId === target);
-      if (session) return { sessionId: target, title: session.title ?? t('暂无标题') };
+      if (session) {
+        return {
+          sessionId: target,
+          title: session.title ?? t('暂无标题'),
+          workspace,
+          ...(validLastSeq(session.lastSeq) ? { lastSeq: session.lastSeq } : {}),
+        };
+      }
     }
     return { error: t('没有找到这个会话，请用 /sessionlist 查看可用会话。') };
   }
 
-  async #latestSessionSeq(sessionId) {
-    if (typeof this.#harness?.rpc !== 'function') return null;
-    const history = await this.#harness.rpc(
-      'session.history',
-      { sessionId, maxMessages: 20 },
-      30_000,
-      { signal: this.#signal },
+  async #freshWatchTargets(workspace) {
+    const selectedWorkspace = nonEmptyString(workspace)
+      ?? (typeof this.#harness?.currentWorkspace === 'function'
+        ? nonEmptyString(this.#harness.currentWorkspace())
+        : null);
+    if (!selectedWorkspace || typeof this.#harness?.listWorkspaceSessions !== 'function') {
+      return new Map();
+    }
+    const listed = await this.#harness.listWorkspaceSessions(
+      selectedWorkspace,
+      { signal: this.#cardDataSignal() },
     );
-    return orderedHistoryEvents(history).at(-1)?.seq ?? -1;
+    return new Map(this.#visibleSessions(Array.isArray(listed?.sessions) ? listed.sessions : [])
+      .filter((session) => nonEmptyString(session?.sessionId))
+      .map((session) => [session.sessionId, {
+        sessionId: session.sessionId,
+        title: session.title ?? session.name ?? t('暂无标题'),
+        workspace: selectedWorkspace,
+        ...(validLastSeq(session.lastSeq) ? { lastSeq: session.lastSeq } : {}),
+      }]));
+  }
+
+  #scheduleCompensation(sessionId) {
+    const pending = this.#pendingCompensations.get(sessionId);
+    if (pending) {
+      pending.requested = true;
+      return pending.promise;
+    }
+    const state = { requested: true, promise: null };
+    this.#pendingCompensations.set(sessionId, state);
+    state.promise = Promise.resolve().then(async () => {
+      try {
+        // A watch can be persisted after an in-progress compensation already
+        // snapshotted its keys. Remember that request and run one trailing pass.
+        do {
+          state.requested = false;
+          await this.#queueEventTask(sessionId, () => this.#compensateSession(sessionId));
+        } while (state.requested && !this.#signal?.aborted);
+      } finally {
+        if (this.#pendingCompensations.get(sessionId) === state) {
+          this.#pendingCompensations.delete(sessionId);
+        }
+      }
+    });
+    return state.promise;
   }
 
-  async #runWatch(key, chatId, target) {
+  async #runWatch(key, chatId, target, {
+    notify = true,
+    validatedTarget = null,
+    workspaceHint = null,
+  } = {}) {
+    const watchRequestedAt = Date.now();
+    const reply = async (message) => {
+      if (!notify) return;
+      await this.#send(chatId, message).catch((error) => {
+        this.#logger.warn?.('[dsh-feishu] watch notification failed:', error.message);
+      });
+    };
     this.#ensureEventWatcher();
     if (typeof this.#state?.setWatch !== 'function') {
-      await this.#send(chatId, t('当前状态存储不支持关注。'));
-      return;
+      await reply(t('当前状态存储不支持关注。'));
+      return { ok: false, changed: false, reason: 'unsupported' };
     }
     let resolved;
     try {
-      resolved = await this.#resolveWatchTarget(target);
+      resolved = validatedTarget?.sessionId === target
+        ? validatedTarget
+        : await this.#resolveWatchTarget(target, {
+          workspaceHint,
+          signal: workspaceHint ? this.#cardDataSignal() : this.#signal,
+        });
     } catch (error) {
-      await this.#send(chatId, t('无法解析会话：{message}', { message: safeErrorText(error) }));
-      return;
+      await reply(t('无法解析会话：{message}', { message: safeErrorText(error) }));
+      return { ok: false, changed: false, reason: 'resolve' };
     }
     if (resolved.error) {
-      await this.#send(chatId, resolved.error);
-      return;
+      await reply(resolved.error);
+      return { ok: false, changed: false, reason: 'not-found' };
     }
     const existing = this.#state.watchEntries?.(key) ?? [];
     const existingEntry = existing.find((entry) => entry.sessionId === resolved.sessionId);
     if (!existingEntry && existing.length >= MAX_WATCHES_PER_KEY) {
-      await this.#send(chatId, t('每个聊天最多关注 {count} 个会话。', { count: MAX_WATCHES_PER_KEY }));
-      return;
-    }
+      await reply(t('每个聊天最多关注 {count} 个会话。', { count: MAX_WATCHES_PER_KEY }));
+      return { ok: false, changed: false, reason: 'limit' };
+    }
+    const lastSeq = validLastSeq(existingEntry?.lastSeq)
+      ? existingEntry.lastSeq
+      : validLastSeq(resolved.lastSeq)
+        ? resolved.lastSeq
+        : null;
+    // session.list's projection asOfSeq can be stale for a cold session. Every
+    // new watch therefore keeps a durable wall-clock boundary; lastSeq is only
+    // a lower bound for the history scan. Existing settled and legacy entries
+    // keep their prior semantics when /watch is repeated.
+    const existingBoundary = watchBoundary(existingEntry);
+    const watchStartedAt = existingBoundary ?? (existingEntry ? null : watchRequestedAt);
     try {
-      const lastSeq = typeof existingEntry?.lastSeq === 'number'
-        ? existingEntry.lastSeq
-        : await this.#latestSessionSeq(resolved.sessionId);
       await this.#state.setWatch(key, {
         sessionId: resolved.sessionId,
         title: resolved.title,
         chatId,
         lastSeq,
+        ...(watchStartedAt !== null ? { watchStartedAt } : {}),
       });
-      await this.#send(chatId, t('已关注会话「{title}」，任务完成会推送结果。', { title: String(resolved.title).replace(/\s+/gu, ' ') }));
-      await this.#queueEventTask(() => this.#compensateSession(resolved.sessionId));
     } catch (error) {
-      await this.#send(chatId, t('关注失败：{message}', { message: safeErrorText(error) }));
+      await reply(t('关注失败：{message}', { message: safeErrorText(error) }));
+      return { ok: false, changed: false, reason: 'persist' };
     }
+    // Always compensate a newly created or still-unsettled watch. This closes
+    // both target-list and durable-persistence windows.
+    if (!existingEntry || watchStartedAt !== null || !validLastSeq(lastSeq)) {
+      void this.#scheduleCompensation(resolved.sessionId);
+    }
+    await reply(t('已关注会话「{title}」，任务完成会推送结果。', { title: String(resolved.title).replace(/\s+/gu, ' ') }));
+    return { ok: true, changed: !existingEntry, entry: this.#state.watchEntry?.(key, resolved.sessionId) };
   }
 
-  async #runUnwatch(key, chatId, target) {
-    if (typeof this.#state?.removeWatch !== 'function') return;
+  async #runUnwatch(key, chatId, target, { notify = true } = {}) {
+    const reply = async (message) => {
+      if (!notify) return;
+      await this.#send(chatId, message).catch((error) => {
+        this.#logger.warn?.('[dsh-feishu] unwatch notification failed:', error.message);
+      });
+    };
+    if (typeof this.#state?.removeWatch !== 'function') {
+      return { ok: false, changed: false, reason: 'unsupported' };
+    }
     const entries = this.#state.watchEntries?.(key) ?? [];
     const entry = typeof target === 'string' && /^\d{1,4}$/.test(target)
       ? entries[Number(target) - 1]
       : entries.find((candidate) => candidate.sessionId === target);
     if (!entry) {
-      await this.#send(chatId, t('关注列表里没有这个会话，回复 /watchlist 查看。'));
-      return;
+      await reply(t('关注列表里没有这个会话，回复 /watchlist 查看。'));
+      return { ok: true, changed: false, reason: 'absent' };
     }
     try {
       await this.#state.removeWatch(key, entry.sessionId);
       this.#failedWatchSeqs.delete(`${key}\0${entry.sessionId}`);
-      await this.#send(chatId, t('已取消关注「{title}」。', { title: String(entry.title ?? '').replace(/\s+/gu, ' ') }));
     } catch (error) {
-      await this.#send(chatId, t('取消失败：{message}', { message: safeErrorText(error) }));
+      await reply(t('取消失败：{message}', { message: safeErrorText(error) }));
+      return { ok: false, changed: false, reason: 'persist' };
     }
+    await reply(t('已取消关注「{title}」。', { title: String(entry.title ?? '').replace(/\s+/gu, ' ') }));
+    return { ok: true, changed: true, entry };
   }
 
-  async #showWatchList(key, chatId) {
+  async #showWatchList(key, chatId, { updateMessageId = null } = {}) {
     const entries = this.#state.watchEntries?.(key) ?? [];
+    // 收集可选会话（用于「添加关注」多选下拉）；失败则传空数组 → 只渲染移除/列表。
+    let availableSessions = [];
+    let currentWorkspace = null;
+    try {
+      currentWorkspace = typeof this.#harness?.currentWorkspace === 'function'
+        ? this.#harness.currentWorkspace()
+        : null;
+      if (currentWorkspace && typeof this.#harness?.listWorkspaceSessions === 'function') {
+        const listed = await this.#harness.listWorkspaceSessions(
+          currentWorkspace,
+          { signal: this.#cardDataSignal() },
+        );
+        availableSessions = this.#visibleSessions(
+          Array.isArray(listed?.sessions) ? listed.sessions : [],
+        )
+          .map((session) => ({
+            sessionId: session.sessionId,
+            title: session.title ?? session.name ?? session.sessionId,
+          }));
+      }
+    } catch { /* add-select section degrades to remove-only */ }
     this.#rememberMenu(key, { kind: 'watches', entries });
-    await this.#sendCard(chatId, watchListCard(entries), { key });
+    await this.#sendCard(
+      chatId,
+      watchListCard(entries, availableSessions),
+      {
+        key,
+        updateMessageId,
+        sessionWorkspace: currentWorkspace,
+      },
+    );
   }
 
   /** Queue live turn completions behind any reconnect compensation. */
@@ -1520,32 +2727,41 @@ export class FeishuHarnessBridge {
       || !event
       || typeof event !== 'object'
       || event.type !== 'turn/end'
-      || !Number.isFinite(event.seq)) return;
-    void this.#queueEventTask(async () => {
-      const hasFailedDelivery = (this.#state.keysWatching?.(sessionId) ?? [])
+      || !validEventSeq(event.seq)) return;
+    // Record before consulting state: /watch may still be resolving its target
+    // or waiting for setWatch persistence and therefore have no visible entry.
+    this.#recordObservedCompletion(sessionId, event);
+    void this.#queueEventTask(sessionId, async () => {
+      const keys = this.#state.keysWatching?.(sessionId) ?? [];
+      const needsBaseline = keys.some((key) => (
+        watchNeedsBaseline(this.#state.watchEntry?.(key, sessionId))
+      ));
+      const hasFailedDelivery = keys
         .some((key) => this.#failedWatchSeqs.has(`${key}\0${sessionId}`));
-      if (hasFailedDelivery) await this.#compensateSession(sessionId);
+      if (needsBaseline || hasFailedDelivery) await this.#compensateSession(sessionId);
       await this.#deliverCompletion(sessionId, event);
     });
   }
 
-  async #deliverCompletion(sessionId, event) {
+  async #deliverCompletion(sessionId, event, { keys: targetKeys = null } = {}) {
     if (this.#signal?.aborted || typeof this.#state?.keysWatching !== 'function') return;
     const reason = event?.data?.reason?.kind ?? event?.data?.reason ?? null;
-    for (const key of this.#state.keysWatching(sessionId)) {
+    const keys = targetKeys ?? this.#state.keysWatching(sessionId);
+    for (const key of keys) {
       if (this.#signal?.aborted) return;
       const entry = this.#state.watchEntry?.(key, sessionId);
       const deliveryKey = `${key}\0${sessionId}`;
       let failedSeq = this.#failedWatchSeqs.get(deliveryKey);
-      if (typeof failedSeq === 'number'
-        && typeof entry?.lastSeq === 'number'
+      if (validEventSeq(failedSeq)
+        && validLastSeq(entry?.lastSeq)
         && entry.lastSeq >= failedSeq) {
         this.#failedWatchSeqs.delete(deliveryKey);
         failedSeq = undefined;
       }
       if (!entry?.chatId
-        || (typeof entry.lastSeq === 'number' && entry.lastSeq >= event.seq)
-        || (typeof failedSeq === 'number' && event.seq > failedSeq)) continue;
+        || watchNeedsBaseline(entry)
+        || (validLastSeq(entry.lastSeq) && entry.lastSeq >= event.seq)
+        || (validEventSeq(failedSeq) && event.seq > failedSeq)) continue;
       try {
         await this.#sendCard(
           entry.chatId,
@@ -1555,13 +2771,14 @@ export class FeishuHarnessBridge {
         const current = this.#state.watchEntry?.(key, sessionId);
         if (!current
           || current.chatId !== entry.chatId
-          || (typeof current.lastSeq === 'number' && current.lastSeq >= event.seq)) continue;
+          || watchNeedsBaseline(current)
+          || (validLastSeq(current.lastSeq) && current.lastSeq >= event.seq)) continue;
         await this.#state.setWatch(key, { ...current, lastSeq: event.seq });
         if (failedSeq === event.seq) this.#failedWatchSeqs.delete(deliveryKey);
       } catch (error) {
         this.#failedWatchSeqs.set(
           deliveryKey,
-          typeof failedSeq === 'number' ? Math.min(failedSeq, event.seq) : event.seq,
+          validEventSeq(failedSeq) ? Math.min(failedSeq, event.seq) : event.seq,
         );
         this.#logger.warn?.('[dsh-feishu] completion push failed:', error.message);
       }
@@ -1577,23 +2794,55 @@ export class FeishuHarnessBridge {
         30_000,
         { signal: this.#signal },
       );
-      const events = orderedHistoryEvents(history);
+      const historicalEvents = orderedHistoryEvents(history);
+      this.#pruneObservedCompletionEvents();
+      const observed = this.#observedCompletionEvents.get(sessionId) ?? new Map();
+      const eventsBySeq = new Map(historicalEvents.map((event) => [event.seq, event]));
+      // The event mux can be ahead of the history projection. Retain a bounded,
+      // minimal completion payload so a pre-persistence live frame is not lost.
+      for (const [seq, record] of observed) {
+        if (!eventsBySeq.has(seq)) eventsBySeq.set(seq, record.event);
+      }
+      const events = [...eventsBySeq.values()].sort((left, right) => left.seq - right.seq);
       const latestSeq = events.at(-1)?.seq ?? -1;
       const keys = typeof this.#state?.keysWatching === 'function'
         ? this.#state.keysWatching(sessionId)
         : [];
 
-      // Watches created by older versions have no baseline. Establish one
-      // without replaying completions that predate the watch.
+      // Establish independent baselines for every chat watching this Session.
+      // New watches carry a durable wall-clock boundary; old persisted null
+      // watches retain the legacy "baseline latest without replay" behavior.
       for (const key of keys) {
         const entry = this.#state.watchEntry?.(key, sessionId);
-        if (entry && typeof entry.lastSeq !== 'number') {
-          await this.#state.setWatch(key, { ...entry, lastSeq: latestSeq });
-        }
+        if (!watchNeedsBaseline(entry)) continue;
+        const watchStartedAt = watchBoundary(entry);
+        const lowerBound = validLastSeq(entry.lastSeq) ? entry.lastSeq : -1;
+        const firstKnownNew = watchStartedAt === null
+          ? null
+          : events.find((event) => {
+            if (event.seq <= lowerBound) return false;
+            const eventTime = Number.isSafeInteger(event.time) && event.time >= 0
+              ? event.time
+              : observed.get(event.seq)?.arrivalAt;
+            return Number.isSafeInteger(eventTime) && eventTime >= watchStartedAt;
+          });
+        // Unknown events before the first event proven post-boundary are
+        // conservatively part of the baseline. Sequence order proves all later
+        // events are post-boundary. With no proof, replay nothing.
+        const baselineSeq = firstKnownNew
+          ? Math.max(lowerBound, firstKnownNew.seq - 1)
+          : Math.max(lowerBound, latestSeq);
+        const current = this.#state.watchEntry?.(key, sessionId);
+        if (!current
+          || current.chatId !== entry.chatId
+          || current.lastSeq !== entry.lastSeq
+          || watchBoundary(current) !== watchStartedAt) continue;
+        const { watchStartedAt: _watchStartedAt, ...settled } = current;
+        await this.#state.setWatch(key, { ...settled, lastSeq: baselineSeq });
       }
 
       for (const event of events) {
-        if (event.type === 'turn/end') await this.#deliverCompletion(sessionId, event);
+        if (event.type === 'turn/end') await this.#deliverCompletion(sessionId, event, { keys });
       }
     } catch (error) {
       if (!this.#signal?.aborted) {
@@ -1607,10 +2856,8 @@ export class FeishuHarnessBridge {
     const sessionIds = typeof this.#state?.watchedSessionIds === 'function'
       ? this.#state.watchedSessionIds()
       : [];
-    for (const sessionId of sessionIds) {
-      if (this.#signal?.aborted) return;
-      await this.#compensateSession(sessionId);
-    }
+    if (this.#signal?.aborted) return;
+    await Promise.allSettled(sessionIds.map((sessionId) => this.#scheduleCompensation(sessionId)));
   }
 
   #interactionAskOptions(event, key, files) {