@dsh-overdrive/gateway 0.1.0

package/test/adapters.whatsapp.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, it } from 'vitest';
+import {
+  buildNativeFlowButtons,
+  buildNumberedReply,
+  matchNumberedReply,
+  normalizeWhatsAppMessage,
+  parseNativeButtonResponse,
+  whatsappImageUrl,
+  type RawWhatsAppMessage,
+} from '../src/adapters/whatsapp.js';
+
+describe('normalizeWhatsAppMessage', () => {
+  it('文本消息 → NormalizedMessage（chatId=JID, userId=发送者）', () => {
+    const raw = {
+      key: { remoteJid: '60123@s.whatsapp.net', participant: undefined },
+      message: { conversation: 'hello' },
+      messageType: 'conversation',
+    };
+    const out = normalizeWhatsAppMessage(raw);
+    expect(out?.kind).toBe('message');
+    expect(out?.msg).toMatchObject({ chatId: '60123@s.whatsapp.net', userId: '60123@s.whatsapp.net', text: 'hello' });
+  });
+
+  it('群聊用 participant 作 userId', () => {
+    const raw = {
+      key: { remoteJid: 'group@g.us', participant: '60123@s.whatsapp.net' },
+      message: { extendedTextMessage: { text: 'hi' } },
+      messageType: 'extendedTextMessage',
+    };
+    const out = normalizeWhatsAppMessage(raw);
+    expect(out?.msg.userId).toBe('60123@s.whatsapp.net');
+    expect(out?.msg.chatId).toBe('group@g.us');
+  });
+
+  it('非文本消息返回 null', () => {
+    expect(normalizeWhatsAppMessage({ key: { remoteJid: 'x' }, message: { imageMessage: {} } })).toBeNull();
+    expect(normalizeWhatsAppMessage({ key: { remoteJid: 'x' }, message: {} })).toBeNull();
+  });
+});
+
+describe('whatsappImageUrl / 媒体消息捕获', () => {
+  it('imageMessage url + caption → media: { kind: "image", url }；无 url 退 directPath', () => {
+    const raw = {
+      key: { remoteJid: '60123@s.whatsapp.net' },
+      message: { imageMessage: { url: 'https://mmg.whatsapp.net/f/x.jpg', caption: '看图' } },
+      messageType: 'imageMessage',
+    };
+    expect(whatsappImageUrl(raw)).toBe('https://mmg.whatsapp.net/f/x.jpg');
+    expect(normalizeWhatsAppMessage(raw)).toMatchObject({
+      kind: 'message',
+      msg: {
+        chatId: '60123@s.whatsapp.net',
+        userId: '60123@s.whatsapp.net',
+        text: '看图',
+        media: { kind: 'image', url: 'https://mmg.whatsapp.net/f/x.jpg' },
+      },
+    });
+    // directPath 兜底（M4 简化：URL 直接透传，认证头后续再补）
+    expect(whatsappImageUrl({ message: { imageMessage: { directPath: '/d/p.jpg' } } })).toBe('/d/p.jpg');
+  });
+});
+
+describe('buildNumberedReply / matchNumberedReply（审批按钮的编号文本方案）', () => {
+  it('生成 1/2 编号选项', () => {
+    const text = buildNumberedReply('⚠️ 需要批准：删除文件', [
+      { id: 'approve:r1', label: '✅ 同意' },
+      { id: 'reject:r1', label: '🚫 拒绝' },
+    ]);
+    expect(text).toContain('1) ✅ 同意');
+    expect(text).toContain('2) 🚫 拒绝');
+  });
+
+  it('回复数字能匹配回按钮 id', () => {
+    const buttons = [
+      { id: 'approve:r1', label: '✅ 同意' },
+      { id: 'reject:r1', label: '🚫 拒绝' },
+    ];
+    expect(matchNumberedReply('1', buttons)?.id).toBe('approve:r1');
+    expect(matchNumberedReply('2', buttons)?.id).toBe('reject:r1');
+    expect(matchNumberedReply('9', buttons)).toBeUndefined();
+    expect(matchNumberedReply('同意', buttons)).toBeUndefined();
+  });
+});
+
+describe('buildNativeFlowButtons（WhatsApp 原生交互按钮）', () => {
+  it('按钮 → nativeFlowMessage buttons 数组', () => {
+    const buttons = buildNativeFlowButtons([
+      { id: 'approve:r1', label: '✅ 同意' },
+      { id: 'reject:r1', label: '🚫 拒绝' },
+    ]);
+    expect(buttons).toHaveLength(2);
+    expect(buttons[0]).toMatchObject({
+      name: 'quick_reply',
+      buttonParamsJson: JSON.stringify({ id: 'approve:r1', display_text: '✅ 同意' }),
+    });
+    expect(buttons[1]).toMatchObject({
+      name: 'quick_reply',
+      buttonParamsJson: JSON.stringify({ id: 'reject:r1', display_text: '🚫 拒绝' }),
+    });
+  });
+
+  it('空数组 → 空 buttons', () => {
+    expect(buildNativeFlowButtons([])).toEqual([]);
+  });
+});
+
+describe('parseNativeButtonResponse（交互按钮响应解析）', () => {
+  it('解析 paramsJson 中的 id', () => {
+    const raw: RawWhatsAppMessage = {
+      key: { remoteJid: '60123@s.whatsapp.net' },
+      message: {
+        interactiveResponseMessage: {
+          nativeFlowResponseMessage: { paramsJson: JSON.stringify({ id: 'approve:r1' }) },
+        },
+      },
+      messageType: 'interactiveResponseMessage',
+    };
+    expect(parseNativeButtonResponse(raw)).toBe('approve:r1');
+  });
+
+  it('无交互响应 / 非法 JSON / 缺 id 均返回 null', () => {
+    expect(parseNativeButtonResponse({ key: { remoteJid: 'x' }, message: { conversation: 'hi' } })).toBeNull();
+    expect(parseNativeButtonResponse({ key: { remoteJid: 'x' }, message: {} })).toBeNull();
+    expect(parseNativeButtonResponse({ key: { remoteJid: 'x' } })).toBeNull();
+    expect(
+      parseNativeButtonResponse({
+        key: { remoteJid: 'x' },
+        message: { interactiveResponseMessage: { nativeFlowResponseMessage: { paramsJson: 'not-json' } } },
+      }),
+    ).toBeNull();
+    expect(
+      parseNativeButtonResponse({
+        key: { remoteJid: 'x' },
+        message: { interactiveResponseMessage: { nativeFlowResponseMessage: { paramsJson: JSON.stringify({ foo: 'bar' }) } } },
+      }),
+    ).toBeNull();
+  });
+});

package/test/commands.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+import { parseCommand, type ParsedCommand } from '../src/commands.js';
+
+describe('parseCommand', () => {
+  it('识别 /trace、/task、/cron、/agents、/new、/help', () => {
+    expect(parseCommand('/trace')).toEqual({ kind: 'trace' });
+    expect(parseCommand('/new')).toEqual({ kind: 'new' });
+    expect(parseCommand('/agents')).toEqual({ kind: 'agents' });
+    expect(parseCommand('/help')).toEqual({ kind: 'help' });
+    expect(parseCommand('/task 调研竞品')).toEqual({ kind: 'task', prompt: '调研竞品' });
+    expect(parseCommand('/cron 0 8 * * * 每日汇报')).toEqual({ kind: 'cron', schedule: '0 8 * * *', prompt: '每日汇报' });
+  });
+  it('非命令返回 null', () => {
+    expect(parseCommand('hello')).toBeNull();
+    expect(parseCommand('/unknown')).toBeNull();
+    expect(parseCommand('/task')).toBeNull(); // 缺参数
+  });
+});

package/test/config.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { createAdapter, parseAdapterIds, type AdapterEnv } from '../src/config.js';
+
+describe('parseAdapterIds', () => {
+  it('逗号分隔 + 去空格 + 去空项', () => {
+    expect(parseAdapterIds('cli, whatsapp, telegram,')).toEqual(['cli', 'whatsapp', 'telegram']);
+  });
+  it('缺省为 cli', () => {
+    expect(parseAdapterIds('')).toEqual(['cli']);
+  });
+});
+
+describe('createAdapter 注册表', () => {
+  it('cli 恒可用', () => {
+    const a = createAdapter('cli', {});
+    expect(a.id).toBe('cli');
+  });
+  it('未知适配器抛错', () => {
+    expect(() => createAdapter('nope', {})).toThrow(/unknown adapter/);
+  });
+  it('feishu 缺凭据抛错', () => {
+    expect(() => createAdapter('feishu', {})).toThrow(/FEISHU_APP_ID/);
+  });
+  it('dingtalk 缺凭据抛错', () => {
+    expect(() => createAdapter('dingtalk', {})).toThrow(/DINGTALK_CLIENT_ID/);
+  });
+  it('wecom 缺凭据抛错', () => {
+    expect(() => createAdapter('wecom', {})).toThrow(/WECOM_CORP_ID/);
+  });
+});

package/test/multi.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it } from 'vitest';
+import { wireAdapter } from '../src/index.js';
+import { GatewayClient } from '@dsh-overdrive/sdk';
+import type { Adapter, NormalizedMessage, OutboundPayload } from '../src/adapter.js';
+
+/** 可编程 FakeAdapter：验证 wiring 逻辑（白名单/会话键/错误兜底）。 */
+class FakeAdapter implements Adapter {
+  readonly id: string;
+  readonly sent: Array<{ chatId: string; payload: OutboundPayload }> = [];
+  private messageCb?: (msg: NormalizedMessage) => Promise<void> | void;
+  private replyCb?: (buttonId: string) => Promise<void> | void;
+  constructor(id: string) { this.id = id; }
+  async connect(): Promise<void> {}
+  async send(chatId: string, payload: OutboundPayload): Promise<void> { this.sent.push({ chatId, payload }); }
+  onMessage(cb: (msg: NormalizedMessage) => void): void { this.messageCb = cb; }
+  onReply(cb: (buttonId: string) => void): void { this.replyCb = cb; }
+  /** 测试助手：返回处理器 Promise，测试 await 以确保 async 接线（upsert→sendMessage / catch 兜底）跑完 */
+  emit(msg: NormalizedMessage): Promise<void> | void { return this.messageCb?.(msg); }
+  click(buttonId: string): Promise<void> | void { return this.replyCb?.(buttonId); }
+}
+
+/** 假 DSH：记录调用。 */
+function fakeClient() {
+  const upserts: Array<{ platform: string; channel: string; user: string }> = [];
+  const messages: Array<{ sessionId: string; text: string }> = [];
+  const approvals: Array<{ reqId: string; decision: string }> = [];
+  const client = {
+    upsertSession: async (req: { platform: string; channel: string; user: string }) => {
+      upserts.push(req);
+      return { sessionId: `${req.platform}:${req.channel}:${req.user}` };
+    },
+    sendMessage: async (sessionId: string, req: { text: string }) => {
+      messages.push({ sessionId, text: req.text });
+      return { runId: 'r1' };
+    },
+    resolveApproval: async (reqId: string, decision: 'approve' | 'reject') => {
+      approvals.push({ reqId, decision });
+      return { ok: true };
+    },
+    // wireAdapter 末尾会订阅事件流（client.connect），假客户端需实现完整接口
+    connect: async () => () => undefined,
+  } as unknown as GatewayClient;
+  return { client, upserts, messages, approvals };
+}
+
+describe('wireAdapter（多适配器装配核心）', () => {
+  it('白名单拦截并回错误文本', async () => {
+    const adapter = new FakeAdapter('telegram');
+    const { client } = fakeClient();
+    await wireAdapter(adapter, client, { allowlist: ['telegram:111:222'] });
+
+    await adapter.emit({ chatId: '999', userId: '999', text: 'hi' });
+    expect(adapter.sent[0].payload.text).toContain('⛔');
+  });
+
+  it('白名单内消息 → upsert + sendMessage', async () => {
+    const adapter = new FakeAdapter('telegram');
+    const { client, upserts, messages } = fakeClient();
+    await wireAdapter(adapter, client, { allowlist: ['telegram:111:222'] });
+
+    await adapter.emit({ chatId: '111', userId: '222', text: 'hello' });
+    expect(upserts).toEqual([{ platform: 'telegram', channel: '111', user: '222' }]);
+    expect(messages).toEqual([{ sessionId: 'telegram:111:222', text: 'hello' }]);
+  });
+
+  it('按钮点击 → resolveApproval', async () => {
+    const adapter = new FakeAdapter('discord');
+    const { client, approvals } = fakeClient();
+    await wireAdapter(adapter, client, { allowlist: [] });
+
+    await adapter.click('approve:r1');
+    expect(approvals).toEqual([{ reqId: 'r1', decision: 'approve' }]);
+  });
+
+  it('DSH 调用失败 → 回错误文本（不崩溃）', async () => {
+    const adapter = new FakeAdapter('slack');
+    const client = {
+      upsertSession: async () => { throw new Error('dsh down'); },
+      connect: async () => () => undefined,
+    } as unknown as GatewayClient;
+    await wireAdapter(adapter, client, { allowlist: [] });
+
+    await adapter.emit({ chatId: 'C1', userId: 'U1', text: 'hi' });
+    expect(adapter.sent[0].payload.text).toContain('❌');
+  });
+});

package/test/outbound.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import { planOutbound } from '../src/index.js';
+import type { ServerEvent } from '@dsh-overdrive/sdk';
+
+describe('planOutbound（事件 → 平台输出）', () => {
+  it('message.complete → 纯文本', () => {
+    const ev: ServerEvent = { type: 'message.complete', sessionId: 'cli:cli:local', ts: 1, text: '结果' };
+    expect(planOutbound(ev)?.payload).toEqual({ text: '结果' });
+  });
+
+  it('trajectory.step → 带图标的轨迹行', () => {
+    const ev: ServerEvent = { type: 'trajectory.step', sessionId: 'cli:cli:local', ts: 1, step: { kind: 'tool', label: 'grep' } };
+    expect(planOutbound(ev)?.payload.text).toBe('🛠️ grep');
+  });
+
+  it('approval.request → 文本 + 同意/拒绝两个按钮', () => {
+    const ev: ServerEvent = { type: 'approval.request', sessionId: 'cli:cli:local', ts: 1, reqId: 'r1', summary: '删除文件', timeoutMs: 60000 };
+    const out = planOutbound(ev)!;
+    expect(out.payload.text).toContain('删除文件');
+    expect(out.payload.buttons).toHaveLength(2);
+    expect(out.payload.buttons![0].id).toBe('approve:r1');
+    expect(out.payload.buttons![1].id).toBe('reject:r1');
+  });
+
+  it('message.delta 不输出（MVP 等 complete）', () => {
+    const ev: ServerEvent = { type: 'message.delta', sessionId: 'cli:cli:local', ts: 1, text: '…' };
+    expect(planOutbound(ev)).toBeNull();
+  });
+});

package/test/session.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest';
+import { Allowlist, buildSessionKey } from '../src/session.js';
+
+describe('buildSessionKey', () => {
+  it('用 adapterId + chatId + userId 拼会话键', () => {
+    expect(buildSessionKey('whatsapp', { chatId: '60123', userId: '60123' })).toBe('whatsapp:60123:60123');
+  });
+});
+
+describe('Allowlist', () => {
+  it('空列表放行所有（开发模式）', () => {
+    const allow = new Allowlist([]);
+    expect(allow.allows('anything:any:any')).toBe(true);
+  });
+
+  it('非空列表只放行白名单条目', () => {
+    const allow = new Allowlist(['whatsapp:60123:60123']);
+    expect(allow.allows('whatsapp:60123:60123')).toBe(true);
+    expect(allow.allows('whatsapp:99999:99999')).toBe(false);
+  });
+});

package/test/status.test.ts

@@ -0,0 +1,41 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { createStatusServer } from '../src/status.js';
+import type { Adapter } from '../src/adapter.js';
+import { GatewayClient } from '@dsh-overdrive/sdk';
+
+describe('createStatusServer', () => {
+  let server: ReturnType<typeof createStatusServer> | undefined;
+  let port = 0;
+  afterEach(async () => { await server?.close(); server = undefined; });
+
+  async function start(fakeAdapters: Adapter[]): Promise<string> {
+    const client = {
+      health: async () => ({ status: 'ok' as const, version: '0.1.0' }),
+    } as unknown as GatewayClient;
+    server = createStatusServer({ adapters: fakeAdapters, client, version: '0.1.0' });
+    port = await server.listen(0);
+    return `http://127.0.0.1:${port}`;
+  }
+
+  it('/api/status 返回 dsh 健康与适配器状态', async () => {
+    const url = await start([
+      { id: 'telegram', status: () => ({ connected: true }) },
+      { id: 'whatsapp', status: () => ({ connected: false }) },
+    ] as unknown as Adapter[]);
+    const res = await fetch(`${url}/api/status`);
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.dsh.status).toBe('ok');
+    expect(body.adapters).toEqual([
+      { id: 'telegram', connected: true },
+      { id: 'whatsapp', connected: false },
+    ]);
+  });
+
+  it('GET / 返回 HTML 控制台页', async () => {
+    const url = await start([]);
+    const res = await fetch(`${url}/`);
+    expect(res.status).toBe(200);
+    expect((await res.text())).toContain('dsh-overdrive');
+  });
+});

package/test/streaming.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, it } from 'vitest';
+import { DeltaTracker, planOutbound, wireAdapter } from '../src/index.js';
+import { HELP_TEXT } from '../src/commands.js';
+import { GatewayClient, type ServerEvent } from '@dsh-overdrive/sdk';
+import type { Adapter, NormalizedMessage, OutboundPayload } from '../src/adapter.js';
+
+describe('DeltaTracker（message.delta → 打字指示，complete → 终稿）', () => {
+  it('首个 delta 触发 typing，重复 delta 不重复触发', () => {
+    const t = new DeltaTracker();
+    const typings: string[] = [];
+    const outputs: string[] = [];
+    t.onDelta('s1', () => typings.push('s1'));
+    t.onDelta('s1', () => typings.push('s1'));
+    expect(typings).toEqual(['s1']);
+    void outputs;
+  });
+
+  it('complete 后同会话下一个 turn 的 delta 可再次触发 typing', () => {
+    const t = new DeltaTracker();
+    const typings: string[] = [];
+    t.onDelta('s1', () => typings.push('s1'));
+    t.onComplete('s1');
+    t.onDelta('s1', () => typings.push('s1'));
+    expect(typings).toEqual(['s1', 's1']);
+  });
+});
+
+describe('planOutbound（trajectory.summary 摘要卡片渲染）', () => {
+  it('trajectory.summary → formatTrajectorySummary 文本', () => {
+    const ev: ServerEvent = {
+      type: 'trajectory.summary', sessionId: 'cli:cli:local', ts: 1,
+      steps: [{ kind: 'thought', label: '分析' }, { kind: 'tool', label: 'bash' }],
+    };
+    const out = planOutbound(ev)!;
+    expect(out.payload.text).toContain('📋 轨迹（2 步）');
+    expect(out.payload.text).toContain('🧠 分析');
+    expect(out.payload.text).toContain('🛠️ bash');
+  });
+});
+
+/** 可编程 FakeAdapter（带 sendTyping 探测）。 */
+class FakeAdapter implements Adapter {
+  readonly id: string;
+  readonly sent: Array<{ chatId: string; payload: OutboundPayload }> = [];
+  readonly typings: string[] = [];
+  private messageCb?: (msg: NormalizedMessage) => Promise<void> | void;
+  private replyCb?: (buttonId: string) => Promise<void> | void;
+  constructor(id: string) { this.id = id; }
+  async connect(): Promise<void> {}
+  async send(chatId: string, payload: OutboundPayload): Promise<void> { this.sent.push({ chatId, payload }); }
+  async sendTyping(chatId: string): Promise<void> { this.typings.push(chatId); }
+  onMessage(cb: (msg: NormalizedMessage) => void): void { this.messageCb = cb; }
+  onReply(cb: (buttonId: string) => void): void { this.replyCb = cb; }
+  emit(msg: NormalizedMessage): Promise<void> | void { return this.messageCb?.(msg); }
+}
+
+/** 假 DSH 客户端：可编程事件推流 + 记录调用。 */
+function fakeClient() {
+  const createTasks: Array<{ sessionId: string; kind: string; prompt: string; schedule?: string }> = [];
+  const resets: string[] = [];
+  let eventCb: ((ev: ServerEvent) => void) | undefined;
+  const client = {
+    upsertSession: async (req: { platform: string; channel: string; user: string }) =>
+      ({ sessionId: `${req.platform}:${req.channel}:${req.user}` }),
+    sendMessage: async () => ({ runId: 'r1' }),
+    resolveApproval: async () => ({ ok: true }),
+    createTask: async (req: { sessionId: string; kind: 'subagent' | 'cron'; prompt: string; schedule?: string }) => {
+      createTasks.push(req);
+      return { taskId: 't1' };
+    },
+    resetSession: async (sessionId: string) => { resets.push(sessionId); return { ok: true }; },
+    connect: async (cb: (ev: ServerEvent) => void) => { eventCb = cb; return () => undefined; },
+  };
+  const push = (ev: ServerEvent): void => eventCb?.(ev);
+  return { client, createTasks, resets, push } as unknown as {
+    client: GatewayClient; createTasks: typeof createTasks; resets: string[];
+    push: (ev: ServerEvent) => void;
+  };
+}
+
+describe('wireAdapter（命令分发 + delta 打字指示 + 轨迹聚合接线）', () => {
+  it('message.delta → sendTyping 一次；complete 后下一 turn 再触发', async () => {
+    const adapter = new FakeAdapter('cli');
+    const { client, push } = fakeClient();
+    await wireAdapter(adapter, client, { allowlist: [] });
+
+    push({ type: 'message.delta', sessionId: 'cli:cli:local', ts: 1, text: '…' });
+    push({ type: 'message.delta', sessionId: 'cli:cli:local', ts: 2, text: '…' });
+    expect(adapter.typings).toEqual(['cli']); // sendTyping 目标是 chatId（无消息时回退到 channel）
+    expect(adapter.sent).toHaveLength(0); // delta 不产出文本
+
+    push({ type: 'message.complete', sessionId: 'cli:cli:local', ts: 3, text: '结果' });
+    push({ type: 'message.delta', sessionId: 'cli:cli:local', ts: 4, text: '…' });
+    expect(adapter.typings).toEqual(['cli', 'cli']);
+  });
+
+  it('trajectory.step 不实时输出，idle 时以 trajectory.summary 摘要输出', async () => {
+    const adapter = new FakeAdapter('cli');
+    const { client, push } = fakeClient();
+    await wireAdapter(adapter, client, { allowlist: [] });
+
+    push({ type: 'agent.status', sessionId: 'cli:cli:local', ts: 1, status: 'busy' });
+    push({ type: 'trajectory.step', sessionId: 'cli:cli:local', ts: 2, step: { kind: 'thought', label: '分析' } });
+    push({ type: 'trajectory.step', sessionId: 'cli:cli:local', ts: 3, step: { kind: 'tool', label: 'bash' } });
+    expect(adapter.sent).toHaveLength(0); // 单步不推
+
+    push({ type: 'agent.status', sessionId: 'cli:cli:local', ts: 4, status: 'idle' });
+    const summary = adapter.sent.find((s) => s.payload.text.includes('📋 轨迹'));
+    expect(summary?.payload.text).toContain('🧠 分析');
+    expect(summary?.payload.text).toContain('🛠️ bash');
+  });
+
+  it('/help → HELP_TEXT 原样输出', async () => {
+    const adapter = new FakeAdapter('cli');
+    const { client } = fakeClient();
+    await wireAdapter(adapter, client, { allowlist: [] });
+    await adapter.emit({ chatId: 'cli', userId: 'local', text: '/help' });
+    expect(adapter.sent[0].payload.text).toBe(HELP_TEXT);
+  });
+
+  it('/task 派子任务并回执；/cron 注册定时任务并回执', async () => {
+    const adapter = new FakeAdapter('cli');
+    const { client, createTasks } = fakeClient();
+    await wireAdapter(adapter, client, { allowlist: [] });
+
+    await adapter.emit({ chatId: 'cli', userId: 'local', text: '/task 调研竞品' });
+    expect(createTasks).toContainEqual({ sessionId: 'cli:cli:local', kind: 'subagent', prompt: '调研竞品' });
+    expect(adapter.sent.at(-1)!.payload.text).toContain('🤖 子任务已派出');
+
+    await adapter.emit({ chatId: 'cli', userId: 'local', text: '/cron 0 8 * * * 每日汇报' });
+    expect(createTasks).toContainEqual({ sessionId: 'cli:cli:local', kind: 'cron', prompt: '每日汇报', schedule: '0 8 * * *' });
+    expect(adapter.sent.at(-1)!.payload.text).toContain('⏰ 定时任务已注册');
+  });
+
+  it('/new 走 resetSession 端点并回执；/trace 显示最近摘要，无则提示', async () => {
+    const adapter = new FakeAdapter('cli');
+    const { client, resets, push } = fakeClient();
+    await wireAdapter(adapter, client, { allowlist: [] });
+
+    await adapter.emit({ chatId: 'cli', userId: 'local', text: '/trace' });
+    expect(adapter.sent.at(-1)!.payload.text).toContain('暂无轨迹');
+
+    push({ type: 'agent.status', sessionId: 'cli:cli:local', ts: 1, status: 'busy' });
+    push({ type: 'trajectory.step', sessionId: 'cli:cli:local', ts: 2, step: { kind: 'thought', label: '分析' } });
+    push({ type: 'agent.status', sessionId: 'cli:cli:local', ts: 3, status: 'idle' });
+
+    await adapter.emit({ chatId: 'cli', userId: 'local', text: '/trace' });
+    expect(adapter.sent.at(-1)!.payload.text).toContain('🧠 分析');
+
+    await adapter.emit({ chatId: 'cli', userId: 'local', text: '/new' });
+    expect(resets).toEqual(['cli:cli:local']);
+    expect(adapter.sent.at(-1)!.payload.text).toContain('🆕 会话已重置');
+  });
+
+  it('/agents 返回简化回执', async () => {
+    const adapter = new FakeAdapter('cli');
+    const { client } = fakeClient();
+    await wireAdapter(adapter, client, { allowlist: [] });
+    await adapter.emit({ chatId: 'cli', userId: 'local', text: '/agents' });
+    expect(adapter.sent[0].payload.text).toContain('/task 派发');
+  });
+});

package/test/trajectory.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest';
+import { TrajectoryAggregator, formatTrajectorySummary } from '../src/trajectory.js';
+import type { ServerEvent, TrajectoryStep } from '@dsh-overdrive/sdk';
+
+// 注意：ServerEvent 联合类型尚无 trajectory.summary（Task 2 协议修改才加入），
+// 故本文件对 summary 事件统一用结构断言 + as 断言，不修改 sdk 协议。
+describe('TrajectoryAggregator', () => {
+  it('聚合 turn 内轨迹，turn 结束产出摘要', () => {
+    const agg = new TrajectoryAggregator();
+    const events: ServerEvent[] = [];
+    agg.onEvent({ type: 'agent.status', sessionId: 'cli:cli:local', ts: 1, status: 'busy' }, (ev) => events.push(ev));
+    agg.onEvent({ type: 'trajectory.step', sessionId: 'cli:cli:local', ts: 2, step: { kind: 'thought', label: '分析' } }, (ev) => events.push(ev));
+    agg.onEvent({ type: 'trajectory.step', sessionId: 'cli:cli:local', ts: 3, step: { kind: 'tool', label: 'bash' } }, (ev) => events.push(ev));
+    agg.onEvent({ type: 'agent.status', sessionId: 'cli:cli:local', ts: 4, status: 'idle' }, (ev) => events.push(ev));
+
+    const summary = events.find((e) => (e as { type: string }).type === 'trajectory.summary') as
+      | { type: 'trajectory.summary'; steps: TrajectoryStep[] }
+      | undefined;
+    expect(summary).toBeDefined();
+    // 直接比较结构（Task 2 的协议变体含 steps，渲染由 formatTrajectorySummary 负责）
+    expect(summary!.steps).toEqual([
+      { kind: 'thought', label: '分析' },
+      { kind: 'tool', label: 'bash' },
+    ]);
+  });
+
+  it('busy 状态在摘要前透传，idle 后清空缓冲', () => {
+    const agg = new TrajectoryAggregator();
+    const events: ServerEvent[] = [];
+    agg.onEvent({ type: 'agent.status', sessionId: 'cli:cli:local', ts: 1, status: 'busy' }, (ev) => events.push(ev));
+    expect(events).toHaveLength(1);
+    expect(events[0].type).toBe('agent.status');
+
+    agg.onEvent({ type: 'agent.status', sessionId: 'cli:cli:local', ts: 2, status: 'idle' }, (ev) => events.push(ev));
+    expect(events).toHaveLength(2);
+  });
+
+  it('其他事件（message.complete 等）原样透传', () => {
+    const agg = new TrajectoryAggregator();
+    const events: ServerEvent[] = [];
+    agg.onEvent({ type: 'message.complete', sessionId: 's', ts: 1, text: '结果' }, (ev) => events.push(ev));
+    expect(events).toEqual([{ type: 'message.complete', sessionId: 's', ts: 1, text: '结果' }]);
+  });
+});
+
+describe('formatTrajectorySummary（摘要卡片渲染，Task 2 接线复用）', () => {
+  it('按 kind 渲染图标 + 标签，含步数标题', () => {
+    const text = formatTrajectorySummary([
+      { kind: 'thought', label: '分析' },
+      { kind: 'tool', label: 'bash' },
+      { kind: 'subagent', label: '子任务' },
+    ]);
+    expect(text).toContain('🧠 分析');
+    expect(text).toContain('🛠️ bash');
+    expect(text).toContain('🤖 子任务');
+    expect(text).toContain('📋 轨迹（3 步）');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": { "outDir": "dist", "rootDir": "src" },
+  "include": ["src"]
+}