@xmanrui/dsh-im 4.12.0 → 4.13.0

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

@@ -0,0 +1,241 @@
+import { createDeferredDeliveryRegistry, extractCompletedTurnAnswer } from './deferred-delivery.mjs';
+import { t } from './i18n.mjs';
+import { channelDeliveryFailure } from './message-failure.mjs';
+
+export function deferredOutcomeText(outcome) {
+  if (outcome.found && outcome.text) return outcome.text;
+  const reason = outcome.reason === 'stopped' ? t('已停止')
+    : ['aborted', 'cancelled'].includes(outcome.reason) ? t('已中止')
+      : outcome.reason === 'failed' ? t('任务失败') : t('已结束');
+  return t('后台任务已结束（{reason}），没有可推送的最终结果。', { reason });
+}
+
+function orderedEvents(history) {
+  return (Array.isArray(history?.events) ? history.events : [])
+    .map((row) => row?.event ?? row)
+    .filter((event) => Number.isSafeInteger(event?.seq) && event.seq >= 0)
+    .sort((a, b) => a.seq - b.seq);
+}
+
+/** One coordinator per bot. All history reads, sends, removal and stops for a
+ * Session use the same queue. Queued work stores ids, never stale entry objects.
+ * Durable pending rows survive crashes; there is no persisted pre-send claim.
+ */
+export function createDeferredDeliveryCoordinator({
+  harness, state, deliver, signal, logger = console,
+  retryDelayMs = 1_000, pollDelayMs = 30_000, watch = true,
+} = {}) {
+  const enabled = ['deferredEntries', 'putDeferred', 'patchDeferred', 'removeDeferred']
+    .every((name) => typeof state?.[name] === 'function');
+  const controller = new AbortController();
+  const activeSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
+  const tails = new Map();
+  const timers = new Map();
+  const registry = createDeferredDeliveryRegistry({
+    listDeferred: async () => state.deferredEntries(),
+    putDeferred: (entry) => state.putDeferred(entry),
+    patchDeferred: (id, patch) => state.patchDeferred(id, patch),
+    removeDeferred: (id) => state.removeDeferred(id),
+  }, { logger });
+  const warn = (error) => { if (!activeSignal.aborted) logger.warn?.('[dsh-im] deferred delivery:', error?.message ?? String(error)); };
+  const pending = async (id) => (await registry.allPending()).find((entry) => entry.id === id);
+  const bound = (entry) => !activeSignal.aborted && state.sessionFor(entry.key) === entry.sessionId;
+  function enqueue(sessionId, operation) {
+    const previous = tails.get(sessionId) ?? Promise.resolve();
+    const task = previous.then(() => activeSignal.aborted ? undefined : operation());
+    const tail = task.catch(warn).finally(() => { if (tails.get(sessionId) === tail) tails.delete(sessionId); });
+    tails.set(sessionId, tail);
+    return task;
+  }
+  function schedule(entry, delay = pollDelayMs) {
+    if (activeSignal.aborted || timers.has(entry.id)) return;
+    const timer = setTimeout(() => {
+      timers.delete(entry.id);
+      void enqueue(entry.sessionId, () => process(entry.id)).catch(warn);
+    }, delay);
+    timer.unref?.();
+    timers.set(entry.id, timer);
+  }
+  function clearTimer(id) {
+    clearTimeout(timers.get(id));
+    timers.delete(id);
+  }
+  async function remove(entry) {
+    clearTimer(entry.id);
+    await registry.remove(entry);
+  }
+  async function readOutcome(entry) {
+    // A result may be older than the latest history page after a restart.
+    // Recover the whole target turn instead of treating a missing page as empty.
+    const events = new Map();
+    const historySignal = AbortSignal.any([activeSignal, AbortSignal.timeout(30_000)]);
+    let beforeSeq;
+    let targetTurn = Number.isSafeInteger(entry.turn) ? entry.turn : null;
+    for (let page = 0; page < 20; page += 1) {
+      historySignal.throwIfAborted();
+      const history = await harness.rpc('session.history', {
+        sessionId: entry.sessionId, maxMessages: 100,
+        ...(beforeSeq === undefined ? {} : { beforeSeq }),
+      }, 30_000, { signal: historySignal });
+      const batch = orderedEvents(history);
+      for (const event of batch) events.set(event.seq, event);
+      const ordered = [...events.values()].sort((a, b) => a.seq - b.seq);
+      if (targetTurn === null && entry.promptRpcId) {
+        let openTurn = null;
+        for (const event of ordered) {
+          if (event.type === 'turn/start') openTurn = event.data?.turn ?? null;
+          if (event.type === 'user/message' && event.data?.source?.rpcId === entry.promptRpcId) {
+            targetTurn = Number.isSafeInteger(event.data?.turn) ? event.data.turn : openTurn;
+            break;
+          }
+          if (event.type === 'turn/end') openTurn = null;
+        }
+      }
+      const reachedCursor = !history.hasMore || ordered[0]?.seq <= entry.afterSeq;
+      if (targetTurn === null && !entry.promptRpcId && reachedCursor) {
+        // Legacy #153 rows had no prompt identity. Never select a completion
+        // preceding the saved cursor, or a newer arbitrary completed turn.
+        targetTurn = ordered.find((event) => event.type === 'turn/end'
+          && event.seq > entry.afterSeq)?.data?.turn ?? null;
+      }
+      const outcome = targetTurn === null
+        ? { found: false, endSeq: -1, turn: null }
+        : extractCompletedTurnAnswer(ordered, { turn: targetTurn });
+      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;
+      if (!Number.isSafeInteger(oldest) || oldest === beforeSeq) break;
+      beforeSeq = oldest;
+    }
+    // Bounded reads cannot prove that a truncated answer is complete.
+    return { found: false, endSeq: -1, turn: targetTurn };
+  }
+  async function process(id, { stopping = false, urgent = false } = {}) {
+    let entry = await pending(id);
+    if (!entry || activeSignal.aborted) return 'none';
+    clearTimer(id);
+    if (!bound(entry)) { await remove(entry); return 'none'; }
+    let sending = false;
+    try {
+      const outcome = await readOutcome(entry);
+      // Binding, status and cancellation can change while the RPC is in flight.
+      entry = await pending(id);
+      if (!entry || activeSignal.aborted) return 'none';
+      if (!bound(entry)) { await remove(entry); return 'none'; }
+      if (outcome.endSeq === -1) {
+        if (Number.isSafeInteger(outcome.turn) && entry.turn !== outcome.turn) {
+          await state.patchDeferred(id, { turn: outcome.turn });
+          entry = { ...entry, turn: outcome.turn };
+        }
+        if (stopping) {
+          const session = harness.workspaceSession?.(entry.sessionId);
+          const stopped = typeof session?.stopDeferredTurn === 'function'
+            ? await session.stopDeferredTurn({ turn: entry.turn, promptRpcId: entry.promptRpcId }, {
+                signal: activeSignal, isCurrent: () => bound(entry),
+              })
+            : typeof harness.stopDeferredTurn === 'function'
+              ? await harness.stopDeferredTurn(entry.sessionId, { turn: entry.turn, promptRpcId: entry.promptRpcId }, {
+                  signal: activeSignal, isCurrent: () => bound(entry),
+                }) : false;
+          schedule(entry, retryDelayMs);
+          return stopped ? 'stopped' : 'unavailable';
+        }
+        schedule(entry, urgent ? retryDelayMs : pollDelayMs);
+        return 'waiting';
+      }
+      sending = true;
+      const result = await deliver(entry, outcome);
+      if (result === false || result?.deliveryOutcome === 'failed' || result?.deliveryOutcome === 'unknown') {
+        throw Object.assign(new Error('Deferred delivery was not confirmed'), {
+          deliveryOutcome: result?.deliveryOutcome ?? 'failed',
+        });
+      }
+      await remove(entry);
+      return 'delivered';
+    } catch (error) {
+      if (activeSignal.aborted) return 'none';
+      if (error?.code === 'session-not-found') { await remove(entry); return 'none'; }
+      const current = await pending(id);
+      if (!current) return 'none';
+      if (!sending) {
+        warn(error);
+        schedule(current);
+        return stopping ? 'unavailable' : 'waiting';
+      }
+      const uncertain = error?.deliveryOutcome === 'unknown'
+        || (error?.deliveryOutcome !== 'failed'
+          && channelDeliveryFailure(error).code === 'channel-delivery-uncertain');
+      if (uncertain) {
+        // The provider may already have accepted the message. Preserve the
+        // existing delivery-uncertain rule instead of retrying a possible copy.
+        await state.patchDeferred(id, { status: 'failed', deliveryOutcome: 'unknown', attempts: (current.attempts ?? 0) + 1 });
+        warn(error);
+        return stopping ? 'unavailable' : 'unknown';
+      }
+      const attempts = await registry.markFailedAttempt(current);
+      warn(error);
+      if (attempts < 3) schedule(current, retryDelayMs * 2 ** (attempts - 1));
+      return stopping ? 'unavailable' : 'retry';
+    }
+  }
+  async function resume() {
+    if (!enabled || activeSignal.aborted) return;
+    const entries = await registry.allPending();
+    await Promise.allSettled(entries.map((entry) => enqueue(entry.sessionId, () => process(entry.id))));
+  }
+  const startup = Promise.resolve().then(async () => {
+    if (!enabled || activeSignal.aborted) return;
+    if (watch && typeof harness.watchHarnessEvents === 'function') {
+      try {
+        Promise.resolve(harness.watchHarnessEvents({ signal: activeSignal,
+          onSessionEvent: (payload) => { void api.onEvent(payload).catch(warn); },
+          onReconnect: () => { void resume().catch(warn); },
+        })).catch(warn);
+      } catch (error) { warn(error); }
+    }
+    await resume();
+  }).catch(warn);
+  activeSignal.addEventListener('abort', () => {
+    for (const timer of timers.values()) clearTimeout(timer);
+    timers.clear();
+  }, { once: true });
+  const api = {
+    async trackTimeout(error, { key, sessionId, ...delivery }) {
+      if (!enabled || error?.code !== 'harness-reply-timeout' || activeSignal.aborted) return;
+      const details = error.details ?? {};
+      const target = details.sessionId ?? sessionId ?? state.sessionFor(key);
+      if (!target || state.sessionFor(key) !== target) return;
+      const entry = await registry.register({ key, sessionId: target,
+        turn: details.turn, promptRpcId: details.promptRpcId,
+        afterSeq: details.baselineSeq ?? details.lastSeq ?? -1,
+        ...delivery,
+      });
+      void enqueue(target, () => process(entry.id)).catch(warn);
+    },
+    async onEvent({ sessionId, event } = {}) {
+      if (!enabled || activeSignal.aborted || event?.type !== 'turn/end') return;
+      const entries = await registry.pendingForSession(sessionId);
+      await Promise.allSettled(entries
+        .filter((entry) => !Number.isSafeInteger(entry.turn) || entry.turn === event.data?.turn)
+        .map((entry) => enqueue(sessionId, () => process(entry.id, { urgent: true }))));
+    },
+    resume,
+    async stop(key) {
+      if (!enabled || activeSignal.aborted) return 'none';
+      const entries = await registry.pendingForKey(key);
+      let outcome = 'none';
+      for (const entry of entries) {
+        const result = await enqueue(entry.sessionId, () => process(entry.id, { stopping: true }));
+        if (result === 'stopped') outcome = 'stopped';
+        else if (result === 'unavailable' && outcome !== 'stopped') outcome = 'unavailable';
+      }
+      return outcome;
+    },
+    async whenIdle() {
+      await startup;
+      while (tails.size) await Promise.allSettled([...tails.values()]);
+    },
+    close() { controller.abort(); },
+  };
+  return api;
+}

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

@@ -0,0 +1,161 @@
+import { AssistantTextAccumulator } from './harness-client.mjs';
+
+export const MAX_DEFERRED_PER_KEY = 4;
+
+/** Classify one turn/end event into a terminal-reason label. */
+export function terminalOutcomeOf(turnEndEvent) {
+  const raw = turnEndEvent?.data?.reason;
+  const kind = typeof raw === 'string'
+    ? raw
+    : typeof raw?.kind === 'string' ? raw.kind : null;
+  return { kind: kind ?? 'other' };
+}
+
+function eventOf(entry) {
+  return entry?.event ?? (entry?.type ? entry : null);
+}
+
+function orderedEvents(entries) {
+  return (Array.isArray(entries) ? entries : [])
+    .map(eventOf)
+    .filter(Boolean)
+    .sort((left, right) => (left.seq ?? -1) - (right.seq ?? -1));
+}
+
+function textFromContent(content) {
+  if (!Array.isArray(content)) return '';
+  return content
+    .flatMap((block) => (block?.type === 'text' && typeof block.text === 'string' ? [block.text] : []))
+    .join('\n')
+    .trim();
+}
+
+/**
+ * Extract the final answer of one completed turn from durable history events.
+ *
+ * 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.
+ * 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 } = {}) {
+  const events = orderedEvents(entries);
+  const wantTurn = Number.isSafeInteger(turn) ? turn : null;
+  function turnAnswer(turnEnd) {
+    const accumulator = new AssistantTextAccumulator();
+    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') {
+        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;
+      }
+    }
+    return { text: accumulator.text, interrupted };
+  }
+
+  function scan(matchTurn, acceptAnyTerminal = false) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+      const event = events[index];
+      if (event?.type !== 'turn/end' || !Number.isSafeInteger(event.data?.turn)) continue;
+      if (matchTurn !== null && event.data.turn !== matchTurn) continue;
+      const raw = event.data?.reason;
+      const reason = typeof raw === 'string' ? raw : typeof raw?.kind === 'string' ? raw.kind : null;
+      const answer = turnAnswer(event);
+      const hasAnswer = reason === 'completed' && !answer.interrupted;
+      const text = hasAnswer ? answer.text : null;
+      if (hasAnswer && text) {
+        return { found: true, turn: event.data.turn, text, reason, endSeq: event.seq ?? -1 };
+      }
+      if (matchTurn !== null || acceptAnyTerminal) {
+        return { found: false, turn: event.data.turn, text: null, reason, endSeq: event.seq ?? -1 };
+      }
+    }
+    return null;
+  }
+
+  const completed = scan(wantTurn);
+  if (completed) return completed;
+  const anyTerminal = scan(wantTurn, true);
+  if (anyTerminal) return anyTerminal;
+  return { found: false, turn: wantTurn, text: null, reason: null, endSeq: -1 };
+}
+
+/**
+ * Registry over a tiny persistence interface:
+ * `listDeferred() / putDeferred(entry) / patchDeferred(id, patch) / removeDeferred(id)`.
+ * Entries are owned snapshots; prompt ids distinguish tasks even before turn/start.
+ */
+export function createDeferredDeliveryRegistry(store, {
+  now = () => Date.now(),
+  maxPerKey = MAX_DEFERRED_PER_KEY,
+  logger = console,
+} = {}) {
+  function deferredId(key, sessionId, turn) {
+    return `${key} ${sessionId} ${Number.isSafeInteger(turn) ? turn : 'any'}`;
+  }
+
+  return {
+    deferredId,
+    async register({
+      key, chatId = null, target = null, replyToMessageId = null, sessionId, turn = null, afterSeq = -1, promptRpcId = null,
+    }) {
+      if (typeof key !== 'string' || !key) throw new TypeError('key is required');
+      if ((!chatId || typeof chatId !== 'string') && (!target || typeof target !== 'object')) {
+        throw new TypeError('chatId or a channel target is required');
+      }
+      if (typeof sessionId !== 'string' || !sessionId) throw new TypeError('sessionId is required');
+      const entry = {
+        id: promptRpcId ? `${key} ${sessionId} ${promptRpcId}` : deferredId(key, sessionId, turn),
+        key,
+        chatId,
+        ...(target ? { target: structuredClone(target) } : {}),
+        replyToMessageId: typeof replyToMessageId === 'string' ? replyToMessageId : null,
+        sessionId,
+        promptRpcId,
+        turn: Number.isSafeInteger(turn) ? turn : null,
+        afterSeq: Number.isSafeInteger(afterSeq) ? afterSeq : -1,
+        lastSeenEndSeq: -1,
+        attempts: 0,
+        status: 'pending',
+        createdAt: now(),
+      };
+      const sameKey = (await store.listDeferred())
+        .filter((candidate) => candidate.key === key && candidate.status === 'pending');
+      const existing = sameKey.find((candidate) => candidate.id === entry.id);
+      if (existing) return existing;
+      if (sameKey.length >= maxPerKey) {
+        logger?.warn?.('[dsh-im] deferred delivery limit reached for key; dropping the oldest entry');
+        await store.removeDeferred(sameKey[0].id);
+      }
+      await store.putDeferred(entry);
+      return entry;
+    },
+    async pendingForSession(sessionId) {
+      return (await store.listDeferred())
+        .filter((entry) => entry.status === 'pending' && entry.sessionId === sessionId);
+    },
+    async pendingForKey(key) {
+      return (await store.listDeferred())
+        .filter((entry) => entry.status === 'pending' && entry.key === key);
+    },
+    async allPending() {
+      return (await store.listDeferred()).filter((entry) => entry.status === 'pending');
+    },
+    async markFailedAttempt(entry) {
+      // Read fresh state: the caller's snapshot goes stale across attempts.
+      const current = (await store.listDeferred())
+        .find((candidate) => candidate.id === entry.id) ?? entry;
+      const attempts = (current.attempts ?? 0) + 1;
+      await store.patchDeferred(entry.id, { attempts, status: attempts >= 3 ? 'failed' : 'pending' });
+      return attempts;
+    },
+    async remove(entry) {
+      await store.removeDeferred(entry.id);
+    },
+  };
+}

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

@@ -0,0 +1,53 @@
+/** Shared durable outbox surface, stored alongside each bot's conversation state. */
+export function validDeferredEntry(value) {
+  return value && typeof value === 'object'
+    && ['id', 'key', 'sessionId'].every((key) => typeof value[key] === 'string' && value[key])
+    && ['pending', 'failed'].includes(value.status);
+}
+
+export function normalizeDeferredState(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
+  return Object.fromEntries(Object.entries(value).flatMap(([key, rows]) => {
+    const entries = Array.isArray(rows)
+      ? rows.filter((entry) => validDeferredEntry(entry) && entry.key === key) : [];
+    return entries.length ? [[key, entries]] : [];
+  }));
+}
+
+export function deferredStateAccess(read, persist) {
+  const rows = () => Object.values(read().deferred ?? {}).flat().filter(validDeferredEntry);
+  return {
+    entries: () => structuredClone(rows()),
+    async put(entry) {
+      if (!validDeferredEntry(entry)) throw new TypeError('Invalid deferred delivery entry');
+      const state = read();
+      const groups = state.deferred ??= {};
+      const list = Object.hasOwn(groups, entry.key) ? groups[entry.key] : [];
+      const next = [...list];
+      const index = next.findIndex((candidate) => candidate.id === entry.id);
+      if (index < 0) next.push(structuredClone(entry));
+      else next[index] = structuredClone(entry);
+      Object.defineProperty(groups, entry.key, { value: next, enumerable: true, writable: true, configurable: true });
+      await persist();
+    },
+    async patch(id, patch) {
+      const current = rows().find((entry) => entry.id === id);
+      if (!current) return null;
+      const next = { ...current, ...patch, id: current.id, key: current.key };
+      await this.put(next);
+      return structuredClone(next);
+    },
+    async remove(id) {
+      const groups = read().deferred ?? {};
+      for (const [key, list] of Object.entries(groups)) {
+        if (!Array.isArray(list)) continue;
+        const next = list.filter((entry) => entry.id !== id);
+        if (next.length === list.length) continue;
+        if (next.length) groups[key] = next;
+        else delete groups[key];
+        await persist();
+        return;
+      }
+    },
+  };
+}

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

@@ -1206,6 +1206,23 @@ export class HarnessClient {
     return Boolean(await this.#refreshControlOwnership(sessionId, control, options));
   }
 
+  /** Cancel only the persisted prompt's exact live turn, in the host's JS tick.
+   * HTTP session.cancel cannot express this precondition, so never fall back to it.
+   */
+  stopDeferredTurn(sessionId, { turn, promptRpcId } = {}, { signal, isCurrent } = {}) {
+    signal?.throwIfAborted();
+    if (typeof sessionId !== 'string' || !sessionId
+      || !Number.isSafeInteger(turn) || turn < 0
+      || typeof promptRpcId !== 'string' || !promptRpcId
+      || typeof this.#controlExecutor !== 'function') return false;
+    if (isCurrent && !isCurrent()) return false;
+    const accepted = this.#controlExecutor({ sessionId, expectedTurn: turn, promptRpcId, action: 'stop' });
+    if (accepted && typeof accepted.then === 'function') {
+      throw new TypeError('controlExecutor must return synchronously');
+    }
+    return accepted === true;
+  }
+
   async stopActiveTurn(sessionId, control, options = {}) {
     if (typeof sessionId !== 'string' || !sessionId) throw new TypeError('sessionId is required');
     const ownership = await this.#refreshControlOwnership(sessionId, control, options);
@@ -1585,7 +1602,10 @@ export class HarnessClient {
             lastProgressAt = Date.now();
             continue;
           }
-          throw new HarnessTurnError('harness-reply-timeout');
+          const timeoutError = new HarnessTurnError('harness-reply-timeout');
+          // Data-only context for deferred delivery; timeout semantics unchanged.
+          timeoutError.details = { sessionId, promptRpcId, baselineSeq, turn: tracker.turn, lastSeq: tracker.lastSeq };
+          throw timeoutError;
         }
       } catch (error) {
         // Once cancellation was accepted, transport/poll failures and timeouts

package/src/channels/shared/i18n-en/dingtalk.mjs

@@ -5,6 +5,11 @@ export default {
   '已连接 DeepSeek Harness，正在思考…': 'Connected to DeepSeek Harness, thinking…',
 
   '钉钉机器人已连接 DeepSeek Harness。': 'The DingTalk bot is connected to DeepSeek Harness.',
+  '/m 或 /menu  打开下拉操作菜单': '/m or /menu  Open the dropdown action menu',
+  '会话或工作区已变化，请重新发送 /m。': 'The session or workspace changed. Send /m again.',
+  '会话或工作区已变化，菜单已刷新，请重新选择。': 'The session or workspace changed. The menu was refreshed; please select again.',
+  '当前任务尚未结束，请先停止任务或等待完成后再操作。': 'A task is still running. Stop it or wait until it finishes before making changes.',
+  '操作未完成，请重新发送 /m 后重试。': 'The action did not complete. Send /m again and retry.',
 
 
 

package/src/channels/shared/i18n-en/feishu.mjs

@@ -367,4 +367,10 @@ export default {
   '🔐 工具审批': '🔐 Tool approval',
   // feishu/feishu-cards.mjs — question card
   '❓ 请补充信息{progress}': '❓ Please provide more information{progress}',
+  // feishu/bridge.mjs — deferred delivery terminal statuses
+  '后台任务已结束（{reason}），没有可推送的最终结果。':
+    'The background task has finished ({reason}); there is no final result to deliver.',
+  '已请求停止后台任务。': 'Requested to stop the background task.',
+  '无法安全停止后台任务，请在 Harness 中查看并停止对应任务。': 'Unable to safely stop the background task. Please inspect and stop the matching task in Harness.',
+  '任务失败': 'Failed',
 };

package/src/channels/shared/i18n-en/qq.mjs

@@ -1,5 +1,44 @@
 // English translations (qq area). Keys are exact Chinese literals passed to t().
 export default {
+  '返回主菜单': 'Back to main menu',
+  '模式／预设': 'Mode / preset',
+  '归档显示': 'Archived sessions',
+  '第 {page} / {pages} 页': 'Page {page} / {pages}',
+  '当前会话：{session}': 'Current session: {session}',
+  '模式／预设：{preset}': 'Mode / preset: {preset}',
+  '当前模型：{model}': 'Current model: {model}',
+  '暂不可用': 'Unavailable',
+  '归档会话：{state}': 'Archived sessions: {state}',
+  '显示': 'Shown',
+  '隐藏': 'Hidden',
+  '任务状态：{state}': 'Task status: {state}',
+  '处理中': 'Processing',
+  '空闲': 'Idle',
+  '部分设置暂未加载，可进入对应列表重试。': 'Some settings could not be loaded. Open the corresponding list to retry.',
+  '💬 会话选择': '💬 Select session',
+  '📁 工作区': '📁 Workspace',
+  '🤖 模式／预设': '🤖 Mode / preset',
+  '🧠 模型': '🧠 Model',
+  '💬 补充指令': '💬 Steer task',
+  '给当前正在运行的任务补充指令。': 'Send an additional instruction to the running task.',
+  '自定义指令': 'Custom instruction',
+  '请发送 /steer 你的补充指令。': 'Send /steer followed by your instruction.',
+  '发送 /m 打开助手中心，点击按钮或回复当前列表的数字选择。': 'Send /m to open the assistant menu. Click a button or reply with a number from the current list.',
+  '设置：会话、工作区、模式／预设、模型。': 'Settings: session, workspace, mode / preset, model.',
+  '会话：新会话、会话列表、归档显示切换。': 'Sessions: new session, session list, show or hide archived sessions.',
+  '任务：停止、压缩、快捷或自定义补充指令。': 'Tasks: stop, compact, quick or custom steering instructions.',
+  '信息：状态、帮助。': 'Information: status, help.',
+  '菜单有效期为 15 分钟；发送普通消息会退出数字选择。': 'Menus expire after 15 minutes. Sending an ordinary message exits number selection.',
+  '回答问题、审批和批量输入时，数字优先用于当前交互。': 'During questions, approvals and batch input, numbers belong to that interaction.',
+  '完整命令说明：/help': 'Full command reference: /help',
+  '当前无法展示按钮，请回复数字选择。': 'Buttons are unavailable. Reply with a number to select.',
+  '点击按钮或回复数字选择，/m 返回主菜单。': 'Click a button or reply with a number. Send /m for the main menu.',
+  '回答问题、审批和批量输入时，请先完成当前交互。': 'Finish any pending question, approval or batch input before replying with a menu number.',
+  '已选择': 'Selected',
+  '请回复数字选择，或发送 /m 重新打开菜单。': 'Reply with a number or send /m to reopen the menu.',
+  '当前正在批量输入，请先发送 /send 或 /cancel，再打开菜单。': 'Batch input is active. Send /send or /cancel before opening the menu.',
+  '菜单命令无效，请发送 /m 重新打开。': 'Invalid menu command. Send /m to reopen the menu.',
+  '当前任务仍在运行，请先停止任务或等待任务完成后再执行此操作。': 'A task is still running. Stop it or wait for it to finish before performing this action.',
 
   'QQ 机器人已连接 DeepSeek Harness。':
     'The QQ bot is connected to DeepSeek Harness.',

package/src/channels/shared/i18n-en/weixin.mjs

@@ -12,6 +12,8 @@ export default {
   '微信交互问题发送失败。': 'Failed to send the WeChat interaction question.',
   '回复已经生成，但微信发送失败，可能只收到部分内容。请将下面的诊断信息完整反馈给管理员。': 'The reply was generated, but WeChat delivery failed and only part of it may have arrived. Please send the complete diagnostic below to the administrator.',
   '微信发送诊断：{diagnostic}': 'WeChat delivery diagnostic: {diagnostic}',
+  '微信主动消息发送失败。长轮询在线不代表消息可以发送。': 'WeChat outbound delivery failed. Healthy long polling does not guarantee messages can be sent.',
+  'iLink 拒绝发送，可能涉及会话有效期、发送额度或消息内容。可让接收者发一条消息后重试；不要通过反复发送心跳尝试续期。': 'iLink rejected the message; conversation lifetime, sending quota, or message content may be involved. Ask the recipient to send a message before retrying. Repeated heartbeat messages do not renew the conversation.',
 
   // weixin-controller.mjs
   '微信已授权，但无法读取现有登录凭据。请检查 DSH 凭据存储。': 'WeChat was authorized, but the existing login credential could not be read. Please check the DSH credential store.',

package/src/channels/shared/text-harness-bridge.mjs

@@ -1,3 +1,4 @@
+import { createDeferredDeliveryCoordinator, deferredOutcomeText } from './deferred-delivery-coordinator.mjs';
 import { t } from './i18n.mjs';
 import {
   COMMAND_PERMISSION_DENIED_MESSAGE,
@@ -135,6 +136,7 @@ export class TextHarnessBridge {
   #bot;
   #harness;
   #state;
+  #deferred;
   #contextEnhancement;
   #accessPolicy;
   #status;
@@ -176,6 +178,9 @@ export class TextHarnessBridge {
     this.#logger = logger;
     this.#replyTimeoutMs = replyTimeoutMs;
     this.#signal = signal;
+    this.#deferred = createDeferredDeliveryCoordinator({ harness, state, signal, logger,
+      deliver: (entry, outcome) => this.#deliverDeferredOutcome(entry, outcome),
+    });
     this.#approvals = new HarnessApprovalQueue({
       label: descriptor.key,
       logger,
@@ -449,6 +454,13 @@ export class TextHarnessBridge {
     return current;
   }
 
+  async #deliverDeferredOutcome(entry, outcome) {
+    const text = deferredOutcomeText(outcome);
+    return typeof this.#bot.sendDelivery === 'function'
+      ? this.#bot.sendDelivery(entry.target, createTextDeliveryBlock(text, outcome.found ? 'markdown' : 'plain'))
+      : this.#bot.sendText(entry.target, text);
+  }
+
   async waitForIdle() {
     await Promise.allSettled([
       ...this.#queues.values(),
@@ -458,6 +470,7 @@ export class TextHarnessBridge {
       ...this.#approvalTasks,
       ...this.#commandTasks,
     ]);
+    await this.#deferred.whenIdle();
   }
 
   async #processFastCommand(message, messageId, key, runner) {
@@ -480,6 +493,7 @@ export class TextHarnessBridge {
           pendingInteraction: this.#pendingInteractions.has(key)
             || this.#approvals.hasPending(key),
           control: { owner: this, key },
+          deferredDelivery: this.#deferred,
         },
       );
       if (result?.stopped) {
@@ -696,6 +710,7 @@ export class TextHarnessBridge {
         contextEnhanced = content !== originalContent;
       }
       const { answer, artifacts = [] } = await askInWorkspaceSession({
+        deferredDelivery: () => ({ coordinator: this.#deferred, target: this.#descriptor.key === 'whatsapp' ? { jid: target.jid, selfChat: target.selfChat } : target }),
         harness: this.#harness,
         state: this.#state,
         key: conversationKey,