@xmanrui/dsh-im 4.11.0 → 4.13.0

package/src/channels/dingtalk/dingtalk-api.mjs

@@ -3,6 +3,7 @@ import { extname } from 'node:path';
 
 import { fetchImageBuffer, ImagePromptError } from '../shared/image-prompt.mjs';
 import { t } from '../shared/i18n.mjs';
+import { DINGTALK_MENU_TEMPLATE_ID, dingtalkMenuCardData } from './dingtalk-menu.mjs';
 
 export const DINGTALK_REGISTRATION_BASE_URL = 'https://oapi.dingtalk.com/';
 export const DINGTALK_API_BASE_URL = 'https://api.dingtalk.com/';
@@ -876,6 +877,38 @@ export function createDingtalkApi({
       }
     },
 
+    async createMenuCard({ clientId, clientSecret, target, data, signal }) {
+      const normalizedTarget = normalizeCardTarget(target);
+      const token = await accessToken({ clientId, clientSecret, signal });
+      const cardInstanceId = `dsh_menu_${randomUUID()}`;
+      const headers = { 'x-acs-dingtalk-access-token': token };
+      await cardRequest('v1.0/card/instances/createAndDeliver', {
+        body: {
+          ...cardDeliverBody(cardInstanceId, normalizedTarget, clientId),
+          cardTemplateId: DINGTALK_MENU_TEMPLATE_ID,
+          outTrackId: cardInstanceId,
+          cardData: dingtalkMenuCardData(data),
+          callbackType: 'STREAM',
+          imGroupOpenSpaceModel: { supportForward: false },
+          imRobotOpenSpaceModel: { supportForward: false },
+        },
+        headers, signal, action: '菜单卡片创建',
+      });
+      return { cardInstanceId };
+    },
+
+    async updateMenuCard({ clientId, clientSecret, cardInstanceId, data, signal }) {
+      if (!nonEmptyString(cardInstanceId)) throw new TypeError('cardInstanceId is required');
+      const token = await accessToken({ clientId, clientSecret, signal });
+      await cardRequest('v1.0/card/instances', {
+        method: 'PUT',
+        body: { outTrackId: cardInstanceId, cardData: dingtalkMenuCardData(data),
+          cardUpdateOptions: { updateCardDataByKey: true } },
+        headers: { 'x-acs-dingtalk-access-token': token }, signal, action: '菜单卡片更新',
+      });
+      return true;
+    },
+
     async createAiCard({ clientId, clientSecret, target, initialText, signal }) {
       const appKey = nonEmptyString(clientId);
       const appSecret = nonEmptyString(clientSecret);

package/src/channels/dingtalk/dingtalk-bridge.mjs

@@ -1,3 +1,4 @@
+import { createDeferredDeliveryCoordinator, deferredOutcomeText } from '../shared/deferred-delivery-coordinator.mjs';
 import {
   DINGTALK_DONE_REACTION_NAME,
   DINGTALK_ERROR_REACTION_NAME,
@@ -6,6 +7,7 @@ import {
   splitDingtalkText,
 } from './dingtalk-api.mjs';
 import { createDingTalkCardStream } from './dingtalk-card-stream.mjs';
+import { dingtalkMenuSnapshot, dingtalkMenuCommand, isDingtalkMenuCommand } from './dingtalk-menu.mjs';
 import {
   harnessAnswerForQuestion,
   harnessQuestionText,
@@ -76,6 +78,7 @@ const HELP_TEXT_LINES = [
   '钉钉机器人已连接 DeepSeek Harness。',
   '',
   '直接发送文字、图片或文件即可继续当前会话。',
+  '/m 或 /menu  打开下拉操作菜单',
   '/new  开启一个全新会话',
   '/compact  压缩当前会话的较早上下文',
   '/history [数量]  查看最近历史消息（默认 3 条，最多 5 条）',
@@ -475,6 +478,7 @@ export class DingtalkHarnessBridge {
   #clientSecret;
   #harness;
   #state;
+  #deferred;
   #contextEnhancement;
   #accessPolicy;
   #status;
@@ -488,6 +492,7 @@ export class DingtalkHarnessBridge {
   #interactionKeys = new Map();
   #interactionTasks = new Set();
   #commandTasks = new Set();
+  #menus = new Map();
   // Keep the accepted configuration through the existing queue/reply lifecycle.
   #acceptedMessageIds = new Map();
   #approvals;
@@ -529,6 +534,9 @@ export class DingtalkHarnessBridge {
       : 5_000;
     this.#maxMessageChars = maxMessageChars;
     this.#signal = signal;
+    this.#deferred = createDeferredDeliveryCoordinator({ harness, state, signal, logger,
+      deliver: (entry, outcome) => this.#deliverDeferredOutcome(entry, outcome),
+    });
     ensureStats(this.#status);
     this.#refreshPendingSenders();
   }
@@ -574,6 +582,7 @@ export class DingtalkHarnessBridge {
         text: commandText,
         hasImages: hasInboundImages(promptMessage),
         hasFiles: hasInboundFiles(promptMessage),
+        ...(isDingtalkMenuCommand(commandText) ? { isCommand: true } : {}),
       });
       if (!access.allowed) {
         this.#acceptedMessageIds.set(messageId, null);
@@ -617,7 +626,8 @@ export class DingtalkHarnessBridge {
         statusReaction,
       ));
     }
-    if (direct && sessionWebhook && (batchCommand || batchStatus.phase === 'collecting')) {
+    if (direct && sessionWebhook && !isDingtalkMenuCommand(commandText)
+      && (batchCommand || batchStatus.phase === 'collecting')) {
       const exactBatchStart = /^\/batch$/iu.test(commandText);
       const result = exactBatchStart
         && batchStatus.phase === 'idle'
@@ -652,7 +662,10 @@ export class DingtalkHarnessBridge {
         ));
       }
     }
-    const commandRunner = isHistoryCommand(commandText) ? runHistoryCommand
+    const commandRunner = isDingtalkMenuCommand(commandText)
+      && !hasInboundFiles(promptMessage) && !hasInboundImages(promptMessage)
+      ? async () => { await this.#showMenu(message, key); }
+      : isHistoryCommand(commandText) ? runHistoryCommand
       : hasInboundFiles(promptMessage) ? null : isControlCommand(commandText)
       ? runControlCommand
       : (isModelCommand(commandText)
@@ -773,6 +786,111 @@ export class DingtalkHarnessBridge {
     return finish(this.#enqueueMessage(message, messageId, sender, key, { statusReaction }));
   }
 
+  async #showMenu(message, key) {
+    if (typeof this.#api.createMenuCard !== 'function') {
+      await this.#send(message.sessionWebhook, helpText(), this.#atUsersFor(message));
+      return;
+    }
+    const snapshot = await dingtalkMenuSnapshot(this.#harness, this.#state, key, this.#signal);
+    const now = Date.now();
+    for (const [id, entry] of this.#menus) {
+      if (entry.expiresAt <= now || entry.key === key) this.#menus.delete(id);
+    }
+    while (this.#menus.size >= 256) this.#menus.delete(this.#menus.keys().next().value);
+    const { cardInstanceId } = await this.#api.createMenuCard({
+      clientId: this.#clientId, clientSecret: this.#clientSecret,
+      target: cardTarget(message, senderStaffId(message)), data: snapshot.data, signal: this.#signal,
+    });
+    this.#menus.set(cardInstanceId, {
+      ...snapshot, key, message, cardInstanceId, expiresAt: now + 30 * 60_000, busy: false,
+    });
+  }
+
+  acceptCard(callback, messageId) {
+    if (this.#signal?.aborted || !nonEmptyString(messageId) || this.#state.hasSeen(messageId)) {
+      return Promise.resolve();
+    }
+    const entry = this.#menus.get(callback?.outTrackId);
+    if (!entry || entry.busy || entry.expiresAt <= Date.now()
+      || callback?.userId !== senderStaffId(entry.message)) return Promise.resolve();
+    const command = dingtalkMenuCommand(entry, callback);
+    if (!command) return Promise.resolve();
+    entry.busy = true;
+    let task;
+    task = this.#processMenuAction(entry, command, messageId).catch(async (error) => {
+      if (this.#signal?.aborted) return;
+      this.#status.lastError = error?.message ?? String(error);
+      this.#logger.warn?.('[dsh-dingtalk] menu action failed', safeErrorDiagnostic(error));
+      await this.#api.updateMenuCard({
+        clientId: this.#clientId, clientSecret: this.#clientSecret,
+        cardInstanceId: entry.cardInstanceId,
+        data: { notice: t('操作未完成，请重新发送 /m 后重试。') }, signal: this.#signal,
+      }).catch(() => undefined);
+    }).finally(() => { entry.busy = false; this.#commandTasks.delete(task); });
+    this.#commandTasks.add(task);
+    return task;
+  }
+
+  async #processMenuAction(entry, command, messageId) {
+    await this.#state.markSeen(messageId);
+    const { key, message } = entry;
+    const options = {
+      signal: this.#signal, isDirect: String(message.conversationType) === '1',
+      pendingInteraction: this.#pendingInteractions.has(key) || this.#approvals.hasPending(key),
+      control: { owner: this, key }, deferredDelivery: this.#deferred,
+    };
+    const access = evaluateInboundAccess(this.#accessPolicy, {
+      conversationType: options.isDirect ? 'direct' : 'group',
+      senderIds: senderStaffId(message), text: command, isCommand: true,
+    });
+    let result;
+    if (!access.allowed) {
+      await this.#api.updateMenuCard({
+        clientId: this.#clientId, clientSecret: this.#clientSecret,
+        cardInstanceId: entry.cardInstanceId,
+        data: { notice: t(COMMAND_PERMISSION_DENIED_MESSAGE) }, signal: this.#signal,
+      });
+      return;
+    }
+    if (entry.workspace !== this.#harness.currentWorkspace?.()
+      || entry.sessionId !== this.#state.sessionFor(key)) {
+      result = { message: t('会话或工作区已变化，菜单已刷新，请重新选择。') };
+    } else if ((this.#queues.has(key) || options.pendingInteraction || this.#batchInputs.status(key).phase !== 'idle')
+      && !['/stop', '/help', '/status', '/history'].includes(command)) {
+      result = { message: t('当前任务尚未结束，请先停止任务或等待完成后再操作。') };
+    } else if (command === '/new') {
+      await this.#state.clearSession(key);
+      result = { message: t('已开启新会话。请发送你的问题。') };
+    } else if (command === '/status') {
+      await this.#harness.ensureRunning({ signal: this.#signal });
+      result = { message: t('钉钉机器人与 DeepSeek Harness 连接正常。') };
+    } else if (command === '/help') {
+      result = { message: helpText() };
+    } else {
+      result = await runWorkspaceCommand(command, this.#harness, key)
+        ?? await runCompactCommand(command, this.#harness, this.#state, key, options)
+        ?? await runControlCommand(command, this.#harness, this.#state, key, options)
+        ?? await runHistoryCommand(command, this.#harness, this.#state, key, options)
+        ?? await runModelCommand(command, this.#harness, this.#state, key, options)
+        ?? await runPresetCommand(command, this.#harness, this.#state, key, options);
+    }
+    if (result?.stopped) await Promise.allSettled([
+      this.#cancelPendingInteraction(key), this.#approvals.closeRoute(key),
+    ]);
+    const snapshot = await dingtalkMenuSnapshot(this.#harness, this.#state, key, this.#signal);
+    if (command === '/help' || command === '/history') {
+      for (const reply of result?.messages ?? [result?.message]) {
+        if (reply) await this.#send(message.sessionWebhook, reply, this.#atUsersFor(message));
+      }
+    } else snapshot.data.notice = (result?.message ?? '').slice(0, 300);
+    await this.#api.updateMenuCard({
+      clientId: this.#clientId, clientSecret: this.#clientSecret,
+      cardInstanceId: entry.cardInstanceId, data: snapshot.data, signal: this.#signal,
+    });
+    Object.assign(entry, snapshot);
+    this.#status.lastError = null;
+  }
+
   #runReactionCall(method, target, reactionName, kind) {
     const controller = new AbortController();
     const operation = Promise.resolve().then(() => this.#api[method]({
@@ -936,6 +1054,19 @@ export class DingtalkHarnessBridge {
     return { content: text };
   }
 
+  async #deliverDeferredOutcome(entry, outcome) {
+    const text = deferredOutcomeText(outcome);
+    if (outcome.found && ['createAiCard', 'updateAiCard', 'finishAiCard'].every((name) => typeof this.#api[name] === 'function')) {
+      const card = createDingTalkCardStream({ api: this.#api, clientId: this.#clientId,
+        clientSecret: this.#clientSecret, target: entry.target, signal: this.#signal, logger: this.#logger });
+      if (await card.start(t(CARD_INITIAL_TEXT)) && await card.finish(text)) return true;
+      this.#logger.warn?.('[dsh-dingtalk] deferred card unavailable; sending robot text');
+    }
+    await this.#api.sendRobotText({ clientId: this.#clientId, clientSecret: this.#clientSecret,
+      target: entry.target, text, signal: this.#signal });
+    return true;
+  }
+
   async waitForIdle() {
     await Promise.allSettled([
       ...this.#queues.values(),
@@ -945,6 +1076,7 @@ export class DingtalkHarnessBridge {
       ...this.#interactionTasks,
       ...this.#commandTasks,
     ]);
+    await this.#deferred.whenIdle();
   }
 
   async #processFastCommand(message, messageId, key, sessionWebhook, prompt, runner) {
@@ -966,6 +1098,7 @@ export class DingtalkHarnessBridge {
         pendingInteraction: this.#pendingInteractions.has(key)
           || this.#approvals.hasPending(key),
         control: { owner: this, key },
+        deferredDelivery: this.#deferred,
       },
     );
     if (result?.stopped) {
@@ -1157,6 +1290,7 @@ export class DingtalkHarnessBridge {
         if (cardStarted) cardStartedAt = startedAt;
       }
       const { answer, artifacts = [] } = await askInWorkspaceSession({
+        deferredDelivery: () => ({ coordinator: this.#deferred, target: { ...cardTarget(message, sender), robotCode: this.#clientId } }),
         harness: this.#harness,
         state: this.#state,
         key,

package/src/channels/dingtalk/dingtalk-menu.mjs

@@ -0,0 +1,91 @@
+import { randomUUID } from 'node:crypto';
+import { workspacePathSnapshot } from '../shared/workspace-command.mjs';
+import { t } from '../shared/i18n.mjs';
+
+export const DINGTALK_MENU_TEMPLATE_ID = '9ca31362-e5b3-409c-a694-6993706a6004.schema';
+export const DINGTALK_CARD_TOPIC = '/v1.0/card/instances/callback';
+export const DINGTALK_MENU_BUTTONS = Object.freeze({
+  new: '/new', history: '/history', stop: '/stop', compact: '/compact',
+  status: '/status', help: '/help',
+});
+
+export function isDingtalkMenuCommand(text) {
+  return typeof text === 'string' && /^\/(?:m|menu)$/iu.test(text.trim());
+}
+
+const presetCommand = (id) => `/preset ${/^\d+$/u.test(id) ? 'id:' : ''}${id}`;
+
+// Keep exact commands alongside the displayed options. Never interpret a callback
+// as a command supplied by the client or as a prompt for the model.
+export async function dingtalkMenuSnapshot(harness, state, key, signal) {
+  const workspace = harness.currentWorkspace?.();
+  const sessionId = state.sessionFor(key);
+  const options = { signal };
+  const results = await Promise.allSettled([
+    workspacePathSnapshot(harness, options),
+    harness.listWorkspaceSessions?.(workspace, options),
+    (async () => {
+      const session = sessionId ? harness.workspaceSession?.(sessionId) : null;
+      return typeof session?.models === 'function'
+        ? session.models(options) : harness.listModels?.(options);
+    })(),
+    harness.agentPresetSettings?.(options),
+  ]);
+  signal?.throwIfAborted();
+  if (harness.currentWorkspace?.() !== workspace || state.sessionFor(key) !== sessionId) {
+    throw new Error(t('会话或工作区已变化，请重新发送 /m。'));
+  }
+  const [paths, listed, catalog, settings] = results.map((r) => r.status === 'fulfilled' ? r.value : null);
+  const selections = {
+    session: [[t('新会话'), '/new'], ...(listed?.sessions ?? []).map((item) => [
+      item.title || item.sessionId, `/session ${item.sessionId}`,
+    ])],
+    workspace: (paths?.paths ?? (workspace ? [workspace] : [])).map((path) => [path, `/workspace ${path}`]),
+    preset: [[t('跟随 Host 默认'), '/preset --default'], ...(settings?.agentPresetCatalog?.items ?? []).map((item) => [
+      item.label || item.id, presetCommand(item.id),
+    ])],
+    model: (catalog?.groups ?? []).flatMap((group) => group.models.map((model) => [
+      `${model.name} (${group.id})`, `/model ${group.id}/${model.id}`,
+    ])),
+  };
+  const current = {
+    session: sessionId ? `/session ${sessionId}` : '/new',
+    workspace: `/workspace ${workspace}`,
+    preset: settings?.agentPreset ? presetCommand(settings.agentPreset) : '/preset --default',
+    model: catalog?.current ? `/model ${catalog.current.provider}/${catalog.current.model}` : null,
+  };
+  const data = { revision: randomUUID(), notice: '' };
+  for (const [name, entries] of Object.entries(selections)) {
+    // Keep the active value visible even when the session listing is paginated.
+    if (current[name] && !entries.some(([, command]) => command === current[name])) {
+      entries.unshift([name === 'session' ? sessionId : current[name].replace(/^\/\w+\s+/u, ''), current[name]]);
+    }
+    data[`${name}_options`] = entries.map(([label], index) => ({
+      value: String(index), text: { zh_CN: label, en_US: label },
+    }));
+    data[`${name}_index`] = entries.findIndex(([, command]) => command === current[name]);
+  }
+  return { workspace, sessionId, selections, data };
+}
+
+export function dingtalkMenuCommand(entry, callback) {
+  let content;
+  try {
+    content = typeof callback?.content === 'string' ? JSON.parse(callback.content) : callback?.content;
+  } catch { return null; }
+  const { actionIds, params } = content?.cardPrivateData ?? {};
+  if (!Array.isArray(actionIds) || actionIds.length !== 1
+    || params?.revision !== entry.data.revision) return null;
+  const action = actionIds[0];
+  if (Object.hasOwn(DINGTALK_MENU_BUTTONS, action)) return DINGTALK_MENU_BUTTONS[action];
+  const entries = entry.selections[action];
+  const index = params[action]?.index;
+  if (!Array.isArray(entries) || !Number.isSafeInteger(index) || index < 0) return null;
+  return entries[index]?.[1] ?? null;
+}
+
+export function dingtalkMenuCardData(data) {
+  return { cardParamMap: Object.fromEntries(Object.entries(data).map(([key, value]) => [
+    key, typeof value === 'string' ? value : JSON.stringify(value),
+  ])) };
+}

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

@@ -7,6 +7,7 @@ import { sendRememberedConnectionTest } from '../shared/connection-test.mjs';
 import { t } from '../shared/i18n.mjs';
 import { captureContextEnhancement } from '../shared/context-enhancement.mjs';
 import { dingtalkRuntimeStartError } from './connection-error.mjs';
+import { DINGTALK_CARD_TOPIC } from './dingtalk-menu.mjs';
 
 function nonEmptyString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
@@ -271,6 +272,22 @@ export class DingtalkRuntime {
       const client = this.#client;
       const bridge = this.#bridge;
       startStage = 'dingtalk-stream-listener-failed';
+      client.registerCallbackListener(DINGTALK_CARD_TOPIC, (response) => {
+        if (this.#client !== client || this.#bridge !== bridge) return;
+        const messageId = nonEmptyString(response?.headers?.messageId);
+        if (messageId) {
+          try { client.socketCallBackResponse(messageId, { success: true }); }
+          catch { this.#logger.warn?.('[dsh-dingtalk] unable to acknowledge a card callback'); }
+        }
+        const task = Promise.resolve().then(async () => {
+          if (this.#bridge !== bridge) return;
+          const callback = typeof response?.data === 'string' ? JSON.parse(response.data) : response?.data;
+          await bridge.acceptCard(callback, messageId);
+        }).catch(() => {
+          if (!signal.aborted) this.#logger.warn?.('[dsh-dingtalk] card callback processing failed');
+        }).finally(() => this.#callbackTasks.delete(task));
+        this.#callbackTasks.add(task);
+      });
       client.registerCallbackListener(this.#topic, (response) => {
         if (this.#client !== client || this.#bridge !== bridge) return;
         const callbackMessageId = nonEmptyString(response?.headers?.messageId);

package/src/channels/dingtalk/state-store.mjs

@@ -1,3 +1,4 @@
+import { deferredStateAccess, normalizeDeferredState } from '../shared/deferred-state.mjs';
 import { randomUUID } from 'node:crypto';
 import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
@@ -114,6 +115,7 @@ function normalizeState(value) {
   return {
     version: 1,
     sessions,
+    ...(value.deferred ? { deferred: normalizeDeferredState(value.deferred) } : {}),
     seenMessageIds: Array.isArray(value.seenMessageIds)
       ? [...new Set(value.seenMessageIds.map(nonEmptyString).filter(Boolean))].slice(-1_000)
       : [],
@@ -126,6 +128,7 @@ export class DingtalkStateStore {
   #path;
   #state = structuredClone(EMPTY_STATE);
   #writeQueue = Promise.resolve();
+  #deferred = deferredStateAccess(() => this.#state, () => this.#persist());
   #idFactory;
   #now;
 
@@ -150,6 +153,11 @@ export class DingtalkStateStore {
     return this;
   }
 
+  deferredEntries() { return this.#deferred.entries(); }
+  putDeferred(entry) { return this.#deferred.put(entry); }
+  patchDeferred(id, patch) { return this.#deferred.patch(id, patch); }
+  removeDeferred(id) { return this.#deferred.remove(id); }
+
   sessionFor(key) {
     return this.#state.sessions[key] ?? null;
   }

package/src/channels/feishu/bridge.mjs

@@ -56,6 +56,7 @@ import {
   workspacePathSnapshot,
 } from '../shared/workspace-command.mjs';
 import { askInWorkspaceSession } from '../shared/workspace-session.mjs';
+import { createDeferredDeliveryCoordinator, deferredOutcomeText } from '../shared/deferred-delivery-coordinator.mjs';
 import { captureContextEnhancement, enhanceContextContent } from '../shared/context-enhancement.mjs';
 import { deliverOutboundArtifacts } from '../shared/semantic/artifact-delivery.mjs';
 import {
@@ -505,6 +506,7 @@ export class FeishuHarnessBridge {
   #cardKeys = new Map();
   /** The global event-mux watcher (one per bridge). */
   #eventWatcher = null;
+  #deferred;
   /** Serializes completion work per session without blocking unrelated sessions. */
   #eventTails = new Map();
   /** Coalesces baseline compensation and records whether a trailing pass is needed. */
@@ -581,10 +583,16 @@ export class FeishuHarnessBridge {
     this.#approvals = new HarnessApprovalQueue({ label: 'Feishu', logger });
     this.#signal = signal;
     ensureStatus(this.#status);
+    this.#deferred = createDeferredDeliveryCoordinator({
+      harness, state, signal, logger, watch: false,
+      deliver: (entry, outcome) => this.#deliverDeferredOutcome(entry, outcome),
+    });
     // Persisted watches must resume at runtime start, not on the first
     // message. Older hosts without the mux watcher simply skip this.
     if (typeof this.#harness?.watchHarnessEvents === 'function') {
-      queueMicrotask(() => this.#ensureEventWatcher());
+      queueMicrotask(() => {
+        this.#ensureEventWatcher();
+      });
     }
   }
 
@@ -1128,6 +1136,7 @@ export class FeishuHarnessBridge {
     // Drain to a fixed point: awaited work can register compensation or
     // another serialized tail before it settles.
     for (;;) {
+      await this.#deferred.whenIdle();
       const tasks = [
         ...this.#queues.values(),
         ...[...this.#pendingInteractions.values()].flatMap((pending) => (
@@ -1141,6 +1150,7 @@ export class FeishuHarnessBridge {
       ];
       if (tasks.length === 0) return;
       await Promise.allSettled(tasks);
+      await this.#deferred.whenIdle();
       if (this.#queues.size === 0
         && this.#interactionTasks.size === 0
         && this.#commandTasks.size === 0
@@ -1166,7 +1176,7 @@ export class FeishuHarnessBridge {
     await this.#state.markSeen(messageId);
     this.#status.lastMessageAt = new Date().toISOString();
     this.#status.messagesReceived += 1;
-    const result = await runner(
+    let result = await runner(
       nonEmptyString(message.content) ?? '',
       this.#harness,
       this.#state,
@@ -1175,6 +1185,7 @@ export class FeishuHarnessBridge {
         signal: this.#signal,
         isDirect: event.message.chat_type === 'p2p',
         hasImages: hasInboundImages(message),
+        deferredDelivery: this.#deferred,
         hasFiles: hasInboundFiles(message),
         pendingInteraction: this.#hasPendingInteraction(key),
         control: { owner: this, key },
@@ -2831,7 +2842,7 @@ export class FeishuHarnessBridge {
    */
   async #handleStop(key, chatId, replyTo = null) {
     try {
-      const result = await runControlCommand(
+      let result = await runControlCommand(
         '/stop', this.#harness, this.#state, key, {
           signal: this.#signal,
           control: { owner: this, key },
@@ -2952,6 +2963,61 @@ export class FeishuHarnessBridge {
 
   // ── Watches: read-only session tracking + completion pushes ─────────────
 
+  // ── Deferred delivery (MODEL_REPLY_TIMEOUT → late result push) ──────────
+
+  async #deliverDeferredOutcome(entry, outcome) {
+    this.#rememberTopicReply(entry.replyToMessageId, entry.key);
+    if (entry.key === managedGroupKey(entry.chatId, entry.replyToMessageId)) {
+      this.#rememberTopicRoot(entry.replyToMessageId);
+    }
+    const text = deferredOutcomeText(outcome);
+    if (outcome.found) {
+      return this.#deliverDeferredText(entry.chatId, answerTextForDelivery(text, []), entry.replyToMessageId);
+    }
+    await this.#send(entry.chatId, text, { replyTo: entry.replyToMessageId });
+    return true;
+  }
+
+  async #deliverDeferredText(chatId, markdownText, replyToMessageId) {
+    if (this.#channel?.stream) {
+      try {
+        await this.#channel.stream(chatId, {
+          markdown: async (controller) => {
+            await controller.setContent(markdownText);
+          },
+        }, {
+          ...(replyToMessageId ? { replyTo: replyToMessageId } : {}),
+          ...(this.#replyInThreadFor(replyToMessageId) ? {
+            replyInThread: true,
+            onReplyThreadId: async (threadId) => this.#registerTopicThreadId(
+              threadId,
+              replyToMessageId,
+              chatId,
+            ),
+          } : {}),
+        });
+        return true;
+      } catch (error) {
+        if (error?.deliveryOutcome === 'unknown') throw error;
+        this.#logger.warn?.(
+          '[dsh-feishu] deferred stream delivery failed; falling back to text:',
+          error.message,
+        );
+      }
+    }
+    try {
+      await this.#sendAnswerText(chatId, markdownText, {
+        deliveryId: `deferred-${Date.now()}`,
+        presentation: 'feishu-deferred-text',
+        ...(replyToMessageId ? { replyTo: replyToMessageId } : {}),
+      });
+      return true;
+    } catch (error) {
+      this.#logger.warn?.('[dsh-feishu] deferred text delivery failed:', error.message);
+      throw error;
+    }
+  }
+
   #ensureEventWatcher() {
     if (this.#eventWatcher) return;
     if (typeof this.#harness?.watchHarnessEvents !== 'function') return;
@@ -2963,6 +3029,7 @@ export class FeishuHarnessBridge {
         onSessionEvent: (payload) => this.#onHarnessEvent(payload),
         onReconnect: () => {
           void this.#compensateMissedEvents();
+          void this.#deferred.resume();
         },
       });
       Promise.resolve(this.#eventWatcher).catch((error) => {
@@ -3321,6 +3388,7 @@ export class FeishuHarnessBridge {
         .some((key) => this.#failedWatchSeqs.has(`${key}\0${sessionId}`));
       if (needsBaseline || hasFailedDelivery) await this.#compensateSession(sessionId);
       await this.#deliverCompletion(sessionId, event);
+      await this.#deferred.onEvent({ sessionId, event });
     });
   }
 
@@ -3562,6 +3630,7 @@ export class FeishuHarnessBridge {
     }
     if (!this.#channel?.stream) {
       const { answer, artifacts = [] } = await askInWorkspaceSession({
+        deferredDelivery: () => ({ coordinator: this.#deferred, chatId, replyToMessageId: messageId }),
         harness: this.#harness,
         state: this.#state,
         key,
@@ -3632,6 +3701,7 @@ export class FeishuHarnessBridge {
             },
           };
           const completed = await askInWorkspaceSession({
+            deferredDelivery: () => ({ coordinator: this.#deferred, chatId, replyToMessageId: messageId }),
             harness: this.#harness,
             state: this.#state,
             key,
@@ -3701,6 +3771,7 @@ export class FeishuHarnessBridge {
 
       this.#logger.warn?.('[dsh-feishu] native stream unavailable; using text fallback:', error.message);
       const { answer, artifacts = [] } = await askInWorkspaceSession({
+        deferredDelivery: () => ({ coordinator: this.#deferred, chatId, replyToMessageId: messageId }),
         harness: this.#harness,
         state: this.#state,
         key,

package/src/channels/feishu/state-store.mjs

@@ -1,3 +1,4 @@
+import { deferredStateAccess, normalizeDeferredState } from '../shared/deferred-state.mjs';
 import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 
@@ -6,6 +7,7 @@ const EMPTY_STATE = Object.freeze({
   sessions: {},
   seenMessageIds: [],
   watches: {},
+  deferred: {},
   includeArchivedSessions: false,
   topics: {},
 });
@@ -25,6 +27,7 @@ export class StateStore {
   #path;
   #state = structuredClone(EMPTY_STATE);
   #writeQueue = Promise.resolve();
+  #deferred = deferredStateAccess(() => this.#state, () => this.#persist());
 
   constructor(path) {
     this.#path = path;
@@ -38,6 +41,7 @@ export class StateStore {
         sessions: parsed.sessions && typeof parsed.sessions === 'object' ? parsed.sessions : {},
         seenMessageIds: Array.isArray(parsed.seenMessageIds) ? parsed.seenMessageIds.slice(-1000) : [],
         watches: parsed.watches && typeof parsed.watches === 'object' ? parsed.watches : {},
+        deferred: normalizeDeferredState(parsed.deferred),
         includeArchivedSessions: typeof parsed.includeArchivedSessions === 'boolean'
           ? parsed.includeArchivedSessions
           : false,
@@ -50,6 +54,11 @@ export class StateStore {
     return this;
   }
 
+  deferredEntries() { return this.#deferred.entries(); }
+  putDeferred(entry) { return this.#deferred.put(entry); }
+  patchDeferred(id, patch) { return this.#deferred.patch(id, patch); }
+  removeDeferred(id) { return this.#deferred.remove(id); }
+
   sessionFor(key) {
     return this.#state.sessions[key] ?? null;
   }
@@ -138,6 +147,8 @@ export class StateStore {
     return [...ids];
   }
 
+  // ── Deferred delivery (persisted: surviving restarts) ───────────────────
+
   // ── Managed Feishu topics (thread_id → root message, persisted) ────────
 
   topicRootFor(threadId) {