@xmanrui/dsh-im 4.26.0 → 4.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmanrui/dsh-im",
-  "version": "4.26.0",
+  "version": "4.28.0",
   "description": "把十二种 IM 渠道和公网 AI Office 接入本机 DeepSeek Harness。 Connect twelve IM channels and a public AI Office to a local DeepSeek Harness.",
   "keywords": [
     "deepseek-harness",

package/plugin-src/client/i18n.js

@@ -111,6 +111,7 @@ const EN = Object.freeze({
   'DSH 版本兼容说明': 'DSH version compatibility',
   'dsh-im 4.25.0 支持到 DSH v0.1.6-alpha.2。': 'dsh-im 4.25.0 supports DSH up to v0.1.6-alpha.2.',
   'dsh-im 4.26.0 仅支持 DSH v0.1.7-alpha.1。': 'dsh-im 4.26.0 only supports DSH v0.1.7-alpha.1.',
+  'dsh-im 4.27.0 仅支持 DSH v0.1.7-alpha.1 及更新版本。': 'dsh-im 4.27.0 only supports DSH v0.1.7-alpha.1 and later.',
   '升级到 dsh-im 4.26.0 前，请先将 DSH 升级到 v0.1.7-alpha.1；使用旧版 DSH 请保留 dsh-im 4.25.0。': 'Before updating to dsh-im 4.26.0, upgrade DSH to v0.1.7-alpha.1. If you use an older DSH version, stay on dsh-im 4.25.0.',
   '重新检查': 'Check again',
   '刷新状态': 'Refresh status',

package/plugin-src/client/update-panel.js

@@ -471,6 +471,7 @@ export function UpdatePanel({ rpcCall, clientVersion, onStatus }) {
           h('strong', null, 'DSH 版本兼容说明'),
           h('p', { className: 'dim-updateManualHint' }, 'dsh-im 4.25.0 支持到 DSH v0.1.6-alpha.2。'),
           h('p', { className: 'dim-updateManualHint' }, 'dsh-im 4.26.0 仅支持 DSH v0.1.7-alpha.1。'),
+          h('p', { className: 'dim-updateManualHint' }, 'dsh-im 4.27.0 仅支持 DSH v0.1.7-alpha.1 及更新版本。'),
           h('p', { className: 'dim-updateManualHint' },
             '升级到 dsh-im 4.26.0 前，请先将 DSH 升级到 v0.1.7-alpha.1；使用旧版 DSH 请保留 dsh-im 4.25.0。')),
         h(ManualUpdateCommand, {

package/plugin-src/host/channels/matrix/production.mjs

@@ -5,6 +5,7 @@ import { MatrixConfigStore, MatrixSidecarStore } from '../../../../src/channels/
 import { MatrixController } from '../../../../src/channels/matrix/matrix-controller.mjs';
 import { MatrixCryptoStore, matrixCryptoPathFor } from '../../../../src/channels/matrix/matrix-crypto-store.mjs';
 import { MatrixHarnessClient } from '../../../../src/channels/matrix/matrix-harness-client.mjs';
+import { MatrixRoomHistoryStore, matrixRoomHistoryPathFor } from '../../../../src/channels/matrix/matrix-room-history.mjs';
 import { MatrixRuntime } from '../../../../src/channels/matrix/matrix-runtime.mjs';
 import { ConversationStateStore } from '../../../../src/channels/shared/conversation-state-store.mjs';
 import {
@@ -63,10 +64,13 @@ export async function createProductionController(ctx, config = {}, internals = {
   const stateStores = new Map();
   const sidecarStores = new Map();
   const cryptoStores = new Map();
+  const historyStores = new Map();
+  const ResolvedRoomHistory = internals.RoomHistoryStore ?? MatrixRoomHistoryStore;
   const ResolvedCryptoStore = internals.CryptoStore ?? MatrixCryptoStore;
   const statePath = (botId) => resolve(paths.bots, botId, 'state.json');
   const sidecarPath = (botId) => resolve(paths.bots, botId, 'matrix.json');
   const cryptoPath = (botId) => matrixCryptoPathFor(resolve(paths.bots, botId));
+  const historyPath = (botId) => matrixRoomHistoryPathFor(resolve(paths.bots, botId));
   const stateFor = async (botId) => {
     let state = stateStores.get(botId);
     if (!state) {
@@ -91,6 +95,14 @@ export async function createProductionController(ctx, config = {}, internals = {
     }
     return crypto;
   };
+  const historyFor = async (botId) => {
+    let history = historyStores.get(botId);
+    if (!history) {
+      history = await new ResolvedRoomHistory(historyPath(botId)).load();
+      historyStores.set(botId, history);
+    }
+    return history;
+  };
   const commandExecutor = createHarnessCommandExecutor(ctx, internals.commandExecutor);
   const inboundTtl = internals.inboundTtl ?? getInboundTtlRuntime(ctx, config);
   const inboundTtlService = inboundTtl?.service ?? inboundTtl;
@@ -137,6 +149,7 @@ export async function createProductionController(ctx, config = {}, internals = {
       });
       const e2eeMode = String(botConfig?.e2eeMode ?? 'optional').trim().toLowerCase();
       const cryptoStore = e2eeMode === 'off' ? null : await cryptoFor(botId);
+      const roomHistory = await historyFor(botId);
       return new ResolvedRuntime({
         config: botConfig,
         ...(accessToken ? { accessToken } : {}),
@@ -145,6 +158,7 @@ export async function createProductionController(ctx, config = {}, internals = {
         harness: workspaceScope.harness,
         state: workspaceScope.state,
         sidecar,
+        roomHistory,
         ...(cryptoStore ? { cryptoStore } : {}),
         contextEnhancement: { botId, getSettings: () => workspaces.contextEnhancementFor(botId) },
         accessPolicy: accessPolicyProvider(workspaces, botId, {

package/src/channels/feishu/bridge.mjs

@@ -305,6 +305,32 @@ function isFeishuLocalCommand(text, { hasImages = false, hasFiles = false } = {}
     || ARCHIVED_COMMAND.test(command);
 }
 
+/**
+ * A p2p text message that is nothing but a mention of the bot.
+ *
+ * The mention is stripped before we see the text, so `@bot` arrives as an empty
+ * body — indistinguishable from an empty message unless the message type is
+ * checked. Deliberately narrow:
+ *
+ *   - only `p2p`, where the reader is talking to the bot directly;
+ *   - only `text`, so a voice note, video, sticker or forwarded card keeps its
+ *     own "not supported" notice instead of silently opening a menu;
+ *   - only when nothing else came with it, so `@bot 你好` stays a prompt.
+ *
+ * The caller also treats this as a command for access control, because opening
+ * the menu is `/m` by another route and carries the same information.
+ */
+function isBareMentionMenuRequest(event, text, {
+  hasImages = false,
+  hasFiles = false,
+  hasReply = false,
+} = {}) {
+  if (event?.message?.chat_type !== 'p2p') return false;
+  if (event?.message?.message_type !== 'text') return false;
+  if (hasImages || hasFiles || hasReply) return false;
+  return !String(text ?? '').trim();
+}
+
 /** Canonical workspace/session help advertised by every bridge family. */
 const WORKSPACE_HELP_LINES = [
   '/workspace 工作区序号或绝对路径  切换工作区',
@@ -989,7 +1015,16 @@ export class FeishuHarnessBridge {
         hasImages,
         hasFiles,
       }) || isFeishuLocalCommand(commandText, { hasImages, hasFiles })
-        || (!hasImages && !hasFiles && NUMBER_REPLY.test(commandText) && this.#menus.has(key)),
+        || (!hasImages && !hasFiles && NUMBER_REPLY.test(commandText) && this.#menus.has(key))
+        // Opening the menu on a bare mention is the `/m` command by another
+        // route, so it must clear the same command gate. Treating it as plain
+        // chat let a sender without `canExecuteCommands` receive a menu that
+        // carries workspace paths and other session titles.
+        || isBareMentionMenuRequest(event, commandText, {
+          hasImages,
+          hasFiles,
+          hasReply: hasReplyReference(commandMessage),
+        }),
     });
     if (!access.allowed) {
       this.#acceptedMessageIds.set(messageId, null);
@@ -1468,6 +1503,14 @@ export class FeishuHarnessBridge {
     // accept() 侧已用 nonEmptyString(content) 判定，两侧保持一致。
     const commandText = !hasImages && !hasFiles && text ? text.trim() : null;
     if (!text && !hasImages && !hasFiles && !hasReply) {
+      // An "@bot" with nothing else carries no instruction to parse, and the
+      // menu card is what the reader is reaching for — answer it the way `/m`
+      // does rather than with a "text only" notice. Kept to plain p2p text so a
+      // voice note, video or forwarded card still gets its own notice.
+      if (isBareMentionMenuRequest(event, text, { hasImages, hasFiles, hasReply })) {
+        await this.#sendMenuCard(key, event.message.chat_id, { replyTo: event.message.message_id });
+        return;
+      }
       await this.#send(event.message.chat_id, t('目前支持文字、图片和文件消息。'), { replyTo: event.message.message_id });
       return;
     }
@@ -3755,6 +3798,7 @@ export class FeishuHarnessBridge {
     Object.assign(card, {
       blocks: structuredClone(entry.blocks), cardIds: [...entry.cardIds],
       messageId: entry.cardIds.at(-1), chunkCount: entry.cardIds.length,
+      activeCardStart: 0, renderedCardContents: new Map(),
       answerStart: entry.answerStart ?? null, answerEnd: entry.answerEnd ?? null,
       deliveryViaOpenId: true,
     });
@@ -4266,6 +4310,8 @@ export class FeishuHarnessBridge {
         renderChain: null,
         chunkCount: 1,
         cardIds: [],
+        activeCardStart: 0,
+        renderedCardContents: new Map(),
         answerStart: null,
         answerEnd: null,
         // Answer-integrity tracking: the version bumps every time the draft
@@ -4416,62 +4462,51 @@ export class FeishuHarnessBridge {
     });
   }
 
+  /** Sync only this interaction's cards; earlier interactions remain sealed. */
+  async #syncStepCardChunks(card, chunks, status) {
+    const answerVersion = card.answerVersion ?? 0;
+    const activeIds = card.cardIds.slice(card.activeCardStart);
+    const groups = chunks.length ? [...chunks] : [[]];
+    // Retain the last message as the live card when a rewritten answer shrinks.
+    // Clear stale prefixes without introducing a separate deletion/retry path.
+    while (groups.length < activeIds.length) {
+      groups.unshift([{ kind: 'message', text: t('内容已合并至后续消息。') }]);
+    }
+    // Serialize before the first await: a concurrent draft must not change the
+    // payload halfway through this render or be marked as already delivered.
+    const contents = groups.map((blocks, index) => stepStreamCard(blocks, {
+      status: index === groups.length - 1 ? status : 'sealed',
+    }));
+    for (let index = 0; index < contents.length; index += 1) {
+      let id = activeIds[index];
+      const content = contents[index];
+      if (id) {
+        if (card.renderedCardContents.get(id) !== content) {
+          await this.#patchStepCard(id, content);
+        }
+      } else {
+        id = await this.#sendCard(card.chatId, content, card.deliveryViaOpenId
+          ? { receiveIdType: 'open_id' }
+          : { replyTo: card.replyToMessageId });
+        card.cardIds.push(id);
+        activeIds.push(id);
+      }
+      card.renderedCardContents.set(id, content);
+    }
+    card.messageId = activeIds.at(-1);
+    card.chunkCount = activeIds.length;
+    card.renderedAnswerVersion = answerVersion;
+  }
+
   async #renderStepCardNow(chatId, card) {
     if (card.broken) return;
     const chunks = splitStepStreamCardBlocks(card.blocks);
+    if (!chunks.length && card.messageId === null) return;
     const live = chunks[chunks.length - 1] ?? [];
     try {
-      if (card.messageId === null) {
-        // First render: deliver every chunk. When the turn opens with a long
-        // answer already in memory, chunks.length can exceed one — sending
-        // only the live chunk here would silently drop its prefix, and the
-        // chunkCount bookkeeping below would then rewrite the delivered
-        // message with chunk 0 on the next render.
-        for (let index = 0; index < chunks.length; index += 1) {
-          const isLive = index === chunks.length - 1;
-          const id = await this.#sendCard(
-            chatId,
-            stepStreamCard(chunks[index], { status: isLive ? 'running' : 'sealed' }),
-            card.deliveryViaOpenId
-              ? { receiveIdType: 'open_id' }
-              : { replyTo: card.replyToMessageId },
-          );
-          card.cardIds.push(id);
-          if (isLive) card.messageId = id;
-        }
-        card.chunkCount = chunks.length;
-        await this.#persistMirrorState(card, live, 'running');
-        card.lastRenderAt = this.#stepPushClock.now();
-        card.renderedAnswerVersion = card.answerVersion ?? 0;
-        return;
-      }
-      // Overflow: the accumulated blocks outgrew one card. Seal the current
-      // message (no status line), spill extra chunks, and keep the last one
-      // live. Chunk boundaries are stable because blocks only append.
-      if (chunks.length > card.chunkCount) {
-        await this.#patchStepCard(
-          card.messageId,
-          stepStreamCard(chunks[card.chunkCount - 1], { status: 'sealed' }),
-        );
-        for (let index = card.chunkCount; index < chunks.length; index += 1) {
-          const isLive = index === chunks.length - 1;
-          const id = await this.#sendCard(
-            chatId,
-            stepStreamCard(chunks[index], { status: isLive ? 'running' : 'sealed' }),
-            card.deliveryViaOpenId
-              ? { receiveIdType: 'open_id' }
-              : { replyTo: card.replyToMessageId },
-          );
-          card.cardIds.push(id);
-          if (isLive) card.messageId = id;
-        }
-        card.chunkCount = chunks.length;
-      } else {
-        await this.#patchStepCard(card.messageId, stepStreamCard(live, { status: 'running' }));
-      }
+      await this.#syncStepCardChunks(card, chunks, 'running');
       await this.#persistMirrorState(card, live, 'running');
       card.lastRenderAt = this.#stepPushClock.now();
-      card.renderedAnswerVersion = card.answerVersion ?? 0;
     } catch (error) {
       card.broken = true;
       this.#logger.warn?.(
@@ -4510,52 +4545,8 @@ export class FeishuHarnessBridge {
       this.#writeStepCardAnswer(card, body);
     }
     const chunks = splitStepStreamCardBlocks(card.blocks);
-    const live = chunks[chunks.length - 1] ?? [];
     try {
-      if (card.messageId === null) {
-        // A turn without any queued render (plain Q&A): open the cards
-        // directly with their terminal status; every overflow chunk before
-        // the last one is sealed. An empty turn still opens the status card.
-        const groups = chunks.length > 0 ? chunks : [[]];
-        for (let index = 0; index < groups.length; index += 1) {
-          const isLive = index === groups.length - 1;
-          const id = await this.#sendCard(
-            card.chatId,
-            stepStreamCard(groups[index], { status: isLive ? status : 'sealed' }),
-            card.deliveryViaOpenId
-              ? { receiveIdType: 'open_id' }
-              : { replyTo: card.replyToMessageId },
-          );
-          card.cardIds.push(id);
-        }
-        return { ok: true, cardIds: card.cardIds };
-      }
-      // The live message only ever shows the last chunk; spill every chunk
-      // that has not been delivered yet as sealed cards before patching the
-      // live one, otherwise a long answer finishing on an existing card
-      // would silently drop its prefix.
-      if (chunks.length > card.chunkCount) {
-        await this.#patchStepCard(
-          card.messageId,
-          stepStreamCard(chunks[card.chunkCount - 1], { status: 'sealed' }),
-        );
-        for (let index = card.chunkCount; index < chunks.length; index += 1) {
-          const isLast = index === chunks.length - 1;
-          const id = await this.#sendCard(
-            card.chatId,
-            stepStreamCard(chunks[index], { status: isLast ? status : 'sealed' }),
-            card.deliveryViaOpenId
-              ? { receiveIdType: 'open_id' }
-              : { replyTo: card.replyToMessageId },
-          );
-          card.cardIds.push(id);
-          if (isLast) card.messageId = id;
-        }
-        card.chunkCount = chunks.length;
-      } else {
-        await this.#patchStepCard(card.messageId, stepStreamCard(live, { status }));
-      }
-      card.renderedAnswerVersion = card.answerVersion ?? 0;
+      await this.#syncStepCardChunks(card, chunks, status);
       return { ok: true, cardIds: card.cardIds };
     } catch (error) {
       // Only trust the streamed draft when the LAST SUCCESSFUL render actually
@@ -4606,8 +4597,7 @@ export class FeishuHarnessBridge {
     if (card.messageId === null) return;
     try {
       const chunks = splitStepStreamCardBlocks(card.blocks);
-      const live = chunks[chunks.length - 1] ?? [];
-      await this.#patchStepCard(card.messageId, stepStreamCard(live, { status: 'sealed' }));
+      await this.#syncStepCardChunks(card, chunks, 'sealed');
     } catch (error) {
       this.#logger.warn?.(
         '[dsh-feishu] step streaming card rotate seal failed:',
@@ -4615,6 +4605,8 @@ export class FeishuHarnessBridge {
       );
     }
     // Restart the stream on a fresh card below the interaction message.
+    card.activeCardStart = card.cardIds.length;
+    card.renderedCardContents.clear();
     card.blocks = [];
     card.messageId = null;
     card.chunkCount = 1;

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

@@ -1009,20 +1009,191 @@ export function stepStatusText(status) {
   return t('运行中');
 }
 
+/**
+ * A single card accepts only this many `table` elements. Feishu rejects the
+ * whole write with `230099 / ErrCode 11310 card table number over limit`, which
+ * leaves the card stuck on its previous content, so the reply never appears.
+ *
+ * The boundary was established by the maintainer against a live bot: five
+ * tables in one card succeeded, six failed, and a folded process panel's tables
+ * counted toward the total (3 folded + 2 in the body succeeded, 3 + 3 failed).
+ */
+export const STEP_STREAM_CARD_MAX_TABLES = 5;
+
+function hasClosingBacktickRun(text, start, length) {
+  for (let index = start; index < text.length;) {
+    if (text[index] !== '`') {
+      index += 1;
+      continue;
+    }
+    let end = index + 1;
+    while (text[end] === '`') end += 1;
+    if (end - index === length) return true;
+    index = end;
+  }
+  return false;
+}
+
+function gfmTableCells(line) {
+  const normalized = line.endsWith('\r') ? line.slice(0, -1) : line;
+  if (normalized.startsWith('    ') || normalized.startsWith('\t')) return null;
+  const text = normalized.trim();
+  if (!text) return null;
+
+  const cells = [];
+  let cell = '';
+  let separators = 0;
+  let codeRun = 0;
+  for (let index = 0; index < text.length;) {
+    const character = text[index];
+    if (character === '\\' && index + 1 < text.length) {
+      cell += text.slice(index, index + 2);
+      index += 2;
+      continue;
+    }
+    if (character === '`') {
+      let end = index + 1;
+      while (text[end] === '`') end += 1;
+      const length = end - index;
+      if (codeRun === length) {
+        codeRun = 0;
+      } else if (codeRun === 0 && hasClosingBacktickRun(text, end, length)) {
+        codeRun = length;
+      }
+      cell += text.slice(index, end);
+      index = end;
+      continue;
+    }
+    if (character === '|' && codeRun === 0) {
+      cells.push(cell);
+      cell = '';
+      separators += 1;
+      index += 1;
+      continue;
+    }
+    cell += character;
+    index += 1;
+  }
+  if (separators === 0) return null;
+  cells.push(cell);
+  if (cells[0].trim() === '') cells.shift();
+  if (cells.at(-1)?.trim() === '') cells.pop();
+  return cells.length > 0 ? cells : null;
+}
+
+/** Locate table headers once for both counting and splitting. */
+function markdownTableStarts(text) {
+  if (typeof text !== 'string' || !text) return [];
+  const lines = text.split('\n');
+  const offsets = [];
+  let offset = 0;
+  for (const line of lines) {
+    offsets.push(offset);
+    offset += line.length + 1;
+  }
+  const starts = [];
+  let fence = null;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index].replace(/\r$/, '');
+    if (fence) {
+      const close = /^ {0,3}(`{3,}|~{3,})[ \t]*$/.exec(line);
+      if (close && close[1][0] === fence[0] && close[1].length >= fence.length) fence = null;
+      continue;
+    }
+    const opening = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+    if (opening && (opening[1][0] !== '`' || !opening[2].includes('`'))) {
+      fence = opening[1];
+      continue;
+    }
+    const header = gfmTableCells(line);
+    const delimiter = gfmTableCells(lines[index + 1] ?? '');
+    if (!header || !delimiter || header.length !== delimiter.length
+      || !delimiter.every((cell) => /^\s*:?-+:?\s*$/.test(cell))) continue;
+    starts.push(offsets[index]);
+    index += 1;
+    // A delimiter-looking data row is part of this table, not another header.
+    while (index + 1 < lines.length && gfmTableCells(lines[index + 1])) index += 1;
+  }
+  return starts;
+}
+
+export function countMarkdownTables(text) {
+  return markdownTableStarts(text).length;
+}
+
+function splitMarkdownByTableLimit(text, maxTables) {
+  const starts = markdownTableStarts(text);
+  const parts = [];
+  let from = 0;
+  for (let index = maxTables; index < starts.length; index += maxTables) {
+    parts.push(text.slice(from, starts[index]));
+    from = starts[index];
+  }
+  parts.push(text.slice(from));
+  return parts;
+}
+
+/** Count the Markdown that stepStreamCard actually renders. */
+function stepStreamCardTableCount(blocks) {
+  return blocks.reduce((sum, block) => {
+    const text = block?.kind === 'notes' || block?.kind === 'tools'
+      ? (block.lines ?? []).filter((line) => typeof line === 'string' && line.trim()).join('\n')
+      : block?.text;
+    return sum + countMarkdownTables(text);
+  }, 0);
+}
+
+/** Split display copies; the bridge's logical blocks and answer indices stay intact. */
+export function splitBlockByTableLimit(block, maxTables = STEP_STREAM_CARD_MAX_TABLES) {
+  if (!block || typeof block !== 'object' || !Number.isInteger(maxTables) || maxTables < 1) return [block];
+  if (block.kind === 'notes' || block.kind === 'tools') {
+    const lines = (block.lines ?? []).filter((line) => typeof line === 'string' && line.trim());
+    if (countMarkdownTables(lines.join('\n')) <= maxTables) return [block];
+    const groups = [];
+    let current = [];
+    for (const line of lines) {
+      for (const part of splitMarkdownByTableLimit(line, maxTables)) {
+        if (current.length && countMarkdownTables([...current, part].join('\n')) > maxTables) {
+          groups.push(current);
+          current = [];
+        }
+        current.push(part);
+      }
+    }
+    if (current.length) groups.push(current);
+    return groups.map((lines, index) => ({ ...block, lines, omitted: index === 0 ? block.omitted : 0 }));
+  }
+  if (typeof block.text !== 'string' || countMarkdownTables(block.text) <= maxTables) return [block];
+  return splitMarkdownByTableLimit(block.text, maxTables).map((text) => ({ ...block, text }));
+}
+
 /**
  * Split accumulated blocks into card-sized chunks at block boundaries,
- * budgeted by the encoded running-status card (the largest render). Every
- * chunk keeps at least one block so progress is never dropped. The caller
- * renders all but the last chunk as `sealed` and the last one live.
+ * budgeted by the encoded running-status card (the largest render) **and** by
+ * the table count, because a card accepts only a handful of tables no matter
+ * how small it is. Every chunk keeps at least one block so progress is never
+ * dropped. The caller renders all but the last chunk as `sealed` and the last
+ * one live.
  */
-export function splitStepStreamCardBlocks(blocks, limit = STEP_STREAM_CARD_MAX_BYTES) {
-  const list = (Array.isArray(blocks) ? blocks : []).filter(Boolean);
+export function splitStepStreamCardBlocks(
+  blocks,
+  limit = STEP_STREAM_CARD_MAX_BYTES,
+  maxTables = STEP_STREAM_CARD_MAX_TABLES,
+) {
+  // A single block can carry more tables than a card accepts — one short answer
+  // with six small tables — and splitting only between blocks cannot help. Each
+  // block is broken at table boundaries first, so the walk below sees pieces it
+  // can actually distribute.
+  const list = (Array.isArray(blocks) ? blocks : [])
+    .filter(Boolean)
+    .flatMap((block) => splitBlockByTableLimit(block, maxTables));
   if (list.length === 0) return [];
   const chunks = [];
   let current = [];
   for (const block of list) {
-    if (current.length > 0
-      && Buffer.byteLength(stepStreamCard([...current, block]), 'utf8') > limit) {
+    const tooLarge = Buffer.byteLength(stepStreamCard([...current, block]), 'utf8') > limit;
+    const tooManyTables = stepStreamCardTableCount([...current, block]) > maxTables;
+    if (current.length > 0 && (tooLarge || tooManyTables)) {
       chunks.push(current);
       current = [block];
     } else {

package/src/channels/feishu/message-utils.mjs

@@ -534,8 +534,17 @@ export function extractInboundMessage(event, client) {
   const imageKeys = standaloneImageKey ? [standaloneImageKey] : post?.imageKeys ?? [];
   const file = messageType === 'file' ? feishuFileSource(event, client, parsed) : null;
   const replyTo = feishuReplyReference(event, client);
+  // A forwarded card arrives as `interactive`. Without this branch its text was
+  // dropped entirely, so the message looked empty and the reader got the
+  // "text, image and file only" notice — even though the same extraction is
+  // already trusted for quoted cards (`feishuReplyReference`).
+  const cardText = messageType === 'interactive' ? interactiveCardText(parsed) : '';
   return {
-    content: messageType === 'text' ? extractText(event) ?? '' : post?.text ?? '',
+    content: messageType === 'text'
+      ? extractText(event) ?? ''
+      : messageType === 'interactive'
+        ? cardText
+        : post?.text ?? '',
     images: imageKeys.map((key) => feishuImageSource(event, client, key)),
     files: file ? [file] : [],
     ...(replyTo ? { replyTo } : {}),

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

@@ -202,12 +202,13 @@ export class StateStore {
 
   async #persist() {
     const snapshot = JSON.stringify(this.#state, null, 2) + '\n';
-    this.#writeQueue = this.#writeQueue.then(async () => {
+    const operation = this.#writeQueue.then(async () => {
       await mkdir(dirname(this.#path), { recursive: true, mode: 0o700 });
       const temporary = `${this.#path}.tmp`;
       await writeFile(temporary, snapshot, { encoding: 'utf8', mode: 0o600 });
       await rename(temporary, this.#path);
     });
-    await this.#writeQueue;
+    this.#writeQueue = operation.then(() => undefined, () => undefined);
+    await operation;
   }
 }

package/src/channels/matrix/matrix-config-store.mjs

@@ -13,6 +13,9 @@ const E2EE_MODES = new Set(['off', 'optional', 'required']);
 const AUTO_JOIN_MODES = new Set(['authorized', 'all']);
 const MAX_MESSAGE_LENGTH_BOUNDS = Object.freeze({ min: 500, max: 65_535 });
 const MAX_MEDIA_BYTES_CEILING = 104_857_600;
+const ROOM_CONTEXT_LIMIT_BOUNDS = Object.freeze({ min: 1, max: 500 });
+const ROOM_CONTEXT_CHARS_BOUNDS = Object.freeze({ min: 200, max: 200_000 });
+const ROOM_CONTEXT_TZ_BOUNDS = Object.freeze({ min: -840, max: 840 });
 
 function cleanString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
@@ -179,10 +182,15 @@ export class MatrixConfigStore {
     const allowedRooms = roomIdList(value.allowedRooms);
     const freeResponseRooms = roomIdList(value.freeResponseRooms);
     const ignoreUserPatterns = patternList(value.ignoreUserPatterns);
+    const roomContextLimit = boundedInteger(value.roomContextLimit, ROOM_CONTEXT_LIMIT_BOUNDS);
+    const roomContextMaxChars = boundedInteger(value.roomContextMaxChars, ROOM_CONTEXT_CHARS_BOUNDS);
+    const roomContextTzOffsetMinutes = boundedInteger(value.roomContextTzOffsetMinutes, ROOM_CONTEXT_TZ_BOUNDS);
     if (!E2EE_MODES.has(e2eeMode) || !AUTO_JOIN_MODES.has(autoJoinInvites)
       || maxMessageLength === null || maxMediaBytes === null
-      || allowedRooms === null || freeResponseRooms === null || ignoreUserPatterns === null) return null;
-    for (const key of ['requireMention', 'processNotices', 'allowRoomMentions', 'reactions']) {
+      || allowedRooms === null || freeResponseRooms === null || ignoreUserPatterns === null
+      || roomContextLimit === null || roomContextMaxChars === null
+      || roomContextTzOffsetMinutes === null) return null;
+    for (const key of ['requireMention', 'processNotices', 'allowRoomMentions', 'reactions', 'roomContextEnabled']) {
       if (value?.[key] !== undefined && typeof value[key] !== 'boolean') return null;
     }
     return Object.freeze({
@@ -208,6 +216,10 @@ export class MatrixConfigStore {
       ...(allowedRooms !== undefined ? { allowedRooms: Object.freeze(allowedRooms) } : {}),
       ...(freeResponseRooms !== undefined ? { freeResponseRooms: Object.freeze(freeResponseRooms) } : {}),
       ...(ignoreUserPatterns !== undefined ? { ignoreUserPatterns: Object.freeze(ignoreUserPatterns) } : {}),
+      ...(typeof value.roomContextEnabled === 'boolean' ? { roomContextEnabled: value.roomContextEnabled } : {}),
+      ...(roomContextLimit !== undefined ? { roomContextLimit } : {}),
+      ...(roomContextMaxChars !== undefined ? { roomContextMaxChars } : {}),
+      ...(roomContextTzOffsetMinutes !== undefined ? { roomContextTzOffsetMinutes } : {}),
     });
   }