@xmanrui/dsh-im 4.26.0 → 4.28.0

package/src/channels/matrix/matrix-room-history.mjs

@@ -0,0 +1,316 @@
+// Shared, per-room conversation record for the Matrix channel.
+//
+// A Matrix room is one shared context: every participant's messages belong to
+// the same record, regardless of who is addressed. The channel bot replies only
+// when it is mentioned, but it conditions on the whole room. This store keeps a
+// bounded, durable timeline of human and bot messages per room so that:
+//   - unmentioned chatter is not lost -- it is recorded and later injected as
+//     context the next time the bot is addressed, and
+//   - older messages remain searchable across days so a session can pull prior
+//     room history on demand.
+//
+// The store owns only the record and its queries; the runtime decides what is
+// recorded and when pending context is consumed, so the trigger boundary stays
+// in the inbound pipeline.
+
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+
+export const DEFAULT_ROOM_HISTORY_LIMIT = 2_000;
+export const MIN_ROOM_HISTORY_LIMIT = 20;
+export const MAX_ROOM_HISTORY_LIMIT = 50_000;
+export const MIN_ROOM_CONTEXT_LIMIT = 1;
+export const MAX_ROOM_CONTEXT_LIMIT = 500;
+export const MIN_ROOM_CONTEXT_CHARS = 200;
+export const MAX_ROOM_CONTEXT_CHARS = 200_000;
+const ENTRY_TEXT_CHARS = 4_000;
+const INJECTED_EVENT_MAX = 1_000;
+
+export function matrixRoomHistoryPathFor(botDir) {
+  return `${botDir}/matrix-history.json`;
+}
+
+function boundedInteger(value, min, max, fallback) {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return fallback;
+  const rounded = Math.trunc(value);
+  if (!Number.isSafeInteger(rounded)) return fallback;
+  return Math.min(Math.max(rounded, min), max);
+}
+
+function cleanText(value, max) {
+  if (typeof value !== 'string') return '';
+  const trimmed = value.trim();
+  if (!trimmed) return '';
+  return trimmed.length > max ? `${trimmed.slice(0, max)}…` : trimmed;
+}
+
+function localPart(matrixId) {
+  if (typeof matrixId !== 'string') return '';
+  const at = matrixId.indexOf(':');
+  const local = at >= 0 ? matrixId.slice(1, at) : matrixId.replace(/^@/, '');
+  return local.trim();
+}
+
+// Start of the civil day that `nowMs` falls in, at the configured UTC offset.
+// Returned as an absolute epoch-ms threshold so an entry's own origin_serverTs
+// (ms) can be compared against it directly.
+export function roomContextDayStartTs(nowMs, tzOffsetMinutes) {
+  const now = Number.isSafeInteger(nowMs) ? nowMs : Date.now();
+  const offset = Number.isSafeInteger(tzOffsetMinutes) ? tzOffsetMinutes : 0;
+  const shifted = now + offset * 60_000;
+  const dayStartShifted = Math.floor(shifted / 86_400_000) * 86_400_000;
+  return dayStartShifted - offset * 60_000;
+}
+
+function toTimestamp(value) {
+  if (Number.isSafeInteger(value) && value > 0) return value;
+  if (typeof value === 'number' && Number.isFinite(value) && value > 0) return Math.trunc(value);
+  return Date.now();
+}
+
+function normalizeEntry(raw) {
+  if (!raw || typeof raw !== 'object') return null;
+  const eventId = cleanText(raw.eventId, 255);
+  const text = cleanText(raw.text, ENTRY_TEXT_CHARS);
+  if (!eventId) return null;
+  if (!text && raw.fromBot !== true) return null;
+  const kind = raw.kind === 'bot' || raw.fromBot === true ? 'bot'
+    : raw.kind === 'command' ? 'command' : 'human';
+  return {
+    eventId,
+    sender: cleanText(raw.sender, 512),
+    name: cleanText(raw.name, 256) || localPart(raw.sender),
+    text,
+    ts: toTimestamp(raw.ts),
+    kind,
+    injected: raw.injected === true || kind !== 'human',
+  };
+}
+
+/**
+ * Durable, bounded, per-room message record. Entries are kept in arrival order
+ * (the runtime feeds the sync timeline, which is chronological per room). Each
+ * room is trimmed to `limit` most-recent entries and injected-event markers are
+ * pruned against the live entries so growth stays bounded. Writes are serialized
+ * through an in-memory queue with an atomic temp-file rename, mirroring the
+ * Matrix sidecar.
+ */
+export class MatrixRoomHistoryStore {
+  #path;
+  #limit;
+  #value = { rooms: Object.create(null) };
+  #writeQueue = Promise.resolve();
+
+  constructor(path, { limit = DEFAULT_ROOM_HISTORY_LIMIT } = {}) {
+    if (!path) throw new TypeError('Matrix room history requires a file path');
+    this.#path = path;
+    this.#limit = boundedInteger(limit, MIN_ROOM_HISTORY_LIMIT, MAX_ROOM_HISTORY_LIMIT, DEFAULT_ROOM_HISTORY_LIMIT);
+  }
+
+  get limit() {
+    return this.#limit;
+  }
+
+  async load() {
+    try {
+      const parsed = JSON.parse(await readFile(this.#path, 'utf8'));
+      const rooms = Object.create(null);
+      if (parsed && typeof parsed === 'object' && parsed.rooms && typeof parsed.rooms === 'object') {
+        for (const [roomId, room] of Object.entries(parsed.rooms)) {
+          if (!roomId || !room || typeof room !== 'object') continue;
+          const entries = Array.isArray(room.entries)
+            ? room.entries.map(normalizeEntry).filter(Boolean)
+            : [];
+          const injected = new Set((Array.isArray(room.injected) ? room.injected : [])
+            .filter((id) => typeof id === 'string' && id));
+          rooms[roomId] = { entries, injected };
+        }
+      }
+      this.#value = { rooms };
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error;
+    }
+    return this;
+  }
+
+  #roomEntry(roomId) {
+    let room = this.#value.rooms[roomId];
+    if (!room) {
+      room = { entries: [], injected: new Set() };
+      this.#value.rooms[roomId] = room;
+    }
+    return room;
+  }
+
+  #persist() {
+    const rooms = Object.create(null);
+    for (const [roomId, room] of Object.entries(this.#value.rooms)) {
+      if (room.entries.length === 0) continue;
+      rooms[roomId] = {
+        entries: room.entries,
+        injected: [...room.injected].slice(-INJECTED_EVENT_MAX),
+      };
+    }
+    const snapshot = JSON.stringify({ rooms }, null, 2);
+    const operation = this.#writeQueue.then(async () => {
+      await mkdir(dirname(this.#path), { recursive: true, mode: 0o700 });
+      const temporary = `${this.#path}.tmp`;
+      await writeFile(temporary, `${snapshot}\n`, { encoding: 'utf8', mode: 0o600 });
+      await rename(temporary, this.#path);
+    });
+    this.#writeQueue = operation.then(() => undefined, () => undefined);
+    void operation.catch(() => undefined);
+  }
+
+  /**
+   * Record one room message. The caller decides the kind ('human', 'command'
+   * or 'bot'); non-human and explicitly injected entries are marked as already
+   * consumed so they never surface as pending context. Duplicate event ids are
+   * ignored to keep a replayed sync from double-counting an entry.
+   */
+  append({ roomId, eventId, sender, name, text, ts, kind = 'human', injected } = {}) {
+    if (!roomId || typeof eventId !== 'string' || !eventId.trim()) return null;
+    const entry = normalizeEntry({ eventId, sender, name, text, ts, kind, injected });
+    if (!entry) return null;
+    const room = this.#roomEntry(roomId);
+    if (room.entries.some((existing) => existing.eventId === entry.eventId)) return null;
+    room.entries.push(entry);
+    if (entry.injected) room.injected.add(entry.eventId);
+    if (room.entries.length > this.#limit) {
+      const dropped = room.entries.splice(0, room.entries.length - this.#limit);
+      for (const removed of dropped) room.injected.delete(removed.eventId);
+    }
+    this.#persist();
+    return entry;
+  }
+
+  /**
+   * Ambient human chatter that has not been injected yet, from the same civil
+   * day (entries at or after `sinceTs`), in chronological order. Pure -- does not
+   * mark anything -- so the runtime can inspect what would be injected.
+   */
+  pending({ roomId, sinceTs = 0, limit = MAX_ROOM_CONTEXT_LIMIT } = {}) {
+    const room = this.#value.rooms[roomId];
+    if (!room) return [];
+    const cap = boundedInteger(limit, MIN_ROOM_CONTEXT_LIMIT, MAX_ROOM_CONTEXT_LIMIT, MAX_ROOM_CONTEXT_LIMIT);
+    return room.entries
+      .filter((entry) => entry.kind === 'human' && !room.injected.has(entry.eventId) && entry.ts > sinceTs)
+      .slice(-cap);
+  }
+
+  /**
+   * Select the pending same-day chatter to inject now and mark those entries as
+   * consumed, bounded by both a count and a character budget (the most recent
+   * entries are preferred so the freshest context wins when the budget binds).
+   */
+  consumePending({ roomId, sinceTs = 0, limit, maxChars, now = Date.now() } = {}) {
+    const room = this.#value.rooms[roomId];
+    if (!room) return [];
+    const cap = boundedInteger(limit, MIN_ROOM_CONTEXT_LIMIT, MAX_ROOM_CONTEXT_LIMIT, 50);
+    const charCap = boundedInteger(maxChars, MIN_ROOM_CONTEXT_CHARS, MAX_ROOM_CONTEXT_CHARS, 8_000);
+    const dayStart = roomContextDayStartTs(now, 0);
+    const floor = Math.max(Number.isSafeInteger(sinceTs) ? sinceTs : 0, dayStart);
+    const candidates = room.entries
+      .filter((entry) => entry.kind === 'human' && !room.injected.has(entry.eventId) && entry.ts > floor);
+    const selected = [];
+    let used = 0;
+    for (let index = candidates.length - 1; index >= 0 && selected.length < cap; index -= 1) {
+      const entry = candidates[index];
+      const cost = entry.text.length + (entry.name ? entry.name.length + 2 : 1);
+      if (selected.length > 0 && used + cost > charCap) break;
+      selected.unshift(entry);
+      used += cost;
+    }
+    for (const entry of selected) room.injected.add(entry.eventId);
+    if (selected.length > 0) this.#persist();
+    return selected;
+  }
+
+  /**
+   * Search the recorded room history across the retained window. Substring match
+   * against text and speaker display name (case-insensitive), with optional
+   * inclusive time bounds and a recency-first limit. Used to surface older room
+   * history a session can pull in after the current-day auto-context has expired.
+   */
+  search({ roomId, query = '', sender = null, from = null, to = null, limit = 20 } = {}) {
+    const room = this.#value.rooms[roomId];
+    if (!room) return [];
+    const needle = cleanText(query, 512).toLowerCase();
+    const wantSender = cleanText(sender, 512).toLowerCase();
+    const cap = boundedInteger(limit, 1, MAX_ROOM_CONTEXT_LIMIT, 20);
+    const matches = [];
+    for (let index = room.entries.length - 1; index >= 0 && matches.length < cap; index -= 1) {
+      const entry = room.entries[index];
+      if (Number.isSafeInteger(from) && from > 0 && entry.ts < from) continue;
+      if (Number.isSafeInteger(to) && to > 0 && entry.ts > to) continue;
+      if (wantSender
+        && entry.sender.toLowerCase() !== wantSender
+        && localPart(entry.sender).toLowerCase() !== wantSender
+        && entry.name.toLowerCase() !== wantSender) continue;
+      if (needle) {
+        const haystack = `${entry.text}\n${entry.name}`.toLowerCase();
+        if (!haystack.includes(needle)) continue;
+      }
+      matches.push(entry);
+    }
+    return matches;
+  }
+
+  /** Drop a room record entirely (used when a room is removed/reset). */
+  clear(roomId) {
+    if (!this.#value.rooms[roomId]) return false;
+    delete this.#value.rooms[roomId];
+    this.#persist();
+    return true;
+  }
+
+  /** Await the serialized write queue so all queued changes reach disk. */
+  async flush() {
+    await this.#writeQueue;
+  }
+
+  async remove() {
+    const operation = this.#writeQueue.then(async () => {
+      const { unlink } = await import('node:fs/promises');
+      await unlink(this.#path).catch((error) => {
+        if (error?.code !== 'ENOENT') throw error;
+      });
+    });
+    this.#writeQueue = operation.then(() => undefined, () => undefined);
+    await operation;
+  }
+}
+
+/**
+ * Format pending entries as a context block prepended to the prompt. Entries are
+ * attributed by display name so the model can tell participants apart; the block
+ * states it is room chatter the bot was not directly addressed in.
+ */
+// Each line carries a clock stamp and a bracketed speaker, and the whole run sits between a labelled
+// opening and a closing fence: a bare list of speaker-colon-text lines reads to the model as questions
+// that are waiting to be answered one by one.
+function roomContextStamp(ts, offsetMinutes) {
+  const stamp = Number.isSafeInteger(ts) ? ts : 0;
+  const offset = Number.isSafeInteger(offsetMinutes) ? offsetMinutes : 0;
+  const shifted = new Date(stamp + offset * 60_000);
+  const hours = String(shifted.getUTCHours()).padStart(2, '0');
+  const minutes = String(shifted.getUTCMinutes()).padStart(2, '0');
+  return `[${hours}:${minutes}]`;
+}
+
+export function formatRoomContextBlock(entries, {
+  header = '', instruction = '', begin = '', end = '', tzOffsetMinutes = 0,
+} = {}) {
+  if (!Array.isArray(entries) || entries.length === 0) return '';
+  const lines = entries.map((entry) => {
+    const speaker = entry.name || entry.sender || '?';
+    return `${roomContextStamp(entry.ts, tzOffsetMinutes)} [${speaker}] ${entry.text}`;
+  });
+  const parts = [];
+  if (header) parts.push(header);
+  if (instruction) parts.push(instruction);
+  if (begin) parts.push(begin);
+  parts.push(...lines);
+  if (end) parts.push(end);
+  return parts.join('\n');
+}

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

@@ -18,10 +18,16 @@ import {
   ClockSkewGuard,
   compileIgnorePatterns,
   EventDedupeRing,
+  isMatrixCommandLike,
   normalizeMatrixDeliveryTarget,
   normalizeMatrixTimelineEvent,
   resolveBangMatrixCommand,
 } from './matrix-normalize.mjs';
+import {
+  DEFAULT_ROOM_HISTORY_LIMIT,
+  formatRoomContextBlock,
+  roomContextDayStartTs,
+} from './matrix-room-history.mjs';
 import {
   applyMatrixRelations,
   buildMatrixEditContent,
@@ -38,6 +44,13 @@ const INVITE_JOIN_TIMEOUT_MS = 45_000;
 const DEFAULT_MAX_MESSAGE_LENGTH = 16_000;
 const DEFAULT_MAX_MEDIA_BYTES = 104_857_600;
 const EDIT_STREAM_INTERVAL_MS = 350;
+
+function safeInt(value, min, max, fallback) {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return fallback;
+  const rounded = Math.trunc(value);
+  if (!Number.isSafeInteger(rounded)) return fallback;
+  return Math.min(Math.max(rounded, min), max);
+}
 const DEAD_ROOM_MARKERS = Object.freeze(['no servers', 'room not found']);
 const IMAGE_MEDIA_TYPES = new Set(['image/jpeg', 'image/png', 'image/webp', 'image/gif']);
 
@@ -106,6 +119,16 @@ function inviteSenderOf(inviteRoom) {
   return null;
 }
 
+// A room is a direct chat only when the homeserver itself says so: the invite's own membership event
+// carries is_direct, or the account's m.direct listing names the room. A two-member room is an
+// ordinary room, where the mention gate must keep applying, so the joined-member count is never a signal.
+function inviteMarksDirect(inviteRoom) {
+  const events = Array.isArray(inviteRoom?.invite_state?.events) ? inviteRoom.invite_state.events : [];
+  return events.some((event) => event?.type === 'm.room.member'
+    && event?.content?.membership === 'invite'
+    && event?.content?.is_direct === true);
+}
+
 function timelineEventsOf(joinRoom) {
   const events = Array.isArray(joinRoom?.timeline?.events) ? joinRoom.timeline.events : [];
   return events.filter((event) => event && typeof event === 'object' && event.state_key === undefined);
@@ -186,6 +209,7 @@ export class MatrixRuntime {
     createApi = (options) => new MatrixApi(options),
     cryptoStore = null,
     createCrypto = null,
+    roomHistory = null,
     isKnownCommand,
   } = {}) {
     const homeserver = validateMatrixHomeserver(config.homeserver);
@@ -233,6 +257,17 @@ export class MatrixRuntime {
       ? createCrypto
       : (options) => new MatrixCryptoEngine(options);
     this.#isKnownCommand = typeof isKnownCommand === 'function' ? isKnownCommand : () => false;
+    this.#roomHistory = roomHistory
+      && typeof roomHistory.append === 'function'
+      && typeof roomHistory.consumePending === 'function'
+      && typeof roomHistory.pending === 'function'
+      && typeof roomHistory.search === 'function'
+      ? roomHistory
+      : null;
+    this.#roomContextLimit = safeInt(config.roomContextLimit, 1, 500, 50);
+    this.#roomContextMaxChars = safeInt(config.roomContextMaxChars, 200, 200_000, 8_000);
+    this.#roomContextTzOffsetMinutes = safeInt(config.roomContextTzOffsetMinutes, -840, 840, 0);
+    this.#roomContextEnabled = config.roomContextEnabled !== false;
     this.#replyTimeoutMs = replyTimeoutMs;
     this.#patterns = compileIgnorePatterns(config.ignoreUserPatterns);
     for (const roomId of toRoomSet(config.freeResponseRooms)) this.#freeRooms.add(roomId);
@@ -241,6 +276,11 @@ export class MatrixRuntime {
 
   #freeRooms = new Set();
   #allowedRooms = new Set();
+  #roomHistory = null;
+  #roomContextLimit = 50;
+  #roomContextMaxChars = 8_000;
+  #roomContextTzOffsetMinutes = 0;
+  #roomContextEnabled = true;
 
   get status() {
     return this.#status;
@@ -437,12 +477,13 @@ export class MatrixRuntime {
       if (!Array.isArray(list)) continue;
       for (const roomId of list) if (isMatrixRoomId(roomId)) this.#dmRooms.add(roomId);
     }
-    for (const roomId of this.#sidecar.dmRooms()) this.#dmRooms.add(roomId);
+    // A persisted direct chat survives only where the bot really routes a person to it, or where the
+    // account data above re-registers it: residue from the retired member-count rule is forgotten here.
+    const routedTo = new Set(Object.values(this.#sidecar.dmRoomByUser()).filter((roomId) => isMatrixRoomId(roomId)));
+    for (const roomId of this.#sidecar.dmRooms()) if (routedTo.has(roomId)) this.#dmRooms.add(roomId);
     for (const roomId of this.#sidecar.joinedRooms()) this.#joinedRooms.add(roomId);
-    await this.#classifyUnknownRooms();
-    for (const roomId of Object.keys(rooms.invite ?? {})) {
-      const inviter = inviteSenderOf(rooms.invite?.[roomId]);
-      this.#scheduleInviteJoin(roomId, inviter);
+    for (const [roomId, room] of Object.entries(rooms.invite ?? {})) {
+      this.#scheduleInviteJoin(roomId, inviteSenderOf(room), inviteMarksDirect(room));
     }
     // Queued to-device room keys land before the offline timeline replay so queued ciphertext can decrypt on first sight.
     await this.#dispatchToDeviceEvents(initial?.to_device?.events);
@@ -461,14 +502,6 @@ export class MatrixRuntime {
     this.#status.encryptedRoomsSeen = this.#encryptedRooms.size;
   }
 
-  async #classifyUnknownRooms() {
-    for (const roomId of this.#joinedRooms) {
-      if (this.#dmRooms.has(roomId)) continue;
-      const count = await this.#api.getJoinedMemberCount(roomId).catch(() => null);
-      if (count !== null && count <= 2) this.#dmRooms.add(roomId);
-    }
-  }
-
   async #syncLoop(generation) {
     while (!this.#stopped && generation === this.#generation && this.#api) {
       try {
@@ -537,7 +570,7 @@ export class MatrixRuntime {
     }
     for (const [roomId, room] of Object.entries(rooms.invite ?? {})) {
       if (!isMatrixRoomId(roomId)) continue;
-      this.#scheduleInviteJoin(roomId, inviteSenderOf(room));
+      this.#scheduleInviteJoin(roomId, inviteSenderOf(room), inviteMarksDirect(room));
     }
     if (typeof data?.next_batch === 'string' && data.next_batch) {
       this.#lastBatch = data.next_batch;
@@ -588,6 +621,7 @@ export class MatrixRuntime {
         this.#status.lastClockSkewAt = new Date().toISOString();
         this.#logger.warn?.(t('Matrix 收到的时间戳持续远落后于本机时间，检测到本机时钟超前，请校准系统时间后重启机器人。'));
       }
+      if (outcome.drop === 'mention-required') this.#recordRoomAmbient(roomId, event);
       return;
     }
     const message = { ...outcome.message };
@@ -598,6 +632,22 @@ export class MatrixRuntime {
         message.addressed = true;
       }
     }
+    if (this.#roomHistory && this.#roomContextEnabled && message.kind === 'group') {
+      if (message.addressed) {
+        const commandLike = isMatrixCommandLike(message.content);
+        const directAddress = message.mentioned === true || Boolean(message.replyToEventId);
+        this.#recordRoomHuman(message, { kind: commandLike ? 'command' : 'human', injected: true });
+        if (!commandLike && directAddress) {
+          const block = this.#consumeRoomContext(message.roomId);
+          if (block) {
+            const label = t('【下面这条才是对你的提问，请只回答它】');
+            message.content = `${block}\n\n${label}\n${message.content}`;
+          }
+        }
+      } else {
+        this.#recordRoomHuman(message, { kind: 'human', injected: false });
+      }
+    }
     void Promise.resolve(this.#bridge?.accept(message)).catch((error) => {
       this.#logger.warn?.('[dsh-im:matrix] inbound message handling failed:', error?.message ?? error);
     });
@@ -606,6 +656,68 @@ export class MatrixRuntime {
     }
   }
 
+  #recordRoomAmbient(roomId, event) {
+    if (!this.#roomHistory || !this.#roomContextEnabled) return;
+    if (this.#dmRooms.has(roomId)) return;
+    const eventId = typeof event?.event_id === 'string' ? event.event_id : '';
+    const sender = typeof event?.sender === 'string' ? event.sender : '';
+    const body = typeof event?.content?.body === 'string' ? event.content.body.trim() : '';
+    if (!eventId || !sender || !body) return;
+    const self = this.#botUserId?.toLowerCase() ?? '';
+    if (self !== '' && sender.toLowerCase() === self) return;
+    this.#roomHistory.append({
+      roomId,
+      eventId,
+      sender,
+      text: body,
+      ts: Number.isSafeInteger(event?.origin_server_ts) ? event.origin_server_ts : Date.now(),
+      kind: 'human',
+      injected: false,
+    });
+  }
+
+  #recordRoomHuman(message, { kind = 'human', injected = false } = {}) {
+    if (!this.#roomHistory || !this.#roomContextEnabled) return;
+    const text = typeof message.content === 'string' ? message.content.trim() : '';
+    if (!text || !message.messageId || !message.senderId) return;
+    const self = this.#botUserId?.toLowerCase() ?? '';
+    if (self !== '' && message.senderId.toLowerCase() === self) return;
+    this.#roomHistory.append({
+      roomId: message.roomId,
+      eventId: message.messageId,
+      sender: message.senderId,
+      text,
+      ts: Date.now(),
+      kind,
+      injected,
+    });
+  }
+
+  #consumeRoomContext(roomId) {
+    if (!this.#roomHistory) return '';
+    const now = Date.now();
+    const selected = this.#roomHistory.consumePending({
+      roomId,
+      sinceTs: roomContextDayStartTs(now, this.#roomContextTzOffsetMinutes),
+      limit: this.#roomContextLimit,
+      maxChars: this.#roomContextMaxChars,
+      now,
+    });
+    if (selected.length === 0) return '';
+    // The room timeline echoes the bot's own messages too; showing them as other members' speech makes
+    // the model quote itself and answer its own earlier reply, so only third-party lines are presented.
+    const self = this.#botUserId?.toLowerCase() ?? '';
+    const others = selected.filter((entry) => self === '' || String(entry?.sender ?? '').toLowerCase() !== self);
+    if (others.length === 0) return '';
+    return formatRoomContextBlock(others, {
+      header: t('【群聊背景】以下各条是群里其他成员之间的发言，均未指向你。'),
+      instruction: t('这些内容只用来了解现场发生过什么。请勿逐条回应、复述、翻译或总结它们，也不要因为它们而改变下面那条提问的回答。'),
+      begin: t('—— 背景开始 ——'),
+      end: t('—— 背景结束（以上无需回应） ——'),
+      tzOffsetMinutes: this.#roomContextTzOffsetMinutes,
+    });
+  }
+
   #noteEncryptedRoom(roomId) {
     this.#encryptedRooms.add(roomId);
     this.#status.encryptedRoomsSeen = this.#encryptedRooms.size;
@@ -619,7 +731,7 @@ export class MatrixRuntime {
 
   // ---- 邀请 join ----
 
-  #scheduleInviteJoin(roomId, inviter) {
+  #scheduleInviteJoin(roomId, inviter, marksDirect = false) {
     if (this.#stopped || !isMatrixRoomId(roomId) || this.#joinedRooms.has(roomId)) return;
     if (this.#sidecar.isDeclined(roomId)) return;
     const allowed = this.#config.autoJoinInvites === 'all' || inviterAllowed(this.#accessPolicy, inviter);
@@ -633,12 +745,12 @@ export class MatrixRuntime {
     if (this.#inviteTasks.has(roomId)) return;
     const controller = new AbortController();
     this.#inviteTasks.set(roomId, controller);
-    void this.#joinInvitedRoom(roomId, inviter, controller).finally(() => {
+    void this.#joinInvitedRoom(roomId, inviter, controller, marksDirect).finally(() => {
       this.#inviteTasks.delete(roomId);
     });
   }
 
-  async #joinInvitedRoom(roomId, inviter, controller) {
+  async #joinInvitedRoom(roomId, inviter, controller, marksDirect = false) {
     const timeout = AbortSignal.timeout(INVITE_JOIN_TIMEOUT_MS);
     const signal = AbortSignal.any([controller.signal, timeout]);
     try {
@@ -646,7 +758,7 @@ export class MatrixRuntime {
       this.#joinedRooms.add(roomId);
       this.#status.joinedRooms = this.#joinedRooms.size;
       await this.#sidecar.apply({ joinedRooms: [...this.#joinedRooms] });
-      if (inviter) await this.#recordDmRoom(roomId, inviter);
+      if (inviter) await this.#recordDmRoom(roomId, inviter, marksDirect);
       this.#logger.info?.(t('Matrix 已按授权邀请加入房间 {room}。'), { room: roomId });
     } catch (error) {
       const text = String(error?.message ?? '').toLowerCase();
@@ -664,14 +776,16 @@ export class MatrixRuntime {
     }
   }
 
-  async #recordDmRoom(roomId, inviter) {
+  // The inviter's cached room stays usable for outbound routing either way; only an authoritative
+// is_direct invite registers the room as a direct chat for inbound handling.
+  async #recordDmRoom(roomId, inviter, marksDirect = false) {
     const direct = await this.#api.getAccountData('m.direct').catch(() => null);
     const map = { ...(direct && typeof direct === 'object' && !Array.isArray(direct) ? direct : {}) };
     const list = Array.isArray(map[inviter]) ? [...map[inviter]] : [];
     if (!list.includes(roomId)) list.push(roomId);
     map[inviter] = list;
     await this.#api.setAccountData('m.direct', map).catch(() => undefined);
-    this.#dmRooms.add(roomId);
+    if (marksDirect) this.#dmRooms.add(roomId);
     const dmRoomByUser = { ...this.#sidecar.dmRoomByUser(), [inviter.trim().toLowerCase()]: roomId };
     await this.#sidecar.apply({ dmRooms: [...this.#dmRooms], dmRoomByUser });
   }

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

@@ -1,5 +1,6 @@
 // English translations (feishu area). Keys are exact Chinese literals passed to t().
 export default {
+  '内容已合并至后续消息。': 'Content has been consolidated into the following messages.',
   // feishu/bridge.mjs — welcome / help
   '北汇星河 AIOS 已连接 DeepSeek Harness。':
     'BeiHui XingHe AIOS is connected to DeepSeek Harness.',

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

@@ -11,6 +11,16 @@ export default {
     'Matrix long polling and Harness replies are all working.',
   'Matrix 连接当前离线。':
     'The Matrix connection is currently offline.',
+  '【群聊背景】以下各条是群里其他成员之间的发言，均未指向你。':
+    '[Room background] The lines below are messages other members exchanged among themselves; none of them was addressed to you.',
+  '这些内容只用来了解现场发生过什么。请勿逐条回应、复述、翻译或总结它们，也不要因为它们而改变下面那条提问的回答。':
+    'This only tells you what happened in the room. Do not answer, restate, translate or summarise these lines one by one, and do not let them change how you answer the question below.',
+  '—— 背景开始 ——':
+    '--- background begins ---',
+  '—— 背景结束（以上无需回应） ——':
+    '--- background ends (nothing above needs a reply) ---',
+  '【下面这条才是对你的提问，请只回答它】':
+    '[The line below is the question put to you: answer only this]',
   'Matrix 长轮询尚未建立，请检查 homeserver 与凭据。':
     'The Matrix long poll has not been established. Check the homeserver URL and the credentials.',
   'Matrix 正在处理消息；当前存在未恢复的连接。':