@xmanrui/dsh-im 4.15.0 → 4.16.0

package/src/channels/feishu/bridge.mjs

@@ -87,6 +87,7 @@ import {
   menuHelpText,
   modelCard,
   presetCard,
+  answeredQuestionCard,
   questionCard,
   sessionListCard,
   statusCard,
@@ -166,6 +167,15 @@ const STEP_PUSH_MAX_MESSAGES_PER_TURN = 200;
 const STEP_PUSH_SUMMARY_MAX_CHARS = 120;
 const STEP_PUSH_ARGUMENTS_MAX_CHARS = 400;
 const STEP_PUSH_ERROR_MAX_CHARS = 200;
+/** Silence threshold before the thinking status heartbeat appears. */
+const STEP_PUSH_HEARTBEAT_AFTER_MS = 20_000;
+/** The thinking heartbeat refreshes its elapsed time at this cadence. */
+const STEP_PUSH_HEARTBEAT_REFRESH_MS = 30_000;
+/** One turn never refreshes the thinking heartbeat more than this. */
+const STEP_PUSH_HEARTBEAT_MAX_UPDATES = 30;
+/** One pending heartbeat id is retried at most this many times across
+ *  recall boundaries before it is abandoned (with a warning). */
+const STEP_PUSH_HEARTBEAT_RECALL_ATTEMPTS = 3;
 /** One post message carries at most this many UTF-8 bytes after its rich-text
  *  content has been JSON encoded (Feishu caps rich-text requests at 30KB). */
 const STEP_PUSH_POST_CHUNK_MAX_BYTES = 24_000;
@@ -529,6 +539,9 @@ export class FeishuHarnessBridge {
   #pendingInteractions = new Map();
   #interactionKeys = new Map();
   #resolvedQuestionReplies = new Map();
+  // issue #162：已提交答案的 interactionId → 过期时间（TTL-only，惰性清理，
+  // 与 #resolvedQuestionReplies 同风格）。陈旧点击据此给出「已回答」提示。
+  #answeredInteractionIds = new Map();
   // Keep the accepted configuration through the existing queue/reply lifecycle.
   #acceptedMessageIds = new Map();
   #interactionTasks = new Set();
@@ -2192,7 +2205,35 @@ export class FeishuHarnessBridge {
         if (pending && pending.kind === 'question' && !pending.submitting
           && pending.actor === actor
           && Number(indexText) === pending.index) {
-          await this.#submitQuestionAnswer(pending, optionLabel, { chatId });
+          await this.#submitQuestionAnswer(pending, optionLabel, { chatId, questionMessageId: messageId });
+        } else {
+          // issue #162：pending 已清除时区分「已答过」与「其他客户端处理」，
+          // 避免对同一张提问卡的重复点击弹出误导提示。
+          const staleNotice = pending
+            ? INTERACTION_RESOLVED_TEXT()
+            : this.#isAnsweredInteraction(interactionId)
+              ? t('这个问题已经回答过了。')
+              : INTERACTION_RESOLVED_TEXT();
+          await reply(staleNotice).catch(() => undefined);
+        }
+      }
+      return;
+    }
+    // issue #162：自定义答案入口——与 answer: 同构校验；通过后引导用户直接
+    // 发送文字消息（canClaimInteractionReply 语义：同 actor 的文本即答案）。
+    if (action.startsWith('answerCustom:')) {
+      const rest = action.slice('answerCustom:'.length);
+      const sep = rest.indexOf(':');
+      if (sep !== -1) {
+        const interactionId = rest.slice(0, sep);
+        const indexText = rest.slice(sep + 1);
+        const qKey = this.#interactionKeys.get(interactionId);
+        const pending = qKey ? this.#pendingInteractions.get(qKey) : null;
+        if (pending && pending.kind === 'question' && !pending.submitting
+          && pending.actor === actor && Number(indexText) === pending.index) {
+          await reply(t('想自定义答案？直接发送文字消息即可，将作为本题答案提交。')).catch(() => undefined);
+        } else if (!pending && this.#isAnsweredInteraction(interactionId)) {
+          await reply(t('这个问题已经回答过了。')).catch(() => undefined);
         } else {
           await reply(INTERACTION_RESOLVED_TEXT()).catch(() => undefined);
         }
@@ -2605,6 +2646,27 @@ export class FeishuHarnessBridge {
     }
   }
 
+  /**
+   * issue #162：已答状态卡的原地替换。patch 失败仅记录警告并明确降级——
+   * 回执缺失不应影响答案提交，也不得像 #sendCard 那样回退成发送新卡。
+   */
+  async #patchCardMessage(chatId, messageId, cardJson) {
+    if (!messageId) return null;
+    try {
+      const response = await this.#client.im.v1.message.patch({
+        path: { message_id: messageId },
+        data: { content: cardJson },
+      });
+      if (response?.code && response.code !== 0) {
+        throw new Error(`Feishu card update failed: ${response.msg || response.code}`);
+      }
+      return messageId;
+    } catch (error) {
+      this.#logger.warn?.('[dsh-feishu] answered-state card patch failed:', error?.message ?? error);
+      return null;
+    }
+  }
+
   async #sendCard(chatId, cardJson, options = {}) {
     const updateMessageId = nonEmptyString(options.updateMessageId);
     const replyTo = nonEmptyString(options.replyTo);
@@ -3771,6 +3833,10 @@ export class FeishuHarnessBridge {
     const state = this.#stepPushSendState.get(key)
       ?? { lastSentAt: 0, count: 0, breakerLogged: false };
     this.#stepPushSendState.set(key, state);
+    // 真实事件到达：先撤回思考中心跳再推真实消息。
+    // pendingRecallIds 是唯一撤回清单（live 心跳创建时即入队），避免同一 id 双撤回；
+    // 撤回失败的 id 留在队列里待下个边界重试，不能在这里无条件清空。
+    await this.#recallPendingHeartbeats(state);
     if (billable && state.count >= STEP_PUSH_MAX_MESSAGES_PER_TURN) {
       if (!state.breakerLogged) {
         state.breakerLogged = true;
@@ -3778,6 +3844,11 @@ export class FeishuHarnessBridge {
           `[dsh-feishu] step push hit ${STEP_PUSH_MAX_MESSAGES_PER_TURN} messages for this turn; staying silent until it ends`,
         );
       }
+      // 熔断静默期内同样刷新 silenceSince：用户仍在活动，静默窗口重新计时，
+      // 避免看门狗在每个被拦截的事件后重建/撤回心跳。activitySeq 单调递增，
+      // 供心跳创建返回后识别「创建在途期间出现了真实活动」（同毫秒事件也能识别）。
+      state.silenceSince = this.#stepPushClock.now();
+      state.activitySeq = (state.activitySeq ?? 0) + 1;
       return;
     }
     this.#signal?.throwIfAborted();
@@ -3787,6 +3858,8 @@ export class FeishuHarnessBridge {
     // message land after the teardown has begun.
     this.#signal?.throwIfAborted();
     state.lastSentAt = this.#stepPushClock.now();
+    state.silenceSince = state.lastSentAt;
+    state.activitySeq = (state.activitySeq ?? 0) + 1;
     if (billable) state.count += 1;
     this.#status.streamUpdates = (this.#status.streamUpdates ?? 0) + 1;
     await this.#sendStepPost(chatId, replyToMessageId, paragraphs, fallbackText);
@@ -3889,6 +3962,154 @@ export class FeishuHarnessBridge {
       || /230020|230006/.test(error?.message ?? '');
   }
 
+  #formatElapsed(ms) {
+    const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+    return `${Math.floor(totalSeconds / 60)}:${String(totalSeconds % 60).padStart(2, '0')}`;
+  }
+
+  /**
+   * 撤回待撤回心跳清单：撤回成功（recallMessage 返回 true）的 id 移出队列；
+   * 失败的保留，待下个真实事件/回合结束边界重试，单条最多尝试
+   * STEP_PUSH_HEARTBEAT_RECALL_ATTEMPTS 次后放弃并告警（消息可能已被手动
+   * 删除或接口持续受限，避免队列无限增长）。live 心跳撤回失败且仍在队列时
+   * 保留 heartbeatMessageId：消息仍在会话里，看门狗继续原地刷新同一条，
+   * 而不是另建一条造成重复。
+   */
+  async #recallPendingHeartbeats(state) {
+    const remaining = [];
+    for (const entry of state.pendingRecallIds ?? []) {
+      let recalled = false;
+      try {
+        recalled = (await this.#channel?.recallMessage?.(entry.id)) === true;
+      } catch (error) {
+        this.#logger.warn?.('[dsh-feishu] heartbeat recall failed:', error?.message ?? String(error));
+      }
+      if (recalled) continue;
+      const attempts = (entry.attempts ?? 0) + 1;
+      if (attempts >= STEP_PUSH_HEARTBEAT_RECALL_ATTEMPTS) {
+        this.#logger.warn?.(`[dsh-feishu] heartbeat recall gave up after ${attempts} attempts: ${entry.id}`);
+        continue;
+      }
+      remaining.push({ id: entry.id, attempts });
+    }
+    state.pendingRecallIds = remaining;
+    const liveId = state.heartbeatMessageId;
+    if (liveId && !remaining.some((entry) => entry.id === liveId)) state.heartbeatMessageId = null;
+  }
+
+  /**
+   * 撤回一条刚创建、但创建返回时已过时（回合已结束或创建在途期间出现了
+   * 真实活动）的心跳：成功即丢弃；失败则按失败保留策略入队，待下个边界重试。
+   */
+  async #recallLateHeartbeat(state, messageId) {
+    let recalled = false;
+    try {
+      recalled = (await this.#channel?.recallMessage?.(messageId)) === true;
+    } catch (error) {
+      this.#logger.warn?.('[dsh-feishu] late heartbeat recall failed:', error?.message ?? String(error));
+    }
+    if (recalled) return;
+    state.pendingRecallIds = [...(state.pendingRecallIds ?? []), { id: messageId, attempts: 1 }];
+  }
+
+  /**
+   * 思考中状态看门狗：直推回合内静默满阈值时推送/原地刷新一条「⏳ 正在思考中…」
+   * 心跳 post；真实事件或回合结束时撤回。轮询检查可注入 stepPushClock（测试
+   * 手动推进时钟），生命周期归属当前回合（stop 后循环退出）。
+   */
+  #startThinkingStatusWatchdog(key, chatId, replyToMessageId) {
+    const state = this.#stepPushSendState.get(key);
+    if (!state) return { stop: async () => {} };
+    state.heartbeatStopped = false;
+    state.heartbeatMessageId = null;
+    state.heartbeatNextAttemptAt = 0;
+    const watchdog = { stopped: false };
+    void (async () => {
+      try {
+        // 轮询式看门狗：每 10ms 检查一次（真实时间），静默判定读取可注入
+        // 时钟——生产随真实时间自然触发；测试手动推进时钟即可确定性验证。
+        while (!watchdog.stopped && !this.#signal?.aborted && !state.heartbeatStopped) {
+          await new Promise((resolve) => setTimeout(resolve, 10));
+          if (watchdog.stopped || this.#signal?.aborted || state.heartbeatStopped) return;
+          const now = this.#stepPushClock.now();
+          // 静默基线 = silenceSince（回合开始播种，每次真实推送刷新）。
+          const silentFor = now - (state.silenceSince ?? state.turnStartedAt ?? now);
+          if (state.heartbeatMessageId) {
+            if (now - (state.heartbeatUpdatedAt ?? 0) < STEP_PUSH_HEARTBEAT_REFRESH_MS) continue;
+            const elapsed = this.#formatElapsed(now - (state.heartbeatShownAt ?? state.heartbeatUpdatedAt));
+            state.heartbeatUpdatedAt = this.#stepPushClock.now();
+            state.heartbeatUpdates = (state.heartbeatUpdates ?? 0) + 1;
+            if (state.heartbeatUpdates > STEP_PUSH_HEARTBEAT_MAX_UPDATES) {
+              state.heartbeatStopped = true;
+              continue;
+            }
+            try {
+              const response = await this.#client.im.v1.message.update({
+                path: { message_id: state.heartbeatMessageId },
+                data: {
+                  msg_type: 'post',
+                  content: JSON.stringify({
+                    zh_cn: { content: [[{ tag: 'text', text: t('⏳ 正在思考中…（已运行 {elapsed}）', { elapsed }) }]] },
+                  }),
+                },
+              });
+              if (response?.code && response.code !== 0) {
+                this.#logger.warn?.('[dsh-feishu] heartbeat update failed:', response.msg || response.code);
+              }
+            } catch (error) {
+              // 更新失败：保留心跳（消息仍在会话中），留待真实事件/回合结束撤回。
+              this.#logger.warn?.('[dsh-feishu] heartbeat update failed:', error.message);
+            }
+            continue;
+          }
+          if (now < (state.heartbeatNextAttemptAt ?? 0)) continue;
+          if (silentFor < STEP_PUSH_HEARTBEAT_AFTER_MS) continue;
+          // 记录发起创建时的活动序号：创建请求在途期间若出现真实活动
+          // （真实推送或熔断分支都会推进 activitySeq），这条心跳返回时
+          // 已过时，必须立即撤回而不是登记为当前状态。
+          const activitySeqAtDispatch = state.activitySeq ?? 0;
+          const shownAt = now;
+          const result = await this.#sendStepPost(
+            chatId, replyToMessageId,
+            [[{ tag: 'text', text: t('⏳ 正在思考中…（已运行 {elapsed}）', { elapsed: this.#formatElapsed(0) }) }]],
+            t('⏳ 正在思考中…'),
+          );
+          if (watchdog.stopped || this.#signal?.aborted) {
+            // 创建期间回合已结束：立即撤回刚发出的心跳，避免残留。
+            if (result.ok && result.messageId) await this.#recallLateHeartbeat(state, result.messageId);
+            return;
+          }
+          if ((state.activitySeq ?? 0) !== activitySeqAtDispatch) {
+            // 创建期间出现真实活动：这条「正在思考中」会排在真实步骤之后，
+            // 立即撤回且不登记（不进入原地刷新，也不作为 live 心跳）。
+            if (result.ok && result.messageId) await this.#recallLateHeartbeat(state, result.messageId);
+            continue;
+          }
+          if (result.ok) {
+            state.heartbeatMessageId = result.messageId ?? null;
+            state.pendingRecallIds = [...(state.pendingRecallIds ?? []), { id: result.messageId, attempts: 0 }];
+            state.heartbeatShownAt = shownAt;
+            state.heartbeatUpdatedAt = shownAt;
+          } else {
+            // 发送失败：退避后再试，避免每个轮询都重试造成堆积。
+            state.heartbeatNextAttemptAt = now + 5_000;
+          }
+        }
+      } catch (error) {
+        if (!this.#signal?.aborted) {
+          this.#logger.warn?.('[dsh-feishu] thinking status watchdog failed:', error.message);
+        }
+      }
+    })();
+    return {
+      stop: async () => {
+        watchdog.stopped = true;
+        // 回合结束撤回：失败项保留在队列里（跨回合携带），待下个边界重试。
+        await this.#recallPendingHeartbeats(state);
+      },
+    };
+  }
+
   /**
    * 分步直推：`#answerWithStream` 流式分支在开关开启时的完整替代路径。
    * 过程（工具调用、助手中间说明）与最终答案均以富文本 post 逐条直推
@@ -3929,7 +4150,15 @@ export class FeishuHarnessBridge {
       if (oldest !== undefined) this.#stepPushSendState.delete(oldest);
     }
     this.#stepPushSendState.set(key, {
+      // 思考中状态的静默基线 = 回合开始时刻；lastSentAt 仅供真实推送刷新，
+      // 不参与心跳判定（否则首个真实步骤的节流等待会被误判/误伤）。
+      silenceSince: this.#stepPushClock.now(),
+      turnStartedAt: this.#stepPushClock.now(),
       lastSentAt: priorState?.lastSentAt ?? 0,
+      // 撤回失败的心跳跨回合携带：回合边界没撤掉的「正在思考中」在下个
+      // 回合的真实事件/结束时继续重试，而不是被 reopen 静默丢弃。
+      pendingRecallIds: priorState?.pendingRecallIds ?? [],
+      activitySeq: 0,
       count: 0,
       breakerLogged: false,
     });
@@ -3961,7 +4190,10 @@ export class FeishuHarnessBridge {
         messageId,
       );
     };
-    const completed = await askInWorkspaceSession({
+    const watchdog = this.#startThinkingStatusWatchdog(key, chatId, messageId);
+    let completed;
+    try {
+      completed = await askInWorkspaceSession({
       deferredDelivery: () => ({ coordinator: this.#deferred, chatId, replyToMessageId: messageId }),
       harness: this.#harness,
       state: this.#state,
@@ -4002,6 +4234,10 @@ export class FeishuHarnessBridge {
         },
       },
     });
+    } finally {
+      // 回合结束（成功/失败/中断）：停看门狗并撤回残留思考中心跳。
+      await watchdog.stop();
+    }
     markAskComplete();
     const finalStepText = pendingStep ? pendingStep.text : null;
     pendingStep = null;
@@ -4203,14 +4439,22 @@ export class FeishuHarnessBridge {
             // issue #86：独立交互消息（提问/审批）会落在占位卡下方，呈现前
             // 先换卡，让最终答案落在交互消息之后的新流式卡上。
             onInteraction: async (interaction) => {
-              if ((interaction?.kind === 'question' || interaction?.kind === 'approval')
-                && typeof controller?.rotate === 'function') {
-                await controller.rotate();
+              try {
+                if ((interaction?.kind === 'question' || interaction?.kind === 'approval')
+                  && typeof controller?.rotate === 'function') {
+                  await controller.rotate();
+                }
+                await baseAskOptions.onInteraction(interaction);
+              } finally {
+                // issue #163：呈现完成（或失败）即解除换卡挂起，此后建的新卡
+                // 必然位于交互消息下方；interactionPresented 不存在时静默跳过。
+                controller?.interactionPresented?.();
               }
-              await baseAskOptions.onInteraction(interaction);
             },
             onUpdate: async (update) => {
-              await controller.setContent(this.#progressText(update));
+              await controller.setContent(this.#progressText(update), {
+                transient: update.type !== 'text',
+              });
               this.#status.streamUpdates = (this.#status.streamUpdates ?? 0) + 1;
             },
           };
@@ -4403,14 +4647,35 @@ export class FeishuHarnessBridge {
     await this.#submitQuestionAnswer(pending, text, {
       chatId: event.message.chat_id,
       messageId,
+      questionMessageId: pending.questionCardMessageId,
     });
   }
 
-  async #submitQuestionAnswer(pending, answerText, { chatId, messageId } = {}) {
+  async #submitQuestionAnswer(pending, answerText, { chatId, messageId, questionMessageId } = {}) {
     const question = pending.questions[pending.index];
     if (!question) return;
     pending.chatId = chatId ?? pending.chatId;
 
+    // issue #162：已答状态卡以推进前的题号渲染，并整卡替换原提问卡。
+    const answeredIndex = pending.index;
+    const answeredCardJson = answeredQuestionCard({
+      interactionId: pending.interactionId,
+      // 评审补充（#162）：与呈现提问卡保持一致，传入原题的文本/标题/说明，
+      // 否则回执会退化为「请输入你的回答。」。
+      question: question.question,
+      header: question.header,
+      detail: question.detail,
+      options: Array.isArray(question?.options) ? question.options : [],
+      chosen: answerText,
+      index: answeredIndex,
+      total: pending.questions.length,
+    });
+    const patchAnsweredCard = () => this.#patchCardMessage(
+      pending.chatId,
+      questionMessageId ?? pending.questionCardMessageId,
+      answeredCardJson,
+    );
+
     pending.answers.push(harnessAnswerForQuestion(question, answerText));
     pending.index += 1;
     if (pending.index < pending.questions.length) {
@@ -4418,6 +4683,7 @@ export class FeishuHarnessBridge {
         pending.claimedReplyMessageId = null;
       }
       pending.needsPresentation = true;
+      await patchAnsweredCard();
       try {
         await this.#presentInteraction(pending);
       } catch {
@@ -4438,6 +4704,8 @@ export class FeishuHarnessBridge {
           answer: { answers: pending.answers },
         },
       });
+      await patchAnsweredCard();
+      this.#answeredInteractionIds.set(pending.interactionId, Date.now() + RESOLVED_REPLY_TTL_MS);
       this.#rememberResolvedInteraction(key, pending);
       this.#clearPendingInteraction(key, pending.interactionId);
       this.#status.lastError = null;
@@ -4574,6 +4842,7 @@ export class FeishuHarnessBridge {
       submitting: false,
       needsPresentation: true,
       questionMessageIds: new Set(),
+      questionCardMessageId: null,
       inactive: false,
     };
     this.#pendingInteractions.set(key, pending);
@@ -4603,6 +4872,10 @@ export class FeishuHarnessBridge {
       && options.length > 0
       && question.multiSelect !== true;
     let messageId;
+    let presentedAsCard = false;
+    // 评审补充（#162）：每次呈现先重置——本题走文本路径（或卡片回退到文本）
+    // 时不得沿用上一题的卡消息 id，否则后一题的回执会覆盖前一张已答卡。
+    pending.questionCardMessageId = null;
     if (interactive) {
       // Single-choice question with options: render each option as a button.
       messageId = await this.#sendCard(
@@ -4617,7 +4890,10 @@ export class FeishuHarnessBridge {
           total: pending.questions.length,
         }),
         { key: pending.key, replyTo: pending.replyToMessageId },
-      ).catch(async () => {
+      ).then((sent) => {
+        presentedAsCard = true;
+        return sent;
+      }).catch(async () => {
         // Fall back to the plain-text question if the card cannot be sent.
         // If the text send also fails, let the error propagate so the pending
         // question is not marked as presented and the existing retry logic runs.
@@ -4644,11 +4920,21 @@ export class FeishuHarnessBridge {
     }
     if (messageId) {
       pending.questionMessageIds.add(messageId);
+      // issue #162：仅卡片路径成功时记录——文本回退产生的消息 id 不参与已答回写。
+      if (presentedAsCard) pending.questionCardMessageId = messageId;
       if (pending.inactive) this.#rememberResolvedInteraction(pending.key, pending);
     }
     pending.needsPresentation = false;
   }
 
+  #isAnsweredInteraction(interactionId) {
+    const now = Date.now();
+    for (const [id, expiresAt] of this.#answeredInteractionIds) {
+      if (expiresAt <= now) this.#answeredInteractionIds.delete(id);
+    }
+    return this.#answeredInteractionIds.has(interactionId);
+  }
+
   #rememberResolvedInteraction(key, pending) {
     const expiresAt = Date.now() + RESOLVED_REPLY_TTL_MS;
     for (const messageId of pending.questionMessageIds ?? []) {

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

@@ -933,6 +933,44 @@ export function questionCard({ interactionId, header, question, detail, options,
       // question cannot be applied to the current one: answer:<interactionId>:<index>:<label>
       elements.push(button(buttonText, `answer:${interactionId}:${index}:${label}`));
     }
+    // issue #162：自定义答案入口与 menuCard/steerCard 的「✏️ 更多 / 自定义…」
+    // 对齐——文字流本就支持 custom 答案，卡片补上引导入口。
+    elements.push(button(t('✏️ 其他答案…'), `answerCustom:${interactionId}:${index}`));
   }
   return cardWith(t('❓ 请补充信息{progress}', { progress }), elements);
 }
+
+/**
+ * issue #162：提问卡被回答后的已答状态卡——原卡整卡替换为该回执样式：
+ * 保留问题与选项文本、标注已选项、不渲染任何按钮（重复点击从根源消失）。
+ * 与 questionCard 一样返回 JSON 字符串，调用方直接作为卡 content 使用。
+ */
+export function answeredQuestionCard({ interactionId, header, question, detail, options, chosen, index, total }) {
+  const elements = [];
+  const progress = total > 1 ? `（${index + 1}/${total}）` : '';
+  if (header) elements.push({ tag: 'div', text: markdown(String(header)) });
+  const qText = typeof question === 'string' && question.trim() ? question : t('请输入你的回答。');
+  elements.push({ tag: 'div', text: markdown(String(qText)) });
+  if (detail) elements.push({ tag: 'div', text: markdown(String(detail)) });
+  if (Array.isArray(options) && options.length > 0) {
+    elements.push({ tag: 'hr' });
+    let chosenShown = false;
+    for (const option of options) {
+      const label = typeof option?.label === 'string' ? option.label : '';
+      if (!label) continue;
+      if (label === chosen) chosenShown = true;
+      elements.push({ tag: 'div', text: markdown(label === chosen
+        ? t('✅ 已选择：{label}', { label })
+        : label) });
+    }
+    // 自定义文本答案不在预设选项里——单独一行展示所选内容。
+    if (!chosenShown && typeof chosen === 'string' && chosen.trim()) {
+      elements.push({ tag: 'div', text: markdown(t('✅ 已选择：{label}', { label: chosen })) });
+    }
+  } else if (typeof chosen === 'string' && chosen.trim()) {
+    elements.push({ tag: 'div', text: markdown(t('✅ 已选择：{label}', { label: chosen })) });
+  }
+  elements.push({ tag: 'hr' });
+  elements.push({ tag: 'div', text: markdown(t('回答已提交，对话将继续。')) });
+  return cardWith(t('✅ 已回答{progress}', { progress }), elements);
+}

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

@@ -207,59 +207,120 @@ export class VerifiedFeishuChannel {
     const cards = [];
     let activeCard = null;
     let rotating = false;
+    let awaitingPresentation = false;
+    // issue #163：过程写卡与换卡定格共用一条写队列串行化——在途写必然先于
+    // 定格完成，消除「写飞越定格」竞态；前序失败不阻塞后续写入。
+    let writeQueue = Promise.resolve();
+    const enqueue = (job) => {
+      const run = writeQueue.then(job, job);
+      writeQueue = run.catch(() => undefined);
+      return run;
+    };
     try {
       activeCard = await this.#createStreamCard(chatId, options);
       cards.push(activeCard);
       let lastContent = this.#initialText;
+      let lastContentIsTransient = true;
+      // Track the current card separately from incoming snapshots: held or
+      // failed writes have not delivered any text that can be deduplicated.
+      let activeView = lastContent;
+      let activeTextPrefix = null;
       // issue #86：独立交互消息（提问/审批）落在占位卡下方后，最终答案不得
       // 回写旧卡。rotate() 把旧卡定格为「过程记录 + 指引行」并标记换卡态；
       // 下一次 setContent（过程更新或最终答案）才创建新卡——新卡必然创建于
       // 交互消息之后。旧卡纳入 cards，参与 recall 与 providerMessageIds。
+      // issue #163：定格后进入换卡挂起（awaitingPresentation），挂起期内
+      // setContent 只推进快照、不建卡不写卡；bridge 呈现交互消息后调用
+      // interactionPresented() 解除挂起，此后建的新卡必然位于交互消息下方。
       const ensureActiveCard = async () => {
         if (!rotating) return activeCard;
         activeCard = await this.#createStreamCard(chatId, options);
+        activeView = this.#initialText;
+        activeTextPrefix = null;
         cards.push(activeCard);
         rotating = false;
         return activeCard;
       };
+      // issue #163：冻结前缀去重——换卡定格时旧卡已展示 frozenContent；此后
+      // 新卡只展示剥离该前缀后的增量（重放快照剥为空白则跳过写卡），终稿
+      // 分段同样使用增量视图，提问前的过程不再重复播放。
+      let frozenContent = null;
+      const applyFrozenDedup = (next) => {
+        if (frozenContent === null || !next.startsWith(frozenContent)) return next;
+        const rest = next.slice(frozenContent.length);
+        return rest.trim().length > 0 ? rest : ''; // 不改写增量原文；全空白视为无增量
+      };
+      // 评审补充（#163）：去重基线与定格内容必须以「旧卡实际展示的内容」为准——
+      // 超长快照的旧卡只展示了截断前缀，若冻结完整 lastContent，未展示的尾部
+      // 会被整段剥掉而丢失；再次换卡时旧卡展示的是上一轮增量，不得回写完整快照。
+      const shownPrefixOf = (text) => {
+        const notice = `\n\n${t('内容较长，生成完成后将分段发送完整回答。')}`;
+        return text.length <= MAX_STREAM_CHARS
+          ? text
+          : streamTextPrefix(text, MAX_STREAM_CHARS - notice.length);
+      };
       const controller = {
         get messageId() {
           return activeCard.messageId;
         },
-        rotate: async () => {
+        interactionPresented: () => {
+          awaitingPresentation = false;
+        },
+        rotate: () => enqueue(async () => {
           if (rotating) return;
           rotating = true;
+          awaitingPresentation = true;
+          const shownPrefix = shownPrefixOf(activeView);
           try {
             await this.#updateStreamCard(
               activeCard,
-              `${streamPreview(lastContent)}\n\n${t('⤵️ 最终结果见下方')}`,
+              `${streamPreview(shownPrefix)}\n\n${t('⤵️ 最终结果见下方')}`,
             );
+            // Tool/status messages remain visible but never extend the text
+            // prefix. Only a successfully displayed text snapshot advances it.
+            if (activeTextPrefix !== null) frozenContent = activeTextPrefix;
             await this.#finishStreamCard(activeCard);
           } catch (error) {
             // 明确降级：定格失败不阻塞交互呈现，旧卡保留原内容。
             console.warn('[dsh-feishu] unable to finalize the superseded stream card:', error.message);
           }
-        },
-        setContent: async (content) => {
+        }),
+        setContent: (content, { transient = false } = {}) => enqueue(async () => {
           const next = String(content ?? '') || '…';
-          const card = await ensureActiveCard();
-          await this.#updateStreamCard(card, streamPreview(next));
-          // Updates are replaceable snapshots, including progress/tool text.
-          // Retain the full latest snapshot even when its preview is unchanged.
+          // Retain the latest snapshot even if it is a replay or a held write.
           lastContent = next;
-        },
+          lastContentIsTransient = transient;
+          const visible = transient ? next : applyFrozenDedup(next);
+          if (visible === '') return; // 重放快照不建卡不写卡
+          if (awaitingPresentation) return; // 换卡挂起：视图已推进，仅挂起卡片写入
+          const card = await ensureActiveCard();
+          await this.#updateStreamCard(card, streamPreview(visible));
+          activeView = visible;
+          const previousPrefix = frozenContent !== null && next.startsWith(frozenContent)
+            ? frozenContent
+            : '';
+          activeTextPrefix = transient ? null : previousPrefix + shownPrefixOf(visible);
+        }),
       };
 
       await input.markdown(controller);
-      const chunks = splitStreamContent(lastContent);
-      for (const [index, chunk] of chunks.entries()) {
-        const card = index === 0
-          ? await ensureActiveCard()
-          : await this.#createStreamCard(chatId, options);
-        if (index > 0) cards.push(card);
-        await this.#updateStreamCard(card, chunk);
-        await this.#finishStreamCard(card);
-      }
+      await enqueue(async () => {
+        // 终稿强制解除挂起：异常路径下呈现通知缺失时仍可收尾。
+        awaitingPresentation = false;
+        // Recompute from the final snapshot, including an empty delta, rather
+        // than retaining the last nonempty progress/tool view as the answer.
+        const finalView = (lastContentIsTransient ? lastContent : applyFrozenDedup(lastContent))
+          || lastContent;
+        const chunks = splitStreamContent(finalView);
+        for (const [index, chunk] of chunks.entries()) {
+          const card = index === 0
+            ? await ensureActiveCard()
+            : await this.#createStreamCard(chatId, options);
+          if (index > 0) cards.push(card);
+          await this.#updateStreamCard(card, chunk);
+          await this.#finishStreamCard(card);
+        }
+      });
       return {
         messageId: cards[0].messageId,
         providerMessageIds: cards.map((card) => card.messageId),
@@ -507,14 +568,16 @@ export class VerifiedFeishuChannel {
     return messageId;
   }
 
-  async #recall(messageId) {
+  async #recall(messageId, label = 'streaming card') {
     try {
       const response = await this.#client.im.v1.message.delete({
         path: { message_id: messageId },
       });
       assertApiSuccess('Feishu message delete', response);
+      return true;
     } catch (error) {
-      console.warn('[bridge] unable to recall a failed streaming card:', error.message);
+      console.warn(`[bridge] unable to recall ${label}:`, error.message);
+      return false;
     }
   }
 
@@ -528,6 +591,11 @@ export class VerifiedFeishuChannel {
     return reactionId;
   }
 
+  /** Delete one previously sent message (step-push heartbeat cleanup). */
+  async recallMessage(messageId) {
+    return this.#recall(messageId, 'thinking status heartbeat');
+  }
+
   async removeReaction(messageId, reactionId) {
     assertApiSuccess('Feishu reaction.delete', await this.#client.im.v1.messageReaction.delete({
       path: { message_id: messageId, reaction_id: reactionId },