agentworkshop 0.2.1

package/scripts/test-full-system.ts

@@ -0,0 +1,439 @@
+/**
+ * 系统全面验证测试 — 验证所有子系统协同
+ *
+ * 测试矩阵:
+ *  A. 任务队列顺序执行(mock):给同一 worker 连续下发 3 个任务,验证 FIFO 顺序执行
+ *  B. 实时通讯(immediate):worker 忙碌时注入 steer 消息
+ *  C. lead dispatch + worker 执行(mock):验证 lead 分发 → worker 接取 → 完成 → lead 汇总
+ *  D. worker ↔ worker 通信(mock):worker-A 给 worker-B 发消息,B 入队后消费
+ *  E. goal 模式(omp):lead 判断目标完成
+ *  F. loop 模式(mock):循环重放
+ *  G. pipeline 模式(mock):流水线阶段
+ *
+ * 运行: npx tsx scripts/test-full-system.ts
+ */
+import { openWorkshopDb } from '../server/services/workshop/db/database'
+import { createChannelRepo } from '../server/services/workshop/db/channel.repo'
+import { createAgentRepo } from '../server/services/workshop/db/agent.repo'
+import { createChannelAgentRepo } from '../server/services/workshop/db/channel-agent.repo'
+import { createTaskRepo } from '../server/services/workshop/db/task.repo'
+import { createMemoryRepo } from '../server/services/workshop/db/memory.repo'
+import { createChannelEventRepo } from '../server/services/workshop/db/channel-event.repo'
+import { createTeamRepo } from '../server/services/workshop/db/team.repo'
+import { createTeamMemberRepo } from '../server/services/workshop/db/team-member.repo'
+import { createMessageRepo } from '../server/services/workshop/db/message.repo'
+import { createSubscriptionRepo } from '../server/services/workshop/db/subscription.repo'
+import { createAgentChannelManager } from '../server/services/workshop/runtime/manager'
+import type { AgentChannelManager } from '../server/services/workshop/runtime/manager'
+import { createAgentImpl } from '../server/services/workshop/agents/factory'
+import type { WorkspaceTask } from '../server/services/workshop/types/task'
+
+let failures = 0
+let testCount = 0
+function check(name: string, ok: boolean, detail = ''): void {
+  testCount += 1
+  console.log(`  ${ok ? '✅' : '❌'} ${name}${detail ? ` — ${detail}` : ''}`)
+  if (!ok) failures += 1
+}
+
+const sleep = (ms: number) => new Promise<void>(r => setTimeout(r, ms))
+
+async function waitUntil(cond: () => boolean | Promise<boolean>, timeoutMs: number): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    if (await cond()) return true
+    await sleep(50)
+  }
+  return false
+}
+
+interface SetupResult {
+  manager: AgentChannelManager
+  db: ReturnType<typeof openWorkshopDb>
+  repos: {
+    messages: ReturnType<typeof createMessageRepo>
+  }
+}
+
+function setup(): SetupResult {
+  const db = openWorkshopDb(':memory:')
+  const repos = {
+    channels: createChannelRepo(db),
+    agents: createAgentRepo(db),
+    channelAgents: createChannelAgentRepo(db),
+    messages: createMessageRepo(db),
+    subscriptions: createSubscriptionRepo(db),
+    tasks: createTaskRepo(db),
+    memories: createMemoryRepo(db),
+
+    channelEvents: createChannelEventRepo(db),
+
+    teams: createTeamRepo(db),
+
+    teamMembers: createTeamMemberRepo(db),
+  }
+  const manager = createAgentChannelManager({ repos, implFactory: createAgentImpl, db })
+  return { manager, db, repos: { messages: repos.messages } }
+}
+
+function getEngine(manager: AgentChannelManager) {
+  return (manager as unknown as {
+    getTaskEngine(): {
+      get(id: string): WorkspaceTask | undefined
+      list(channelId: string): WorkspaceTask[]
+    }
+  }).getTaskEngine()
+}
+
+function attachScheduler(manager: AgentChannelManager, channelId: string, tickMs = 200, stallMs = 60_000): void {
+  // 懒加载设计:scheduler 由 manager 内部装配与管理
+  manager.ensureChannelActive(channelId, { tickMs, stallMs })
+}
+
+async function cleanup(manager: AgentChannelManager, db: ReturnType<typeof openWorkshopDb>): Promise<void> {
+  await manager.shutdown()
+  db.close()
+}
+
+// ===== 测试 A: 任务队列顺序执行 =====
+async function testTaskQueueOrder(): Promise<void> {
+  console.log('\n━━━ 测试 A: 任务队列 FIFO 顺序执行(mock)━━━')
+
+  const { manager, db } = setup()
+
+  try {
+    const ch = await manager.createChannel({
+      name: '队列测试',
+      leadAgent: { name: 'lead', harness: 'mock', config: { delayMs: 100 } },
+    })
+    const workerTpl = await manager.createAgent({ name: 'worker', harness: 'mock', config: { delayMs: 100 } })
+    const worker = await manager.addAgentToChannel({ channelId: ch.channelId, agentId: workerTpl.id, role: 'worker' })
+    attachScheduler(manager, ch.channelId)
+
+    const engine = getEngine(manager)
+
+    // 连续提交 3 个任务
+    const t1 = await manager.submitChannelTask({ channelId: ch.channelId, title: '任务1' })
+    const t2 = await manager.submitChannelTask({ channelId: ch.channelId, title: '任务2' })
+    const t3 = await manager.submitChannelTask({ channelId: ch.channelId, title: '任务3' })
+
+    // 等待全部完成
+    await waitUntil(() => {
+      return engine.get(t1.id)?.state === 'COMPLETED'
+        && engine.get(t2.id)?.state === 'COMPLETED'
+        && engine.get(t3.id)?.state === 'COMPLETED'
+    }, 15_000)
+
+    // 验证全部 COMPLETED
+    check('任务1 COMPLETED', engine.get(t1.id)?.state === 'COMPLETED')
+    check('任务2 COMPLETED', engine.get(t2.id)?.state === 'COMPLETED')
+    check('任务3 COMPLETED', engine.get(t3.id)?.state === 'COMPLETED')
+
+    // 验证 FIFO: 任务1 的 updatedAt <= 任务2 的 updatedAt <= 任务3 的 updatedAt
+    const r1 = engine.get(t1.id)
+    const r2 = engine.get(t2.id)
+    const r3 = engine.get(t3.id)
+    const order = r1!.updatedAt <= r2!.updatedAt && r2!.updatedAt <= r3!.updatedAt
+    check('FIFO 顺序执行(任务1先完成)', order, `${r1!.updatedAt.slice(11, 19)} ≤ ${r2!.updatedAt.slice(11, 19)} ≤ ${r3!.updatedAt.slice(11, 19)}`)
+
+    // 验证每个任务有 artifact
+    check('每个任务有 artifact', (r1!.artifacts.length > 0) && (r2!.artifacts.length > 0) && (r3!.artifacts.length > 0))
+
+    void worker
+  }
+  finally {
+    await cleanup(manager, db)
+  }
+}
+
+// ===== 测试 B: 实时通讯 immediate =====
+async function testImmediateMessage(): Promise<void> {
+  console.log('\n━━━ 测试 B: 实时通讯(immediate priority)━━━')
+
+  const { manager, db, repos } = setup()
+
+  try {
+    const ch = await manager.createChannel({
+      name: '实时通讯测试',
+      leadAgent: { name: 'lead', harness: 'mock', config: { delayMs: 200 } },
+    })
+    const w1Tpl = await manager.createAgent({ name: 'w1', harness: 'mock', config: { delayMs: 200 } })
+    const w1 = await manager.addAgentToChannel({ channelId: ch.channelId, agentId: w1Tpl.id, role: 'worker' })
+    const w2Tpl = await manager.createAgent({ name: 'w2', harness: 'mock', config: { delayMs: 200 } })
+    const w2 = await manager.addAgentToChannel({ channelId: ch.channelId, agentId: w2Tpl.id, role: 'worker' })
+    attachScheduler(manager, ch.channelId)
+
+    // 提交任务让 w1 忙碌
+    const task = await manager.submitChannelTask({ channelId: ch.channelId, title: 'busy task' })
+
+    // 等 w1 开始工作(busy)
+    await waitUntil(() => {
+      const cr = (manager as unknown as { channels: Map<string, { getAgents(): Array<{ getState: () => string, agentId: string }> }> }).channels.get(ch.channelId)!
+      const w1rt = cr.getAgents().find(a => a.agentId === w1.id)
+      return w1rt?.getState() === 'busy'
+    }, 5_000)
+
+    // w1 busy 时发送 immediate 消息
+    const msg = await manager.sendImmediateMessage({
+      channelId: ch.channelId,
+      fromAgentId: w2.id,
+      toAgentId: w1.id,
+      parts: [{ text: '紧急消息!' }],
+    })
+    check('immediate 消息发送成功', !!msg)
+
+    // 验证消息有 immediate priority metadata
+    check('消息 priority=immediate', msg.metadata?.['x-aw-msg-priority'] === 'immediate')
+
+    // 等 w1 完成任务
+    const engine = getEngine(manager)
+    await waitUntil(() => engine.get(task.id)?.state === 'COMPLETED', 5_000)
+
+    // 发送 task priority 消息给 idle 的 w1
+    const msg2 = await manager.sendA2A(ch.channelId, w2.id, {
+      toAgentId: w1.id,
+      parts: [{ text: '普通消息' }],
+      metadata: { 'x-aw-msg-priority': 'task' },
+    })
+    check('task 消息发送成功', !!msg2)
+
+    // 消息自动被 consumeLoop 消费;验证 DB 中有消息记录(consumed 状态)
+    const recentMsgs = repos.messages.listRecentByChannel(ch.channelId, 10)
+    const w1Msgs = recentMsgs.filter(m => m.toAgentId === w1.id)
+    check('w1 收到了消息(DB 记录)', w1Msgs.length >= 1, `消息数=${w1Msgs.length}`)
+    check('消息被自动消费(consumed)', w1Msgs.some(m => m.state === 'consumed'), `states=[${w1Msgs.map(m => m.state).join(',')}]`)
+  }
+  finally {
+    await cleanup(manager, db)
+  }
+}
+
+// ===== 测试 C: lead dispatch + worker 执行 + 汇总 =====
+async function testLeadDispatchCycle(): Promise<void> {
+  console.log('\n━━━ 测试 C: lead dispatch → worker 执行 → lead 汇总(mock)━━━')
+
+  const { manager, db } = setup()
+
+  try {
+    const ch = await manager.createChannel({
+      name: 'dispatch 测试',
+      leadAgent: { name: 'lead', harness: 'mock', config: { delayMs: 50 } },
+    })
+    await manager.addAgentToChannel({ channelId: ch.channelId, agentId: (await manager.createAgent({ name: 'w1', harness: 'mock', config: { delayMs: 50 } })).id, role: 'worker' })
+    await manager.addAgentToChannel({ channelId: ch.channelId, agentId: (await manager.createAgent({ name: 'w2', harness: 'mock', config: { delayMs: 50 } })).id, role: 'worker' })
+    attachScheduler(manager, ch.channelId)
+
+    const engine = getEngine(manager)
+    const main = await manager.submitChannelTask({ channelId: ch.channelId, title: '主任务' })
+
+    await waitUntil(() => engine.get(main.id)?.state === 'COMPLETED', 10_000)
+
+    const allTasks = engine.list(ch.channelId)
+    const children = allTasks.filter(t => t.parentId === main.id)
+
+    check('主任务 COMPLETED', engine.get(main.id)?.state === 'COMPLETED')
+    check('lead dispatch 了子任务', children.length >= 1, `子任务数=${children.length}`)
+    check('子任务全部 COMPLETED', children.every(c => c.state === 'COMPLETED'), `${children.filter(c => c.state === 'COMPLETED').length}/${children.length}`)
+    check('主任务有汇总 artifact', (engine.get(main.id)?.artifacts.length ?? 0) > 0)
+  }
+  finally {
+    await cleanup(manager, db)
+  }
+}
+
+// ===== 测试 D: worker ↔ worker 通信 =====
+async function testWorkerToWorkerComm(): Promise<void> {
+  console.log('\n━━━ 测试 D: worker ↔ worker 通信(mock)━━━')
+
+  const { manager, db, repos } = setup()
+
+  try {
+    const ch = await manager.createChannel({
+      name: '通信测试',
+      leadAgent: { name: 'lead', harness: 'mock', config: { delayMs: 50 } },
+    })
+    const w1 = await manager.addAgentToChannel({ channelId: ch.channelId, agentId: (await manager.createAgent({ name: 'w1', harness: 'mock', config: { delayMs: 50 } })).id, role: 'worker' })
+    const w2 = await manager.addAgentToChannel({ channelId: ch.channelId, agentId: (await manager.createAgent({ name: 'w2', harness: 'mock', config: { delayMs: 50 } })).id, role: 'worker' })
+
+    // w1 → w2 发消息(task priority → 入队)
+    const msg = await manager.sendA2A(ch.channelId, w1.id, {
+      toAgentId: w2.id,
+      parts: [{ text: 'hello from w1' }],
+    })
+    check('w1 → w2 消息发送', !!msg)
+    check('消息有 target metadata', msg.metadata?.['x-aw-target-agent'] === w2.id)
+    check('消息有 from metadata', msg.metadata?.['x-aw-from-agent'] === w1.id)
+
+    // 等 consumeLoop 处理(mock worker 消费消息很快)
+    await sleep(200)
+
+    // 验证 DB 中有 w2 的消息记录(已被消费)
+    const recentMsgs = repos.messages.listRecentByChannel(ch.channelId, 20)
+    const w2Msgs = recentMsgs.filter(m => m.toAgentId === w2.id)
+    check('w2 收到了 w1 的消息(DB 记录)', w2Msgs.length >= 1, `消息数=${w2Msgs.length}`)
+
+    // w1 没收到自己的消息(点对点不广播)
+    const w1SelfMsgs = recentMsgs.filter(m => m.toAgentId === w1.id && m.fromAgentId === w1.id)
+    check('w1 没收到自己的消息(点对点)', w1SelfMsgs.length === 0)
+
+    // lead → w1 发消息
+    const leadInfo = (await manager.listChannelAgents(ch.channelId)).find(a => a.role === 'lead')!
+    await manager.sendA2A(ch.channelId, leadInfo.id, {
+      toAgentId: w1.id,
+      parts: [{ text: 'lead to w1' }],
+    })
+    await sleep(200)
+    const recentAfter = repos.messages.listRecentByChannel(ch.channelId, 20)
+    const leadToW1 = recentAfter.filter(m => m.toAgentId === w1.id && m.fromAgentId === leadInfo.id)
+    check('lead → w1 消息到达(DB 记录)', leadToW1.length >= 1, `消息数=${leadToW1.length}`)
+  }
+  finally {
+    await cleanup(manager, db)
+  }
+}
+
+// ===== 测试 E: goal 模式(mock 快速验证调度逻辑) =====
+async function testGoalMode(): Promise<void> {
+  console.log('\n━━━ 测试 E: goal 模式(mock)━━━')
+
+  const { manager, db } = setup()
+
+  try {
+    const ch = await manager.createChannel({
+      name: 'goal 测试',
+      leadAgent: { name: 'lead', harness: 'mock', config: { delayMs: 30 } },
+    })
+    await manager.addAgentToChannel({ channelId: ch.channelId, agentId: (await manager.createAgent({ name: 'w1', harness: 'mock', config: { delayMs: 30 } })).id, role: 'worker' })
+    attachScheduler(manager, ch.channelId)
+
+    const engine = getEngine(manager)
+    const task = await manager.submitChannelTask({
+      channelId: ch.channelId,
+      title: 'goal 任务',
+      description: '需要完成的目标',
+      mode: 'goal',
+      modeConfig: { goalCriteria: '任务完成' },
+    })
+
+    await waitUntil(() => {
+      const t = engine.get(task.id)
+      return t?.state === 'COMPLETED' || t?.state === 'CANCELED'
+    }, 10_000)
+
+    check('goal 任务 COMPLETED', engine.get(task.id)?.state === 'COMPLETED')
+
+    // 验证 description 编码了模式
+    const final = engine.get(task.id)
+    check('goal description 有 [mode:goal] 前缀', final?.description?.includes('[mode:goal]') ?? false, final?.description?.slice(0, 40))
+  }
+  finally {
+    await cleanup(manager, db)
+  }
+}
+
+// ===== 测试 F: loop 模式 =====
+async function testLoopMode(): Promise<void> {
+  console.log('\n━━━ 测试 F: loop 模式(mock)━━━')
+
+  const { manager, db } = setup()
+
+  try {
+    const ch = await manager.createChannel({
+      name: 'loop 测试',
+      leadAgent: { name: 'lead', harness: 'mock', config: { delayMs: 20 } },
+    })
+    await manager.addAgentToChannel({ channelId: ch.channelId, agentId: (await manager.createAgent({ name: 'w1', harness: 'mock', config: { delayMs: 20 } })).id, role: 'worker' })
+    attachScheduler(manager, ch.channelId, 100)
+
+    const engine = getEngine(manager)
+    const task = await manager.submitChannelTask({
+      channelId: ch.channelId,
+      title: '循环任务',
+      description: 'loop test',
+      mode: 'loop',
+      modeConfig: { intervalMs: 1000, maxIterations: 2 },
+    })
+
+    // 等第一次完成
+    await waitUntil(() => engine.get(task.id)?.state === 'COMPLETED', 10_000)
+    check('loop 第一次执行完成', engine.get(task.id)?.state === 'COMPLETED')
+
+    // 等循环重放
+    await sleep(2500)
+    const allTasks = engine.list(ch.channelId).filter(t => t.title === '循环任务')
+    check('loop 循环重放生成新任务', allTasks.length >= 2, `任务数=${allTasks.length}`)
+  }
+  finally {
+    await cleanup(manager, db)
+  }
+}
+
+// ===== 测试 G: pipeline 模式 =====
+async function testPipelineMode(): Promise<void> {
+  console.log('\n━━━ 测试 G: pipeline 模式(mock)━━━')
+
+  const { manager, db } = setup()
+
+  try {
+    const ch = await manager.createChannel({
+      name: 'pipeline 测试',
+      leadAgent: { name: 'lead', harness: 'mock', config: { delayMs: 30 } },
+    })
+    await manager.addAgentToChannel({ channelId: ch.channelId, agentId: (await manager.createAgent({ name: 'w1', harness: 'mock', config: { delayMs: 30 } })).id, role: 'worker' })
+    attachScheduler(manager, ch.channelId)
+
+    const engine = getEngine(manager)
+    const task = await manager.submitChannelTask({
+      channelId: ch.channelId,
+      title: '流水线任务',
+      description: 'pipeline test',
+      mode: 'pipeline',
+      modeConfig: {
+        stages: [
+          { name: '阶段1', description: '第一步' },
+          { name: '阶段2', description: '第二步' },
+        ],
+      },
+    })
+
+    await waitUntil(() => {
+      const t = engine.get(task.id)
+      return t?.state === 'COMPLETED' || t?.state === 'CANCELED'
+    }, 10_000)
+
+    const allTasks = engine.list(ch.channelId)
+    const children = allTasks.filter(t => t.parentId === task.id)
+
+    check('pipeline 主任务完成', ['COMPLETED', 'CANCELED'].includes(engine.get(task.id)?.state ?? ''), `state=${engine.get(task.id)?.state}`)
+    check('pipeline 生成了子任务', children.length >= 1, `子任务数=${children.length}`)
+    check('pipeline description 有 [mode:pipeline]', engine.get(task.id)?.description?.includes('[mode:pipeline]') ?? false)
+  }
+  finally {
+    await cleanup(manager, db)
+  }
+}
+
+// ===== main =====
+async function main(): Promise<void> {
+  console.log('╔════════════════════════════════════════════════════════════╗')
+  console.log('║  系统全面验证测试 — 所有子系统                              ║')
+  console.log('╚════════════════════════════════════════════════════════════╝')
+
+  await testTaskQueueOrder()
+  await testImmediateMessage()
+  await testLeadDispatchCycle()
+  await testWorkerToWorkerComm()
+  await testGoalMode()
+  await testLoopMode()
+  await testPipelineMode()
+
+  console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')
+  console.log(`  ${failures === 0 ? `🎉 全部通过(${testCount} 项检查)` : `❌ ${failures}/${testCount} 项失败`}`)
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')
+  process.exit(failures === 0 ? 0 : 1)
+}
+
+main().catch((e) => {
+  console.error('测试异常:', e)
+  process.exit(1)
+})

package/scripts/test-game-session.ts

@@ -0,0 +1,160 @@
+/**
+ * GameSession 会话级集成测试 — 模拟 Agent 全链路(无浏览器,node + tsx 直跑)
+ *
+ * 直接构造 GameSession + 假 WS peer,驱动上行消息,断言下行指令序列:
+ *  1. 同步 brain(ScriptBrain):connect → session.ready/agent.state;玩家贴脸 →
+ *     dialog.open;3 次 interact → advance×2 + close + 大脑收到事件转入 wait
+ *  2. 异步 brain(MockSdkBrain, 零延迟):决议经 Promise 到达,agent.move 照常下发
+ *  3. 大脑主动 dialog.close 动作 → 下行 dialog.close
+ *  4. stop() 停止主循环,不再产出新指令
+ */
+import { AGENT_SPAWN, type AgentAction, type AgentBrain, type AgentContext, type ServerToClient } from '../server/types/game'
+import { MockSdkBrain, ScriptBrain } from '../server/services/game/agent'
+import { GameSession } from '../server/services/game/session'
+
+let failures = 0
+function check(name: string, ok: boolean, detail = ''): void {
+  console.log(`${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` — ${detail}` : ''}`)
+  if (!ok) {
+    failures += 1
+  }
+}
+
+/** 假 WS peer:捕获下行指令(结构兼容 h3 peer) */
+class FakePeer {
+  sent: ServerToClient[] = []
+
+  send(data: string | Uint8Array): void {
+    this.sent.push(JSON.parse(typeof data === 'string' ? data : new TextDecoder().decode(data)))
+  }
+
+  close(): void {}
+}
+
+const sleep = (ms: number) => new Promise<void>(resolve => setTimeout(resolve, ms))
+
+/** 轮询等待某条下行指令出现 */
+async function waitFor(peer: FakePeer, pred: (cmd: ServerToClient) => boolean, timeoutMs: number): Promise<ServerToClient | null> {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    const found = peer.sent.find(pred)
+    if (found) {
+      return found
+    }
+    await sleep(25)
+  }
+  return null
+}
+
+const count = (peer: FakePeer, type: ServerToClient['type']) => peer.sent.filter(c => c.type === type).length
+
+// ---------------------------------------------------------------- 1. 同步 brain 全链路
+
+async function testSyncBrain(): Promise<void> {
+  const peer = new FakePeer()
+  const session = new GameSession(new ScriptBrain())
+  session.connect(peer)
+
+  check('connect → session.ready', peer.sent.some(m => m.type === 'session.ready'))
+  check('connect → agent.state(初始)', peer.sent.some(m => m.type === 'agent.state'))
+
+  // 玩家贴脸(80px < TALK_RADIUS 96px)→ 首个 tick 应发起对话
+  session.handleInput({
+    type: 'player.pos',
+    payload: { x: AGENT_SPAWN.x + 80, y: AGENT_SPAWN.y, tileX: 0, tileY: 0 },
+  })
+  const opened = await waitFor(peer, m => m.type === 'dialog.open', 2000)
+  check('贴脸 → dialog.open', opened !== null, opened ? `lines=${(opened as { payload: { lines: string[] } }).payload.lines.length}` : 'timeout')
+
+  // 空格推进:3 句 → advance×2 + close
+  session.handleInput({ type: 'input.interact', payload: {} })
+  await waitFor(peer, m => m.type === 'dialog.advance', 1000)
+  session.handleInput({ type: 'input.interact', payload: {} })
+  await waitFor(peer, () => count(peer, 'dialog.advance') >= 2, 1000)
+  session.handleInput({ type: 'input.interact', payload: {} })
+  const closed = await waitFor(peer, m => m.type === 'dialog.close', 1000)
+  check('interact×3 → dialog.close', closed !== null)
+  check('advance 恰好 2 次', count(peer, 'dialog.advance') === 2, `actual=${count(peer, 'dialog.advance')}`)
+
+  // 大脑收到 dialog.closed 事件 → 转入 wait
+  const waited = await waitFor(peer, m => m.type === 'agent.state' && m.payload.mode === 'wait', 2000)
+  check('dialog.closed 事件 → 大脑转入 wait', waited !== null)
+  session.stop()
+}
+
+// ---------------------------------------------------------------- 2. 异步 brain(sdk-mock)
+
+async function testAsyncBrain(): Promise<void> {
+  const peer = new FakePeer()
+  const session = new GameSession(new MockSdkBrain([0, 0]))
+  session.connect(peer)
+
+  const ready = await waitFor(peer, m => m.type === 'session.ready', 1000)
+  check('async connect → session.ready', ready !== null)
+  // 无玩家感知 → 大脑游荡,首个 move 决议须经 Promise 应用
+  const moved = await waitFor(peer, m => m.type === 'agent.move', 2000)
+  check('async 决议 → agent.move 下发', moved !== null, moved ? `dir=${moved.payload.dir}` : 'timeout')
+  session.stop()
+}
+
+// ---------------------------------------------------------------- 3. 大脑主动关闭对话
+
+/** 逐 tick 演进的测试大脑:先开对话,下一 tick 主动关闭 */
+class CloseBrain implements AgentBrain {
+  readonly name = 'close-test'
+
+  private phase = 0
+
+  think(_ctx: AgentContext): AgentAction[] {
+    if (this.phase === 0) {
+      this.phase = 1
+      return [{ kind: 'dialog', lines: ['hi'] }]
+    }
+    if (this.phase === 1) {
+      this.phase = 2
+      return [{ kind: 'dialog.close' }]
+    }
+    return []
+  }
+}
+
+async function testBrainClose(): Promise<void> {
+  const peer = new FakePeer()
+  const session = new GameSession(new CloseBrain())
+  session.connect(peer)
+
+  const opened = await waitFor(peer, m => m.type === 'dialog.open', 1000)
+  check('大脑发起对话 → dialog.open', opened !== null)
+  const closed = await waitFor(peer, m => m.type === 'dialog.close', 1000)
+  check('大脑 dialog.close 动作 → 下行 dialog.close', closed !== null)
+  session.stop()
+}
+
+// ---------------------------------------------------------------- 4. stop() 停止主循环
+
+async function testStop(): Promise<void> {
+  const peer = new FakePeer()
+  const session = new GameSession(new ScriptBrain())
+  session.connect(peer)
+  await waitFor(peer, m => m.type === 'agent.move', 1500)
+  session.stop()
+  const before = peer.sent.length
+  await sleep(300)
+  check('stop() 后无新指令', peer.sent.length === before, `before=${before} after=${peer.sent.length}`)
+}
+
+// ----------------------------------------------------------------
+
+async function main(): Promise<void> {
+  await testSyncBrain()
+  await testAsyncBrain()
+  await testBrainClose()
+  await testStop()
+  console.log(`\n===== ${4 - failures}/4 passed =====`)
+  process.exit(failures ? 1 : 0)
+}
+
+main().catch((e) => {
+  console.error('SESSION TEST CRASH:', e)
+  process.exit(2)
+})