@xmanrui/dsh-im 4.35.0 → 4.36.0

package/src/channels/feishu/multi-bot-controller.mjs

@@ -1,3 +1,4 @@
+import { ExclusiveInboundConsumers, normalizeExternalText } from './external-consumer.mjs';
 import { atConnectionStage, createConnectionDiagnostics } from '../shared/connection-error.mjs';
 import { createHash, randomUUID } from 'node:crypto';
 import { connectionTestMessage } from '../shared/connection-test.mjs';
@@ -93,6 +94,7 @@ function secretRefFor(botId) {
 function configuredBotFingerprint(config) {
   return JSON.stringify({
     id: config.id,
+    consumerMode: config.consumerMode ?? 'standalone',
     appId: config.appId,
     secretRef: config.secretRef,
     ownerOpenIds: config.ownerOpenIds,
@@ -113,6 +115,14 @@ function configuredBotFingerprint(config) {
   });
 }
 
+// Account/ownership fences must not include settings that are hot-updated on
+// the same runtime (step push, voice, slash panel or group presentation).
+function externalAccountOwnership(config) {
+  return JSON.stringify({ id: config.id, consumerMode: config.consumerMode ?? 'standalone',
+    appId: config.appId, secretRef: config.secretRef, ownerOpenIds: config.ownerOpenIds,
+    domain: config.domain, botOpenId: config.botOpenId, deletionPending: config.deletionPending === true });
+}
+
 function optionalNonEmptyString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
@@ -133,6 +143,7 @@ export class MultiBotDshFeishuController {
   #createBotId;
   #createRegistrationId;
   #runtimes = new Map();
+  #inboundConsumers = new ExclusiveInboundConsumers();
   #botErrors = new Map();
   #registrations = new Map();
   #activeAppUpdates = new Map();
@@ -594,7 +605,82 @@ export class MultiBotDshFeishuController {
       this.#assertOpen('capability-unavailable');
       return { version: 1, botId, channel: 'feishu', account,
         connected: isConnected(connectionStatus(this.#runtimes.get(botId))),
-        capabilities: ['proactive-text-checked', 'proactive-receipt-checked'] };
+        capabilities: ['proactive-text-checked', 'proactive-receipt-checked', 'exclusive-text-consumer', 'reply-text-checked', 'history-text-checked', 'thread-history-text-checked'] };
+    });
+  }
+
+  async consumeInbound(botId, { expectedFingerprint, onEvent, signal } = {}) {
+    this.#assertOpen();
+    return this.#serializeConfig(() => this.#withBotTransition(botId, async () => {
+      this.#assertOpen();
+      signal?.throwIfAborted();
+      const config = this.#requireBot(botId);
+      const account = await this.#deliveryAccount(config);
+      this.#assertOpen('capability-unavailable');
+      signal?.throwIfAborted();
+      if (account.fingerprint !== expectedFingerprint)
+        throw Object.assign(new Error('account-changed'), { code: 'account-changed' });
+      const dispose = this.#inboundConsumers.register(botId, { fingerprint: expectedFingerprint, onEvent, signal });
+      try {
+        const saved = await this.#configStore.saveBot({ ...config, consumerMode: 'external-consumer' });
+        this.#assertOpen('capability-unavailable');
+        signal?.throwIfAborted();
+        const resolved = await this.#credentials.resolve(saved.secretRef);
+        this.#assertOpen('capability-unavailable');
+        signal?.throwIfAborted();
+        if (!resolved?.value) throw Object.assign(new Error('account-unverified'), { code: 'account-unverified' });
+        await this.#startRuntime(saved, resolved.value);
+        signal?.throwIfAborted();
+        this.#touch();
+        return dispose;
+      } catch (error) {
+        dispose();
+        throw error;
+      }
+    }));
+  }
+
+  async historyChecked(botId, route, query, { expectedFingerprint, signal } = {}) {
+    this.#assertOpen('capability-unavailable');
+    return this.#withBotTransition(botId, async () => {
+      this.#assertOpen('capability-unavailable');
+      signal?.throwIfAborted();
+      const config = this.#requireBot(botId);
+      const account = await this.#deliveryAccount(config);
+      this.#assertOpen('capability-unavailable');
+      signal?.throwIfAborted();
+      if (account.fingerprint !== expectedFingerprint)
+        throw Object.assign(new Error('account-changed'), { code: 'account-changed' });
+      const runtime = this.#runtimes.get(botId);
+      if (config.consumerMode !== 'external-consumer' || !isConnected(connectionStatus(runtime))
+        || typeof runtime.historyChecked !== 'function')
+        throw Object.assign(new Error('capability-unavailable'), { code: 'capability-unavailable' });
+      const leaseSignal = this.#inboundConsumers.signalFor(botId, expectedFingerprint);
+      const readSignal = signal ? AbortSignal.any([signal, leaseSignal]) : leaseSignal;
+      const result = await runtime.historyChecked({ botId, appId: config.appId,
+        botOpenId: config.botOpenId, fingerprint: account.fingerprint }, route, query, { signal: readSignal });
+      this.#assertOpen('capability-unavailable');
+      readSignal.throwIfAborted();
+      return result;
+    });
+  }
+
+  async replyChecked(botId, route, text, { expectedFingerprint, signal } = {}) {
+    this.#assertOpen();
+    return this.#withBotTransition(botId, async () => {
+      this.#assertOpen();
+      const config = this.#requireBot(botId);
+      const account = await this.#deliveryAccount(config);
+      this.#assertOpen('capability-unavailable');
+      signal?.throwIfAborted();
+      if (account.fingerprint !== expectedFingerprint)
+        throw Object.assign(new Error('account-changed'), { code: 'account-changed' });
+      signal?.throwIfAborted();
+      const runtime = this.#runtimes.get(botId);
+      if (config.consumerMode !== 'external-consumer' || !isConnected(connectionStatus(runtime))
+        || typeof runtime.replyChecked !== 'function')
+        throw Object.assign(new Error('capability-unavailable'), { code: 'capability-unavailable' });
+      return runtime.replyChecked(route, text, { signal });
     });
   }
 
@@ -628,6 +714,18 @@ export class MultiBotDshFeishuController {
     });
   }
 
+  async presentSessionSyncApproval(botId, target, interaction, options = {}) {
+    this.#assertOpen();
+    return this.#withBotTransition(botId, async () => {
+      this.#assertOpen();
+      this.#requireBot(botId);
+      const runtime = this.#runtimes.get(botId);
+      if (!isConnected(connectionStatus(runtime))
+        || typeof runtime.presentSessionSyncApproval !== 'function') return false;
+      return runtime.presentSessionSyncApproval(target, interaction, options);
+    });
+  }
+
   async disconnectBot(botId) {
     this.#assertOpen();
     // An operational pause only: credentials/config remain durable, so the
@@ -761,6 +859,7 @@ export class MultiBotDshFeishuController {
   async close() {
     if (this.#closed) return;
     this.#closed = true;
+    this.#inboundConsumers.close();
     const appUpdateProcessing = [];
     for (const record of this.#registrations.values()) {
       const state = record.manager.status().state;
@@ -1352,11 +1451,39 @@ export class MultiBotDshFeishuController {
 
   async #startRuntime(config, appSecret) {
     await this.#stopRuntime(config.id);
-    const runtime = await atConnectionStage('runtime.prepare', () => this.#createRuntime({
+    let runtime;
+    runtime = await atConnectionStage('runtime.prepare', () => this.#createRuntime({
       botId: config.id,
       config,
       appSecret,
       repair: this.#runtimeRepairCapability(config.id),
+      acceptExternal: async (event, { signal } = {}) => {
+        const assertCurrent = () => {
+          this.#assertOpen('capability-unavailable');
+          signal?.throwIfAborted();
+          if (this.#runtimes.get(config.id) !== runtime)
+            throw Object.assign(new Error('consumer-unavailable'), { code: 'consumer-unavailable' });
+          const current = this.#requireBot(config.id);
+          if (current.consumerMode !== 'external-consumer'
+            || externalAccountOwnership(current) !== externalAccountOwnership(config))
+            throw Object.assign(new Error('account-changed'), { code: 'account-changed' });
+          return current;
+        };
+        const evidence = await this.#withBotTransition(config.id, async () => {
+          const current = assertCurrent();
+          const account = await this.#deliveryAccount(current);
+          assertCurrent();
+          return normalizeExternalText(event, { botId: current.id, appId: current.appId,
+            botOpenId: current.botOpenId, fingerprint: account.fingerprint });
+        });
+        // Never hold the account queue across application work: onEvent may
+        // await a checked read/reply, and stop must be able to abort its signal.
+        assertCurrent();
+        if (evidence === null) return { accepted: true, ignored: true };
+        const result = await this.#inboundConsumers.accept(config.id, evidence, signal);
+        assertCurrent();
+        return result;
+      },
     }));
     this.#runtimes.set(config.id, runtime);
     try {
@@ -1398,6 +1525,7 @@ export class MultiBotDshFeishuController {
   async #deleteBot(botId) {
     let config = this.#configStore.getBot(botId);
     if (!config) return;
+    this.#inboundConsumers.remove(botId);
     if (!config.deletionPending) {
       config = await this.#configStore.saveBot({ ...config, deletionPending: true });
     }

package/src/channels/feishu/nearby-history.mjs

@@ -0,0 +1,72 @@
+function refuse(code) { throw Object.assign(new Error(code), { code }); }
+const count = value => Number.isInteger(value) && value >= 0 && value <= 20;
+
+export async function readNearbyHistory(readPage, route, query, anchorTime) {
+  const before = query.beforeCount ?? 10;
+  const after = query.afterCount ?? 5;
+  if (!count(before) || !count(after)) refuse('bad-request');
+  const start = Math.max(0, anchorTime - 300000);
+  const end = anchorTime + 300000;
+  const window = { start: Math.floor(start / 1000), end: Math.floor(end / 1000) + 1 };
+  let state = { phase: 'window', before: 0, after: 0 };
+  if (query.cursor !== undefined) {
+    try {
+      const decoded = JSON.parse(Buffer.from(query.cursor, 'base64url').toString());
+      if (decoded.version !== 1 || decoded.anchor !== route.messageId || decoded.at !== anchorTime
+        || decoded.minBefore !== before || decoded.minAfter !== after || decoded.limit !== query.limit
+        || !['window', 'before', 'after'].includes(decoded.phase)
+        || !count(decoded.before) || !count(decoded.after)
+        || (decoded.page !== undefined && (typeof decoded.page !== 'string' || !decoded.page || decoded.page.length > 3000)))
+        refuse('bad-request');
+      state = decoded;
+    } catch { refuse('bad-request'); }
+  }
+  const params = { container_id_type: 'chat', container_id: route.conversationId,
+    page_size: query.limit, with_sender_name: true,
+    sort_type: state.phase === 'before' ? 'ByCreateTimeDesc' : 'ByCreateTimeAsc',
+    ...(state.page === undefined ? {} : { page_token: state.page }),
+    ...(state.phase === 'window' ? { start_time: String(window.start), end_time: String(window.end) }
+      : state.phase === 'before' ? { end_time: String(window.start + 1) }
+        : { start_time: String(Math.floor(end / 1000)) }),
+  };
+  // Lark defaults an omitted end_time to now and rejects a future start_time.
+  // A fresh anchor has no existing messages beyond its future window boundary.
+  const page = state.phase === 'after' && end >= Date.now()
+    ? { events: [], omitted: 0, hasMore: false }
+    : await readPage(params);
+  const events = [];
+  for (const event of page.events) {
+    const at = Date.parse(event.at);
+    if (!Number.isFinite(at)) refuse('history-unavailable');
+    if (state.phase === 'window') {
+      if (at < start || at > end) continue;
+      events.push(event);
+      if (event.messageId !== route.messageId && at < anchorTime) state.before = Math.min(20, state.before + 1);
+      if (event.messageId !== route.messageId && at > anchorTime) state.after = Math.min(20, state.after + 1);
+    } else if (state.phase === 'before' && at < start && state.before < before) {
+      events.push(event); state.before++;
+    } else if (state.phase === 'after' && at > end && state.after < after) {
+      events.push(event); state.after++;
+    }
+  }
+  const needsPage = page.hasMore && (state.phase === 'window'
+    || (state.phase === 'before' ? state.before < before : state.after < after));
+  if (needsPage) {
+    if (page.nextCursor === state.page) refuse('history-unavailable');
+    state.page = page.nextCursor;
+  } else {
+    delete state.page;
+    if (state.phase === 'window' && state.before < before) state.phase = 'before';
+    else if (state.phase !== 'after' && state.after < after) state.phase = 'after';
+    else state.phase = 'done';
+  }
+  let nextCursor;
+  if (state.phase !== 'done') {
+    nextCursor = Buffer.from(JSON.stringify({version:1, anchor:route.messageId, at:anchorTime,
+      minBefore:before, minAfter:after, limit:query.limit, phase:state.phase,
+      before:state.before, after:state.after, ...(state.page ? {page:state.page} : {})})).toString('base64url');
+    if (nextCursor.length > 4096) refuse('history-unavailable');
+  }
+  return {version:1, scope:'nearby', events, omitted:page.omitted, hasMore:!!nextCursor,
+    ...(nextCursor ? {nextCursor} : {}), window, coverage:'provider-visible-human-text'};
+}

package/src/channels/feishu/plugin-config-store.mjs

@@ -40,6 +40,7 @@ function normalizeBot(value, { legacy = false } = {}) {
   const domain = value.domain === 'lark' ? 'lark' : 'feishu';
   return Object.freeze({
     id,
+    consumerMode: value.consumerMode === 'external-consumer' ? 'external-consumer' : 'standalone',
     appId,
     secretRef,
     ownerOpenIds: Object.freeze(ownerOpenIds),

package/src/channels/matrix/matrix-controller.mjs

@@ -224,6 +224,15 @@ export class MatrixController {
     return { sent: true };
   }
 
+  async presentSessionSyncApproval(botId, target, interaction, options = {}) {
+    this.#requireId(botId);
+    const runtime = this.#runtimes.get(botId);
+    if (!runtime?.status?.ready || typeof runtime.presentSessionSyncApproval !== 'function') {
+      throw new Error('Matrix bot is not connected for proactive delivery');
+    }
+    return runtime.presentSessionSyncApproval(target, interaction, options);
+  }
+
   async deleteBot(botId) {
     this.#requireId(botId);
     const removed = await this.#withBotTransition(botId, async () => {

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

@@ -173,6 +173,7 @@ export class MatrixRuntime {
   #replyTimeoutMs;
   #api = null;
   #bridge = null;
+  #approvalController = new AbortController();
   #botUserId = null;
   #deviceId = null;
   #crypto = null;
@@ -289,6 +290,7 @@ export class MatrixRuntime {
   async start() {
     if (this.#started && this.#status.ready) return;
     this.#stopped = false;
+    this.#approvalController = new AbortController();
     this.#started = true;
     const generation = ++this.#generation;
     const homeserver = this.#config.homeserver;
@@ -361,6 +363,7 @@ export class MatrixRuntime {
   async stop() {
     if (this.#stopped) return;
     this.#stopped = true;
+    this.#approvalController.abort();
     this.#started = false;
     this.#generation += 1;
     if (this.#reconnectTimer !== null) clearTimeout(this.#reconnectTimer);
@@ -389,6 +392,17 @@ export class MatrixRuntime {
     return await bridge.sendConnectionTest(text);
   }
 
+  async presentSessionSyncApproval(target, interaction, options = {}) {
+    if (!this.#status.ready || !this.#bridge) return false;
+    const actor = typeof target?.route?.userId === 'string' ? target.route.userId.trim() : '';
+    if (!actor) return false;
+    return this.#bridge.presentSessionSyncApproval(interaction, {
+      key: options.key.startsWith('dm:') ? `direct:${options.key}` : options.key,
+      actor, validate: options.validate,
+      send: (text) => this.sendProactiveText(target, text),
+    }, { ...options, runtimeSignal: this.#approvalController.signal });
+  }
+
   async sendProactiveText(target, text, options = {}) {
     const api = this.#api;
     if (!api) throw new Error('Matrix bot is not connected');

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

@@ -488,6 +488,7 @@ export class QqHarnessBridge {
     this.#replyTimeoutMs = replyTimeoutMs;
     this.#signal = signal;
     this.#deferred = createDeferredDeliveryCoordinator({ harness, state, signal, logger,
+      finalAnswerOnly: true,
       deliver: (entry, outcome) => this.#deliverDeferredOutcome(entry, outcome),
     });
     this.#fetchImpl = fetchImpl;
@@ -1085,6 +1086,7 @@ export class QqHarnessBridge {
             signal: this.#signal,
             control: { owner: this, key },
             progressMode: 'all',
+            finalAnswerOnly: true,
             onUpdate: (update) => {
               if (update.error) {
                 const name = (nonEmptyString(update.toolName) ?? t('工具'))
@@ -1335,6 +1337,12 @@ export class QqHarnessBridge {
     }
   }
 
+  async presentSessionSyncApproval(interaction, context, options = {}) {
+    return this.#approvals.handleSessionSyncRequested(interaction, context, {
+      ...options, runtimeSignal: this.#signal, accessPolicy: this.#accessPolicy,
+    });
+  }
+
   async #handleInteraction(interaction, {
     key,
     actor,

package/src/channels/qq/qq-controller.mjs

@@ -297,6 +297,20 @@ export class QqController {
     });
   }
 
+  async presentSessionSyncApproval(botId, target, interaction, options = {}) {
+    const config = this.#configStore.get(botId);
+    if (!config) throw new Error('Unknown QQ bot');
+    return this.#withBotTransition(botId, async () => {
+      const runtime = this.#runtimes.get(botId);
+      if (!runtime?.status?.ready || typeof runtime.presentSessionSyncApproval !== 'function') {
+        const error = new Error(t('QQ机器人尚未连接'));
+        error.code = 'bot-not-connected';
+        throw error;
+      }
+      return runtime.presentSessionSyncApproval(target, interaction, options);
+    });
+  }
+
   async deleteBot(botId) {
     const warnings = [];
     const config = this.#configStore.get(botId);

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

@@ -104,6 +104,16 @@ export class QqRuntime {
     return { sent: true };
   }
 
+  async presentSessionSyncApproval(target, interaction, options = {}) {
+    if (!this.#status.ready || !this.#bridge) return false;
+    const actor = typeof target?.route?.userOpenId === 'string' ? target.route.userOpenId.trim() : '';
+    if (!actor) return false;
+    return this.#bridge.presentSessionSyncApproval(interaction, {
+      key: options.key, actor, validate: options.validate,
+      send: (text) => this.sendProactiveText(target, text),
+    }, options);
+  }
+
   async sendProactiveText(target, text, { signal } = {}) {
     const nativeId = target?.kind === 'user'
       ? (typeof target?.route?.userOpenId === 'string' ? target.route.userOpenId.trim() : '')

package/src/channels/shared/deferred-delivery-coordinator.mjs

@@ -24,6 +24,7 @@ function orderedEvents(history) {
 export function createDeferredDeliveryCoordinator({
   harness, state, deliver, signal, logger = console,
   retryDelayMs = 1_000, pollDelayMs = 30_000, watch = true,
+  finalAnswerOnly = false,
 } = {}) {
   const enabled = ['deferredEntries', 'putDeferred', 'patchDeferred', 'removeDeferred']
     .every((name) => typeof state?.[name] === 'function');
@@ -100,7 +101,7 @@ export function createDeferredDeliveryCoordinator({
       }
       const outcome = targetTurn === null
         ? { found: false, endSeq: -1, turn: null }
-        : extractCompletedTurnAnswer(ordered, { turn: targetTurn });
+        : extractCompletedTurnAnswer(ordered, { turn: targetTurn, finalAnswerOnly });
       const hasStart = ordered.some((event) => event.type === 'turn/start' && event.data?.turn === targetTurn);
       if (!history.hasMore || hasStart) return { ...outcome, turn: targetTurn };
       const oldest = batch[0]?.seq;

package/src/channels/shared/deferred-delivery.mjs

@@ -1,4 +1,4 @@
-import { AssistantTextAccumulator } from './harness-client.mjs';
+import { AssistantTextAccumulator, accumulateFinalAssistantText } from './harness-client.mjs';
 
 export const MAX_DEFERRED_PER_KEY = 4;
 
@@ -35,12 +35,13 @@ function textFromContent(content) {
  *
  * Reuses HarnessReplyTracker text accumulation: chunk deltas accumulate per
  * (step, part index); a canonical assistant/message replaces its step; steps
- * join with a blank line. `turn` omitted → prefer the latest completed answer.
+ * join with a blank line. finalAnswerOnly discards text before tool calls.
+ * `turn` omitted → prefer the latest completed answer.
  * Returns `{ found, turn, text, reason, endSeq }`; `found: false` when the
  * turn ended without a completed final answer (stopped/failed/empty/
  * interrupted) — `reason`/`endSeq` still identify the confirmed terminal.
  */
-export function extractCompletedTurnAnswer(entries, { turn } = {}) {
+export function extractCompletedTurnAnswer(entries, { turn, finalAnswerOnly = false } = {}) {
   const events = orderedEvents(entries);
   const wantTurn = Number.isSafeInteger(turn) ? turn : null;
   function turnAnswer(turnEnd) {
@@ -48,12 +49,14 @@ export function extractCompletedTurnAnswer(entries, { turn } = {}) {
     let interrupted = false;
     for (const event of events) {
       if (event.seq > turnEnd.seq || event.data?.turn !== turnEnd.data.turn) continue;
-      if (event.type === 'assistant/chunk' && event.data?.chunk?.type === 'text-delta') {
+      if (finalAnswerOnly === true) {
+        accumulateFinalAssistantText(accumulator, event);
+      } else if (event.type === 'assistant/chunk' && event.data?.chunk?.type === 'text-delta') {
         accumulator.appendDelta(event.data.step, event.data.chunk.index, event.data.chunk.text);
       } else if (event.type === 'assistant/message') {
         accumulator.setCanonical(event.data.step, textFromContent(event.data.message?.content));
-        interrupted = event.data.interrupted === true;
       }
+      if (event.type === 'assistant/message') interrupted = event.data.interrupted === true;
     }
     return { text: accumulator.text, interrupted };
   }

package/src/channels/shared/harness-approval.mjs

@@ -1,4 +1,5 @@
 import { t } from './i18n.mjs';
+import { evaluateInboundAccess } from './inbound-access.mjs';
 
 const APPROVAL_REPLIES = new Map([
   ['批准', 'allowed-once'],
@@ -9,6 +10,12 @@ const APPROVAL_REPLIES = new Map([
   ['no', 'rejected'],
 ]);
 
+export const COMPETITIVE_APPROVAL_CHANNELS = Object.freeze([
+  'feishu', 'weixin', 'dingtalk', 'wecom', 'wecom-app', 'qq',
+  'telegram', 'slack', 'discord', 'whatsapp', 'matrix',
+]);
+
+const APPROVAL_UNAVAILABLE_TEXT = '机器人端无法处理这次审批，请到 Web 查看。';
 const APPROVAL_PROMPT = '请精准回复「批准」或「拒绝」（也支持：同意 / 不同意 / yes / no）。';
 const APPROVAL_AFTER_QUESTION_PROMPT = '请先完成当前问题，再精准回复「批准」或「拒绝」。';
 const APPROVAL_RESOLVED_TEXT = '该审批已处理，无需再次回复。';
@@ -95,6 +102,7 @@ function approvalResult(pending, outcome) {
 }
 
 function approvalOutcomeText(outcome) {
+  if (outcome === 'unavailable') return t(APPROVAL_UNAVAILABLE_TEXT);
   if (outcome === 'allowed-once') return t('已批准，仅对本次操作有效。');
   if (outcome === 'rejected') return t('已拒绝此次操作。');
   return t(APPROVAL_RESOLVED_TEXT);
@@ -210,6 +218,51 @@ export class HarnessApprovalQueue {
     };
   }
 
+  /** Present a bound private-chat approval without creating an IM prompt. */
+  async handleSessionSyncRequested(interaction, context, { signal, completion, runtimeSignal, accessPolicy } = {}) {
+    if (signal?.aborted || runtimeSignal?.aborted) return false;
+    const validateRoute = context.validate;
+    context = { ...context, validate: async () => {
+      await validateRoute?.();
+      if (!context.actor || !evaluateInboundAccess(accessPolicy, {
+        conversationType: 'direct', senderIds: [context.actor], text: 'yes',
+      }).allowed) throw new Error('Approval recipient is no longer allowed');
+    } };
+    await context.validate();
+    if (signal?.aborted || runtimeSignal?.aborted) return false;
+    let resolved = false;
+    const finish = (outcome) => this.handleResolved({
+      kind: 'approval', interactionId: interaction.interactionId, outcome,
+    });
+    const onStop = () => {
+      queueMicrotask(async () => {
+        if (resolved) return;
+        try {
+          await interaction.withdraw?.();
+          await finish('unavailable');
+        } catch (error) {
+          this.#logger.warn?.(`[dsh-im:${this.#label}] failed to withdraw a stopped approval:`, error);
+        }
+      });
+    };
+    runtimeSignal?.addEventListener('abort', onStop, { once: true });
+    Promise.resolve(completion).then(async (outcome) => {
+      resolved = true;
+      runtimeSignal?.removeEventListener('abort', onStop);
+      await finish(outcome);
+    }).catch((error) => this.#logger.warn?.(`[dsh-im:${this.#label}] failed to retire a synced approval:`, error));
+    try {
+      await this.handleRequested(interaction, context);
+      if (runtimeSignal?.aborted) onStop();
+      return this.#byId.has(interaction.interactionId);
+    } catch (error) {
+      runtimeSignal?.removeEventListener('abort', onStop);
+      await interaction.withdraw?.();
+      await finish('unavailable');
+      throw error;
+    }
+  }
+
   async handleRequested(interaction, context) {
     if (interaction?.kind !== 'approval') return false;
     const payload = interaction.payload;
@@ -257,7 +310,7 @@ export class HarnessApprovalQueue {
     if (!text) {
       const rejected = await this.#rejectInteraction(interaction, payload);
       await send(rejected
-        ? t('无法完整展示这次操作，已安全拒绝此次审批。')
+        ? (interaction.withdraw ? t(APPROVAL_UNAVAILABLE_TEXT) : t('无法完整展示这次操作，已安全拒绝此次审批。'))
         : t(APPROVAL_RESOLVED_TEXT));
       return true;
     }
@@ -272,6 +325,7 @@ export class HarnessApprovalQueue {
       requiresMention: context.requiresMention === true,
       send,
       render,
+      validate: context.validate,
       onResolved: typeof context.onResolved === 'function' ? context.onResolved : null,
       text,
       presented: false,
@@ -342,13 +396,14 @@ export class HarnessApprovalQueue {
     for (const pending of pendingItems) this.#remove(pending);
     await Promise.all(pendingItems.map(async (pending) => {
       try {
-        await pending.interaction.respond(
+        if (pending.interaction.withdraw) await pending.interaction.withdraw();
+        else await pending.interaction.respond(
           approvalResult(pending, 'rejected'),
           { signal: AbortSignal.timeout(5_000) },
         );
-        pending.closedOutcome = 'rejected';
+        pending.closedOutcome = pending.interaction.withdraw ? 'unavailable' : 'rejected';
         if (pending.presented || pending.deliveryCompleted) {
-          await this.#notifyResolved(pending, 'rejected');
+          await this.#notifyResolved(pending, pending.closedOutcome);
         }
       } catch (error) {
         if (error?.code === 'interaction-not-pending') {
@@ -372,9 +427,12 @@ export class HarnessApprovalQueue {
     if (pending.presentationTask) return pending.presentationTask;
     // A channel-provided renderer shows the approval as an interactive card
     // (e.g. approve/reject buttons); otherwise fall back to plain text.
-    const task = pending.render
-      ? Promise.resolve().then(() => pending.render(pending, pending.send))
-      : Promise.resolve().then(() => pending.send(pending.text));
+    const task = Promise.resolve().then(async () => {
+      await pending.validate?.();
+      if (pending.inactive || pending.resolving) return;
+      if (pending.render) await pending.render(pending, pending.send);
+      else await pending.send(pending.text);
+    });
     pending.presentationTask = task;
     try {
       await task;
@@ -384,6 +442,12 @@ export class HarnessApprovalQueue {
       } else if (pending.closedOutcome) {
         await this.#notifyResolved(pending, pending.closedOutcome);
       }
+    } catch (error) {
+      if (!pending.interaction.withdraw) throw error;
+      pending.presentationTask = null;
+      await pending.interaction.withdraw();
+      await this.handleResolved({ kind: 'approval', interactionId: pending.approvalId, outcome: 'unavailable' });
+      this.#logger.warn?.(`[dsh-im:${this.#label}] approval presentation unavailable:`, error);
     } finally {
       if (pending.presentationTask === task) pending.presentationTask = null;
     }
@@ -392,6 +456,15 @@ export class HarnessApprovalQueue {
   async #submit(pending, outcome) {
     pending.submitting = true;
     try {
+      if (pending.validate) {
+        try { await pending.validate(); }
+        catch (error) {
+          await pending.interaction.withdraw?.();
+          throw Object.assign(new Error('Approval route is no longer available', { cause: error }), {
+            code: 'interaction-not-pending',
+          });
+        }
+      }
       await pending.interaction.respond(approvalResult(pending, outcome));
     } catch (error) {
       if (error?.code === 'interaction-not-pending') {
@@ -491,6 +564,10 @@ export class HarnessApprovalQueue {
 
   async #rejectInteraction(interaction, payload) {
     try {
+      if (interaction.withdraw) {
+        await interaction.withdraw();
+        return true;
+      }
       await interaction.respond({
         ok: true,
         value: {