@xmanrui/dsh-im 4.14.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();
@@ -816,14 +829,21 @@ export class FeishuHarnessBridge {
   accept(event) {
     if (this.#signal?.aborted) return Promise.resolve();
     const messageId = nonEmptyString(event?.message?.message_id);
-    if (!messageId || isBotSender(event)) return Promise.resolve();
+    if (!messageId) return Promise.resolve();
+    const addressed = this.#isAddressed(event);
+    // Bot messages require a known, explicit group mention even in all-message mode.
+    if (isBotSender(event) && (
+      event?.message?.chat_type !== 'group'
+      || !this.#botOpenId
+      || !addressed
+      || senderOpenId(event) === this.#botOpenId
+    )) return Promise.resolve();
     if (!this.#accessPolicy && !isAllowedSender(event, this.#allowedSenderOpenIds)) {
       this.#status.messagesRejected += 1;
       this.#status.lastRejectedAt = new Date().toISOString();
       this.#logger.warn?.('[dsh-feishu] ignored a message from a sender outside the legacy allowlist');
       return Promise.resolve();
     }
-    const addressed = this.#isAddressed(event);
     if (event?.message?.chat_type !== 'p2p'
       && this.#groupResponseMode === FEISHU_GROUP_RESPONSE_MODES.MENTION
       && !addressed) {
@@ -1771,7 +1791,7 @@ export class FeishuHarnessBridge {
       : t('链接约 {minutes} 分钟后过期', { minutes: Math.max(1, Math.ceil(remaining / 60)) });
     await this.#send(chatId, [
       restarted ? t('旧授权链接已作废，已生成新的修复链接。') : t('🔧 准备补全权限与回调。'),
-      t('本次会增量添加当前缺少项：卡片回调 card.action.trigger；飞书显示为“获取单聊、群组消息”的租户权限 im:message:readonly（用于读取用户消息中的图片或文件）；im:resource（用于上传机器人发送的图片或文件）；以及原生命令面板所需的 application:app_slash_command:read / write。确认页只会显示当前缺少的项；若出现上述范围之外的配置，请取消。'),
+      t('本次会增量添加当前缺少项：卡片回调 card.action.trigger；飞书显示为“获取单聊、群组消息”的租户权限 im:message:readonly（用于读取用户消息中的图片或文件）；im:resource（用于上传机器人发送的图片或文件）；im:message.group_at_msg.include_bot:readonly（用于接收群内其他机器人 @ 当前机器人的消息）；以及原生命令面板所需的 application:app_slash_command:read / write。确认页只会显示当前缺少的项；若出现上述范围之外的配置，请取消。'),
       '',
       t('当前设备直接打开：'),
       url,
@@ -2185,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);
         }
@@ -2598,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);
@@ -3764,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;
@@ -3771,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();
@@ -3780,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);
@@ -3882,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 逐条直推
@@ -3922,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,
     });
@@ -3954,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,
@@ -3995,6 +4234,10 @@ export class FeishuHarnessBridge {
         },
       },
     });
+    } finally {
+      // 回合结束（成功/失败/中断）：停看门狗并撤回残留思考中心跳。
+      await watchdog.stop();
+    }
     markAskComplete();
     const finalStepText = pendingStep ? pendingStep.text : null;
     pendingStep = null;
@@ -4196,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;
             },
           };
@@ -4396,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) {
@@ -4411,6 +4683,7 @@ export class FeishuHarnessBridge {
         pending.claimedReplyMessageId = null;
       }
       pending.needsPresentation = true;
+      await patchAnsweredCard();
       try {
         await this.#presentInteraction(pending);
       } catch {
@@ -4431,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;
@@ -4567,6 +4842,7 @@ export class FeishuHarnessBridge {
       submitting: false,
       needsPresentation: true,
       questionMessageIds: new Set(),
+      questionCardMessageId: null,
       inactive: false,
     };
     this.#pendingInteractions.set(key, pending);
@@ -4596,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(
@@ -4610,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.
@@ -4637,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);
+}