@dsh-overdrive/gateway 0.1.9 → 0.3.0

package/src/index.ts

@@ -1,5 +1,6 @@
-import { existsSync } from 'node:fs';
-import { basename } from 'node:path';
+import { existsSync, writeFileSync, rmSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { tmpdir } from 'node:os';
 import { GatewayClient, type ServerEvent } from '@dsh-overdrive/sdk';
 import type { Adapter, OutboundPayload } from './adapter.js';
 import { Allowlist, buildSessionKey } from './session.js';
@@ -9,7 +10,10 @@ import { parseCommand, HELP_TEXT, type ParsedCommand } from './commands.js';
 import { TrajectoryAggregator, formatTrajectorySummary } from './trajectory.js';
 import { createStatusServer } from './status.js';
 import { createTranscriber, type AsrTranscriber } from './asr.js';
-import { MemoryStore, memoryScope, formatMemories, extractAutoMemories } from './memory.js';
+import { MemoryStore, TopicStore, memoryScope, formatMemories, extractAutoMemories } from './memory.js';
+import { FeedStore, FeedPoller } from './feed.js';
+import { shouldRespond } from './mention.js';
+import { chunkLongText } from './text.js';
 
 /**
  * message.delta → 打字指示去重：同一 turn 内首个 delta 触发一次 typing，
@@ -76,6 +80,14 @@ export interface WireOptions {
   memory?: MemoryStore;
   /** 人设（persona）：每条用户消息前注入的固定上下文，如「你是一个毒舌但贴心的私人助理」。 */
   persona?: string;
+  /** RSS 订阅存储（/feed 命令）。 */
+  feed?: FeedStore;
+  /** 群聊提及策略：true 时群聊中仅在被提及/回复时响应（私聊始终响应）。 */
+  requireMention?: boolean;
+  /** 机器人身份（telegram @用户名 / discord·slack 用户ID / whatsapp 号码）。 */
+  botIdentity?: string;
+  /** 会话主题存储（/context）。 */
+  topics?: TopicStore;
 }
 
 /** 纯函数：一次性提醒的时间 → cron 5 字段表达式（分钟精度）。 */
@@ -108,6 +120,8 @@ async function handleCommand(
   chatId: string,
   aggregator: TrajectoryAggregator,
   memory: MemoryStore | undefined,
+  feed: FeedStore | undefined,
+  topics: TopicStore | undefined,
 ): Promise<void> {
   switch (command.kind) {
     case 'trace': {
@@ -126,8 +140,24 @@ async function handleCommand(
       return;
     }
     case 'cron': {
-      await client.createTask({ sessionId, kind: 'cron', prompt: command.prompt, schedule: command.schedule });
-      await adapter.send(chatId, { text: '⏰ 定时任务已注册' });
+      await client.createTask({ sessionId, kind: 'cron', prompt: command.prompt, schedule: command.schedule, timeZone: command.timeZone });
+      await adapter.send(chatId, { text: `⏰ 定时任务已注册${command.timeZone ? `（时区 ${command.timeZone}）` : ''}` });
+      return;
+    }
+    case 'context': {
+      if (!topics) { await adapter.send(chatId, { text: '会话主题未启用。' }); return; }
+      if (command.action === 'set' && command.topic) {
+        topics.set(sessionId, command.topic);
+        await adapter.send(chatId, { text: `📌 会话主题已绑定：${command.topic}` });
+        return;
+      }
+      if (command.action === 'clear') {
+        const ok = topics.clear(sessionId);
+        await adapter.send(chatId, { text: ok ? '📌 会话主题已清除' : '当前没有会话主题。' });
+        return;
+      }
+      const current = topics.get(sessionId);
+      await adapter.send(chatId, { text: current ? `📌 当前会话主题：${current}` : '当前没有会话主题。用 /context <主题> 绑定。' });
       return;
     }
     case 'crons': {
@@ -214,6 +244,48 @@ async function handleCommand(
       });
       return;
     }
+    case 'digest': {
+      const scope = memoryScope(adapter.id, sessionId.split(':')[2] ?? '');
+      const mems = memory ? memory.list(scope) : [];
+      const crons = await client.listTasks();
+      await adapter.send(chatId, {
+        text: [
+          `📋 今日摘要`,
+          `- 你的记忆: ${mems.length} 条${mems.slice(0, 5).map((e) => `\n  · ${e.text}`).join('')}`,
+          `- 定时任务: ${crons.tasks.length} 个`,
+          `- 订阅源: ${feed ? feed.list().filter((f) => f.chatId === chatId).length : 0} 个`,
+        ].join('\n'),
+      });
+      return;
+    }
+    case 'digestdaily': {
+      const schedule = remindSchedule(0, command.time);
+      await client.createTask({ sessionId, kind: 'cron', prompt: '⏰ 每日摘要：请基于今天的对话输出一份简短摘要。', schedule });
+      await adapter.send(chatId, { text: `📋 已设置每日摘要（${command.time} 触发）` });
+      return;
+    }
+    case 'feedadd': {
+      if (!feed) { await adapter.send(chatId, { text: 'RSS 订阅未启用。' }); return; }
+      const entry = feed.add(adapter.id, chatId, command.url);
+      await adapter.send(chatId, { text: `✅ 已订阅 RSS（\`${entry.id}\`）：${command.url}` });
+      return;
+    }
+    case 'feedlist': {
+      if (!feed) { await adapter.send(chatId, { text: 'RSS 订阅未启用。' }); return; }
+      const mine = feed.list().filter((f) => f.chatId === chatId);
+      await adapter.send(chatId, {
+        text: mine.length
+          ? `📡 订阅（${mine.length}）:\n` + mine.map((f) => `- \`${f.id}\` ${f.url}`).join('\n')
+          : '暂无订阅。用 /feed add <rss链接> 添加。',
+      });
+      return;
+    }
+    case 'feedrm': {
+      if (!feed) { await adapter.send(chatId, { text: 'RSS 订阅未启用。' }); return; }
+      const ok = feed.remove(command.feedId);
+      await adapter.send(chatId, { text: ok ? `🗑️ 已删除订阅 \`${command.feedId}\`` : `未找到订阅 \`${command.feedId}\`` });
+      return;
+    }
     case 'help': {
       await adapter.send(chatId, { text: HELP_TEXT });
       return;
@@ -242,13 +314,27 @@ export async function wireAdapter(
       }
       chatIds.set(key, msg.chatId);
 
+      // 群聊提及策略（对齐竞品）：群聊中仅被提及/回复时响应；私聊始终响应
+      if (opts.requireMention && !shouldRespond(adapter.id, msg, { requireMention: true, botIdentity: opts.botIdentity ?? '' })) {
+        console.log(`[gateway][${adapter.id}] 群聊未提及，跳过: chat=${msg.chatId}`);
+        return;
+      }
+
       const command = parseCommand(msg.text);
       if (command) {
         console.log(`[gateway][${adapter.id}] 命令: ${JSON.stringify(command)}`);
-        await handleCommand(adapter, client, command, key, msg.chatId, aggregator, opts.memory);
+        await handleCommand(adapter, client, command, key, msg.chatId, aggregator, opts.memory, opts.feed, opts.topics);
         return;
       }
 
+      // 会话主题注入（/context）
+      if (opts.topics) {
+        const topic = opts.topics.get(key);
+        if (topic) {
+          msg.text = `【会话主题】${topic}\n${msg.text}`;
+        }
+      }
+
       // OpenClaw 式记忆注入：入站消息前检索相关记忆，拼到文本后让 agent「记得你」
       if (opts.memory) {
         const scope = memoryScope(adapter.id, msg.userId);
@@ -328,16 +414,42 @@ export async function wireAdapter(
       deltas.onComplete(ev.sessionId);
     }
 
+    // 自动发送：agent 产出的文件（file.created，base64）→ 写临时文件 → 发到聊天 → 清理
+    if (ev.type === 'file.created') {
+      const chatId = chatIdFor(ev.sessionId);
+      const tmp = join(tmpdir(), `dsh-out-${Date.now()}-${Math.random().toString(36).slice(2, 6)}-${ev.name}`);
+      try {
+        writeFileSync(tmp, Buffer.from(ev.data, 'base64'));
+      } catch (error) {
+        console.error(`[gateway][${adapter.id}] 写入自动发送临时文件失败: ${error instanceof Error ? error.message : String(error)}`);
+        return;
+      }
+      void adapter.send(chatId, { text: `📎 ${ev.name}`, media: { kind: ev.kind, path: tmp, caption: ev.name } })
+        .then(
+          () => console.log(`[gateway][${adapter.id}] 已自动发送 ${ev.name} 到 ${chatId}`),
+          (error) => console.error(`[gateway][${adapter.id}] 自动发送失败 ${ev.name}: ${error instanceof Error ? error.message : String(error)}`),
+        )
+        .finally(() => rmSync(tmp, { force: true }));
+      return;
+    }
+
     // 轨迹聚合：trajectory.step 攒批，idle 时产出 trajectory.summary（减少刷屏）
     aggregator.onEvent(ev, (out) => {
       const planned = planOutbound(out);
       if (!planned) return;
       const chatId = chatIdFor(out.sessionId);
-      console.log(`[gateway][${adapter.id}] 事件 ${out.type} -> 发送到 ${chatId}`);
-      void adapter.send(chatId, planned.payload).then(
-        () => console.log(`[gateway][${adapter.id}] 已发送 ${out.type} 到 ${chatId}`),
-        (error) => console.error(`[gateway][${adapter.id}] 发送失败 ${out.type}: ${error instanceof Error ? error.message : String(error)}`),
-      );
+      // 长回复智能分片（对齐竞品）：>1500 字按换行/句号断行，带（i/n）序号
+      const chunks = chunkLongText(planned.payload.text);
+      chunks.forEach((chunk, i) => {
+        const payload = i === 0
+          ? planned.payload
+          : { text: chunk };
+        console.log(`[gateway][${adapter.id}] 事件 ${out.type} -> 发送到 ${chatId}${chunks.length > 1 ? `（${i + 1}/${chunks.length}）` : ''}`);
+        void adapter.send(chatId, payload).then(
+          () => console.log(`[gateway][${adapter.id}] 已发送 ${out.type} 到 ${chatId}`),
+          (error) => console.error(`[gateway][${adapter.id}] 发送失败 ${out.type}: ${error instanceof Error ? error.message : String(error)}`),
+        );
+      });
     });
   });
 }
@@ -358,16 +470,29 @@ async function main(): Promise<void> {
   if (asr.enabled) console.log('[gateway] ASR 语音转写已启用');
   const memory = new MemoryStore(process.env.MEMORY_FILE ?? 'data/memory.json');
   console.log(`[gateway] 记忆系统已启用（文件: ${process.env.MEMORY_FILE ?? 'data/memory.json'}）`);
+  const feedStore = new FeedStore(process.env.FEED_FILE ?? 'data/feeds.json');
+  const topics = new TopicStore(process.env.TOPIC_FILE ?? 'data/topics.json');
+  const requireMention = process.env.GROUP_MENTION === '1';
+  if (requireMention) console.log('[gateway] 群聊提及模式已启用（群聊仅在被提及/回复时响应）');
 
   const client = new GatewayClient(dshBaseUrl, dshToken);
   await client.health(); // 确认 DSH 侧（或 mock）活着
 
   const adapters: Adapter[] = adapterIds.map((id) => createAdapter(id, env));
+  const adaptersMap = new Map(adapters.map((a) => [a.id, a]));
+  const feedPoller = new FeedPoller(feedStore, adaptersMap);
+  feedPoller.start();
+  console.log('[gateway] RSS 订阅轮询已启动');
   for (const adapter of adapters) {
     await adapter.connect();
     // 人设：PERSONA_<ADAPTER_ID>（如 PERSONA_TELEGRAM）优先，回退 PERSONA
     const persona = process.env[`PERSONA_${adapter.id.toUpperCase()}`] ?? process.env.PERSONA;
-    await wireAdapter(adapter, client, { allowlist, allowAll, asr, memory, persona });
+    // 机器人身份：BOT_IDENTITY_<ADAPTER_ID> 优先，回退 BOT_IDENTITY
+    const botIdentity = process.env[`BOT_IDENTITY_${adapter.id.toUpperCase()}`] ?? process.env.BOT_IDENTITY ?? '';
+    await wireAdapter(adapter, client, {
+      allowlist, allowAll, asr, memory, persona, feed: feedStore, topics,
+      requireMention, botIdentity,
+    });
     console.log(`[gateway] ${adapter.id} 适配器已就绪${persona ? `（人设: ${persona.slice(0, 20)}…）` : ''}`);
   }
 

package/src/memory.ts

@@ -131,3 +131,46 @@ export class MemoryStore {
     return this.list(scope).length;
   }
 }
+
+/** 会话主题存储（/context）：sessionKey → 主题，JSON 持久化；file 缺省仅内存。 */
+export class TopicStore {
+  private readonly map = new Map<string, string>();
+  private readonly file?: string;
+
+  constructor(file?: string) {
+    this.file = file;
+    if (file && existsSync(file)) {
+      try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8')) as Record<string, string>;
+        for (const [k, v] of Object.entries(parsed)) if (typeof v === 'string') this.map.set(k, v);
+      } catch {
+        /* 损坏则从空开始 */
+      }
+    }
+  }
+
+  private persist(): void {
+    if (!this.file) return;
+    try {
+      mkdirSync(dirname(this.file), { recursive: true });
+      writeFileSync(this.file, JSON.stringify(Object.fromEntries(this.map), null, 2), 'utf8');
+    } catch {
+      /* 持久化失败不阻断 */
+    }
+  }
+
+  set(sessionKey: string, topic: string): void {
+    this.map.set(sessionKey, topic);
+    this.persist();
+  }
+
+  get(sessionKey: string): string | undefined {
+    return this.map.get(sessionKey);
+  }
+
+  clear(sessionKey: string): boolean {
+    const removed = this.map.delete(sessionKey);
+    if (removed) this.persist();
+    return removed;
+  }
+}

package/src/mention.ts

@@ -0,0 +1,51 @@
+// 群聊响应策略（对齐竞品 dsh-im 的「私聊直接响应、群聊被提及/回复才响应」）。
+// 纯函数，平台判定基于渠道 ID 特征与提及模式；无法判定的平台默认始终响应。
+
+import type { NormalizedMessage } from './adapter.js';
+
+/** 纯函数：该渠道 ID 是否为群聊/频道（vs 私聊）。平台特征： */
+export function isGroupChat(adapterId: string, chatId: string): boolean {
+  switch (adapterId) {
+    case 'telegram':
+      // 群/超级群为负 ID（-100 前缀的超群，- 前缀的普通群）
+      return chatId.startsWith('-');
+    case 'whatsapp':
+      return chatId.endsWith('@g.us');
+    case 'slack':
+      // Slack 私聊 DM 以 D 开头，公共频道/群以 C/G 开头
+      return !chatId.startsWith('D');
+    default:
+      // discord / feishu / dingtalk / wecom / wechat / cli：无法从 ID 可靠区分 → 视为私聊（始终响应）
+      return false;
+  }
+}
+
+/** 纯函数：消息文本是否提及了机器人（@<identity> 或 <@identity> 平台格式）。 */
+export function isMentioned(adapterId: string, text: string, botIdentity: string): boolean {
+  if (!botIdentity) return false;
+  switch (adapterId) {
+    case 'telegram':
+      return text.includes(`@${botIdentity}`);
+    case 'whatsapp':
+      return text.includes(`@${botIdentity}`);
+    case 'discord':
+    case 'slack':
+      return text.includes(`<@${botIdentity}>`);
+    default:
+      return true; // 无法检测提及的平台 → 视为已提及（始终响应）
+  }
+}
+
+export interface MentionPolicy {
+  /** 群聊中要求被提及/回复才响应；私聊始终响应。 */
+  requireMention: boolean;
+  /** 机器人身份（telegram @用户名 / discord·slack 用户ID / whatsapp 号码）。 */
+  botIdentity: string;
+}
+
+/** 纯函数：是否应响应该消息。 */
+export function shouldRespond(adapterId: string, msg: NormalizedMessage, policy: MentionPolicy): boolean {
+  if (!policy.requireMention) return true;
+  if (!isGroupChat(adapterId, msg.chatId)) return true; // 私聊始终响应
+  return isMentioned(adapterId, msg.text, policy.botIdentity);
+}

package/src/pending-buttons.ts

@@ -23,7 +23,11 @@ export class PendingButtons {
     this.map.set(chatId, { buttons, expiresAt: Date.now() + this.ttlMs });
   }
 
-  /** 数字回复命中：返回匹配按钮并消费（删除）；无 pending / 已过期 / 非数字或越界返回 undefined。 */
+  /**
+   * 回复解析（对齐竞品的文字审批）：数字编号（"1"/"2"…）或关键词
+   * （批准/同意/yes/ok/确认 → approve 按钮；拒绝/不同意/no/取消 → reject 按钮）。
+   * 命中即消费；无 pending / 已过期 / 不匹配返回 undefined。
+   */
   match(chatId: string, text: string): OutboundButton | undefined {
     const entry = this.map.get(chatId);
     if (!entry) return undefined;
@@ -31,11 +35,27 @@ export class PendingButtons {
       this.map.delete(chatId);
       return undefined;
     }
-    const n = Number(text.trim());
-    if (!Number.isInteger(n) || n < 1 || n > entry.buttons.length) return undefined;
-    const button = entry.buttons[n - 1];
-    if (button) this.map.delete(chatId);
-    return button;
+    const trimmed = text.trim().toLowerCase();
+    // 数字回复
+    const n = Number(trimmed);
+    if (Number.isInteger(n) && n >= 1 && n <= entry.buttons.length) {
+      const button = entry.buttons[n - 1];
+      if (button) this.map.delete(chatId);
+      return button;
+    }
+    // 文字审批关键词（竞品 dsh-im 同款：回复「批准/拒绝」即可）
+    const approveWords = ['批准', '同意', 'yes', 'ok', '确认', 'approve'];
+    const rejectWords = ['拒绝', '不同意', 'no', '取消', 'reject'];
+    const wantsApprove = approveWords.some((w) => trimmed === w || trimmed.startsWith(`${w} `));
+    const wantsReject = rejectWords.some((w) => trimmed === w || trimmed.startsWith(`${w} `));
+    if (wantsApprove || wantsReject) {
+      const button = entry.buttons.find((b) =>
+        wantsApprove ? b.id.startsWith('approve:') : b.id.startsWith('reject:'),
+      );
+      if (button) this.map.delete(chatId);
+      return button;
+    }
+    return undefined;
   }
 
   /** 消费原生按钮点击（如 WhatsApp 原生交互按钮）：删除该 chat 的 pending。 */

package/src/text.ts

@@ -0,0 +1,32 @@
+// 长文本工具：按渠道可读性分片（对齐竞品的长回复分段能力）。
+
+const DEFAULT_CHUNK_LIMIT = 1500;
+
+/** 纯函数：长文本按 limit 分片，优先在换行/句号/问号/感叹号处断行；超过 1 段时带（i/n）序号。 */
+export function chunkLongText(text: string, limit = DEFAULT_CHUNK_LIMIT): string[] {
+  if (!text) return [text];
+  if (text.length <= limit) return [text];
+
+  const raw: string[] = [];
+  let rest = text;
+  while (rest.length > limit) {
+    const slice = rest.slice(0, limit);
+    const breakAt = Math.max(
+      slice.lastIndexOf('\n'),
+      slice.lastIndexOf('。'),
+      slice.lastIndexOf('！'),
+      slice.lastIndexOf('？'),
+      slice.lastIndexOf('.'),
+      slice.lastIndexOf('!'),
+      slice.lastIndexOf('?'),
+      slice.lastIndexOf('；'),
+    );
+    const cut = breakAt >= limit * 0.6 ? breakAt + 1 : limit;
+    raw.push(rest.slice(0, cut));
+    rest = rest.slice(cut);
+  }
+  if (rest) raw.push(rest);
+
+  if (raw.length <= 1) return raw;
+  return raw.map((chunk, i) => `${chunk}\n（${i + 1}/${raw.length}）`);
+}

package/test/commands.test.ts

@@ -40,4 +40,14 @@ describe('parseCommand', () => {
     expect(parseCommand('/status')).toEqual({ kind: 'status' });
     expect(parseCommand('/send')).toBeNull(); // 缺路径
   });
+  it('识别 /cron --tz 时区', () => {
+    expect(parseCommand('/cron 0 8 * * * 每日汇报 --tz Asia/Shanghai'))
+      .toEqual({ kind: 'cron', schedule: '0 8 * * *', prompt: '每日汇报', timeZone: 'Asia/Shanghai' });
+    expect(parseCommand('/cron 0 8 * * * 每日汇报')).toEqual({ kind: 'cron', schedule: '0 8 * * *', prompt: '每日汇报', timeZone: undefined });
+  });
+  it('识别 /context', () => {
+    expect(parseCommand('/context 项目重构')).toEqual({ kind: 'context', action: 'set', topic: '项目重构' });
+    expect(parseCommand('/context off')).toEqual({ kind: 'context', action: 'clear' });
+    expect(parseCommand('/context')).toEqual({ kind: 'context', action: 'show' });
+  });
 });

package/test/feed.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, it, vi } from 'vitest';
+import { FeedPoller, FeedStore, formatFeedItem, parseRss } from '../src/feed.js';
+import type { Adapter } from '../src/adapter.js';
+
+const SAMPLE_RSS = `<?xml version="1.0"?>
+<rss version="2.0"><channel>
+  <title>Example Feed</title>
+  <item>
+    <title>First post</title>
+    <link>https://x.com/1</link>
+    <guid>g-1</guid>
+    <pubDate>Mon, 18 Aug 2026 10:00:00 GMT</pubDate>
+  </item>
+  <item>
+    <title>Second &amp; great post</title>
+    <link>https://x.com/2</link>
+    <guid>g-2</guid>
+  </item>
+</channel></rss>`;
+
+describe('parseRss', () => {
+  it('解析条目与实体解码', () => {
+    const items = parseRss(SAMPLE_RSS);
+    expect(items).toHaveLength(2);
+    expect(items[0]).toMatchObject({ title: 'First post', link: 'https://x.com/1', guid: 'g-1', pubDate: 'Mon, 18 Aug 2026 10:00:00 GMT' });
+    expect(items[1].title).toBe('Second & great post');
+  });
+  it('空/非法 XML 返回空', () => {
+    expect(parseRss('')).toEqual([]);
+    expect(parseRss('<rss></rss>')).toEqual([]);
+  });
+  it('CDATA 内容解码', () => {
+    const xml = '<rss><channel><item><title><![CDATA[Hello <World>]]></title><guid>g</guid></item></channel></rss>';
+    expect(parseRss(xml)[0].title).toBe('Hello <World>');
+  });
+});
+
+describe('formatFeedItem', () => {
+  it('带链接时输出 标题+链接', () => {
+    expect(formatFeedItem({ title: 'A', link: 'https://a', guid: 'g' })).toContain('📰 A');
+    expect(formatFeedItem({ title: 'A', link: 'https://a', guid: 'g' })).toContain('https://a');
+  });
+});
+
+describe('FeedStore（内存模式）', () => {
+  it('add / list / remove / updateLastGuid', () => {
+    const store = new FeedStore();
+    const feed = store.add('telegram', 'c1', 'https://feed.example/rss');
+    expect(store.list()).toHaveLength(1);
+    expect(feed.lastGuid).toBe('');
+    store.updateLastGuid(feed.id, 'g-2');
+    expect(store.list()[0].lastGuid).toBe('g-2');
+    expect(store.remove(feed.id)).toBe(true);
+    expect(store.list()).toHaveLength(0);
+    expect(store.remove(feed.id)).toBe(false);
+  });
+});
+
+describe('FeedPoller.pollOnce', () => {
+  const fakeAdapter = { id: 'telegram', send: vi.fn(async () => {}) } as unknown as Adapter;
+
+  it('首次订阅只建立游标不推送', async () => {
+    const store = new FeedStore();
+    const feed = store.add('telegram', 'c1', 'https://feed.example/rss');
+    const poller = new FeedPoller(store, new Map([['telegram', fakeAdapter]]), {
+      fetchImpl: vi.fn(async () => ({ ok: true, text: async () => SAMPLE_RSS }) as Response),
+    });
+    const pushed = await poller.pollOnce();
+    expect(pushed).toBe(0);
+    expect(store.list()[0].lastGuid).toBe('g-1');
+    expect(fakeAdapter.send).not.toHaveBeenCalled();
+    void feed;
+  });
+
+  it('游标之后的新条目按序推送', async () => {
+    const store = new FeedStore();
+    const feed = store.add('telegram', 'c1', 'https://feed.example/rss');
+    // 首次订阅：游标建立在最新一条 g-1 上
+    const poller1 = new FeedPoller(store, new Map([['telegram', fakeAdapter]]), {
+      fetchImpl: vi.fn(async () => ({ ok: true, text: async () => SAMPLE_RSS }) as Response),
+    });
+    await poller1.pollOnce();
+    expect(store.list()[0].lastGuid).toBe('g-1');
+    fakeAdapter.send.mockClear();
+    // 第二轮出现新条目 g-0（文档序最新在前）→ 只推 g-0
+    const NEW_RSS = `<rss version="2.0"><channel><item><title>Brand new</title><link>https://x.com/0</link><guid>g-0</guid></item>${SAMPLE_RSS.slice(SAMPLE_RSS.indexOf('<item>'))}`;
+    const poller2 = new FeedPoller(store, new Map([['telegram', fakeAdapter]]), {
+      fetchImpl: vi.fn(async () => ({ ok: true, text: async () => NEW_RSS }) as Response),
+    });
+    const pushed = await poller2.pollOnce();
+    expect(pushed).toBe(1);
+    expect(fakeAdapter.send).toHaveBeenCalledWith('c1', expect.objectContaining({ text: expect.stringContaining('Brand new') }));
+    expect(store.list()[0].lastGuid).toBe('g-0');
+  });
+
+  it('抓取失败不影响其他源', async () => {
+    const store = new FeedStore();
+    store.add('telegram', 'c1', 'https://bad.example');
+    store.add('telegram', 'c1', 'https://good.example');
+    const calls: string[] = [];
+    const poller = new FeedPoller(store, new Map([['telegram', fakeAdapter]]), {
+      fetchImpl: vi.fn(async (url: string) => {
+        calls.push(url);
+        if (url.includes('bad')) return { ok: false, status: 500 } as Response;
+        return { ok: true, text: async () => SAMPLE_RSS } as Response;
+      }),
+    });
+    await poller.pollOnce();
+    expect(calls).toHaveLength(2);
+  });
+});

package/test/mention.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+import { isGroupChat, isMentioned, shouldRespond } from '../src/mention.js';
+
+describe('isGroupChat', () => {
+  it('telegram 负 ID 为群', () => {
+    expect(isGroupChat('telegram', '-1001234567890')).toBe(true);
+    expect(isGroupChat('telegram', '-12345')).toBe(true);
+    expect(isGroupChat('telegram', '12345')).toBe(false);
+  });
+  it('whatsapp @g.us 为群', () => {
+    expect(isGroupChat('whatsapp', '123@ g.us'.replace(' ', ''))).toBe(true);
+    expect(isGroupChat('whatsapp', '123@s.whatsapp.net')).toBe(false);
+  });
+  it('slack D 开头为私聊', () => {
+    expect(isGroupChat('slack', 'D123')).toBe(false);
+    expect(isGroupChat('slack', 'C123')).toBe(true);
+  });
+  it('无法判定的平台默认视为私聊', () => {
+    expect(isGroupChat('discord', 'any')).toBe(false);
+    expect(isGroupChat('feishu', 'oc_1')).toBe(false);
+  });
+});
+
+describe('isMentioned', () => {
+  it('telegram/whatsapp @身份', () => {
+    expect(isMentioned('telegram', '@mybot 你好', 'mybot')).toBe(true);
+    expect(isMentioned('telegram', '你好', 'mybot')).toBe(false);
+    expect(isMentioned('whatsapp', '@8613800000000 hi', '8613800000000')).toBe(true);
+  });
+  it('discord/slack <@ID>', () => {
+    expect(isMentioned('discord', '<@123456> hello', '123456')).toBe(true);
+    expect(isMentioned('slack', 'hello <@U123>', 'U123')).toBe(true);
+    expect(isMentioned('discord', 'hello', '123456')).toBe(false);
+  });
+  it('无法检测的平台视为已提及', () => {
+    expect(isMentioned('feishu', '随便', 'x')).toBe(true);
+  });
+});
+
+describe('shouldRespond', () => {
+  const msg = (text: string) => ({ chatId: '-100123', userId: 'u', text });
+  it('未开启提及模式 → 始终响应', () => {
+    expect(shouldRespond('telegram', msg('随便'), { requireMention: false, botIdentity: 'b' })).toBe(true);
+  });
+  it('群聊未提及 → 不响应；提及 → 响应', () => {
+    const policy = { requireMention: true, botIdentity: 'mybot' };
+    expect(shouldRespond('telegram', msg('你好'), policy)).toBe(false);
+    expect(shouldRespond('telegram', msg('@mybot 你好'), policy)).toBe(true);
+  });
+  it('私聊始终响应', () => {
+    const policy = { requireMention: true, botIdentity: 'mybot' };
+    expect(shouldRespond('telegram', { chatId: '12345', userId: 'u', text: '你好' }, policy)).toBe(true);
+  });
+});

package/test/multi.test.ts

@@ -1,10 +1,10 @@
 import { describe, expect, it } from 'vitest';
 import { mediaKindFromPath, remindSchedule, wireAdapter } from '../src/index.js';
-import { GatewayClient } from '@dsh-overdrive/sdk';
-import { MemoryStore } from '../src/memory.js';
+import { GatewayClient, type ServerEvent } from '@dsh-overdrive/sdk';
+import { MemoryStore, TopicStore } from '../src/memory.js';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { rmSync, writeFileSync } from 'node:fs';
+import { existsSync, rmSync, writeFileSync } from 'node:fs';
 import type { Adapter, NormalizedMessage, OutboundPayload, ReplySender } from '../src/adapter.js';
 
 /** 可编程 FakeAdapter：验证 wiring 逻辑（白名单/会话键/错误兜底）。 */
@@ -166,6 +166,52 @@ describe('wireAdapter（多适配器装配核心）', () => {
     expect(messages[0].text).toBe('【人设】你是一个毒舌助理\n你好');
   });
 
+  it('file.created 事件：agent 产出的文件自动发回聊天并清理临时文件', async () => {
+    const adapter = new FakeAdapter('telegram');
+    let onEvent: ((ev: ServerEvent) => void) | undefined;
+    const client = {
+      upsertSession: async () => ({ sessionId: 'telegram:111:222' }),
+      connect: async (cb: (ev: ServerEvent) => void) => { onEvent = cb; return () => {}; },
+    } as unknown as GatewayClient;
+    await wireAdapter(adapter, client, { allowlist: ['telegram:111:222'] });
+
+    const bytes = Buffer.from('fake-image-bytes');
+    onEvent!({
+      type: 'file.created', sessionId: 'telegram:111:222', ts: Date.now(),
+      name: 'chart.png', kind: 'image', data: bytes.toString('base64'),
+    });
+    await new Promise((r) => setTimeout(r, 100));
+    expect(adapter.sent[0].payload.text).toContain('chart.png');
+    expect(adapter.sent[0].payload.media).toMatchObject({ kind: 'image', caption: 'chart.png' });
+    expect(existsSync(adapter.sent[0].payload.media!.path)).toBe(false); // 临时文件已清理
+  });
+
+  it('群聊提及模式：群聊未提及不响应，提及才响应', async () => {
+    const adapter = new FakeAdapter('telegram');
+    const { client, messages } = fakeClient();
+    await wireAdapter(adapter, client, { allowlist: ['telegram:-100123:222'], requireMention: true, botIdentity: 'mybot' });
+
+    await adapter.emit({ chatId: '-100123', userId: '222', text: '你好' }); // 群聊（负 ID）未提及
+    expect(messages).toHaveLength(0);
+    await adapter.emit({ chatId: '-100123', userId: '222', text: '@mybot 你好' }); // 提及
+    expect(messages).toHaveLength(1);
+  });
+
+  it('/context 设置/清除会话主题并注入到消息', async () => {
+    const adapter = new FakeAdapter('telegram');
+    const { client, messages } = fakeClient();
+    const topics = new TopicStore();
+    await wireAdapter(adapter, client, { allowlist: ['telegram:111:222'], topics });
+
+    await adapter.emit({ chatId: '111', userId: '222', text: '/context 项目重构' });
+    expect(adapter.sent[0].payload.text).toContain('已绑定');
+    await adapter.emit({ chatId: '111', userId: '222', text: '帮我写周报' });
+    expect(messages[0].text).toBe('【会话主题】项目重构\n帮我写周报');
+    await adapter.emit({ chatId: '111', userId: '222', text: '/context off' });
+    await adapter.emit({ chatId: '111', userId: '222', text: '你好' });
+    expect(messages[1].text).toBe('你好');
+  });
+
   it('/send <path> 读取文件并以媒体载荷发送', async () => {
     const adapter = new FakeAdapter('telegram');
     const { client } = fakeClient();