agentworkshop 0.7.34 → 0.7.38

package/scripts/.mimosa/hook-state/sess_aeaecb58-8833-4b83-b93c-050467d21e03.mtxwtxme-61028-1f4519fbc4.baseline/263c2e05b425e5c322e60c6475279f963bab3a873eb521b21df7fec935a46597.source

@@ -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)
+})

package/scripts/.mimosa/hook-state/sess_aeaecb58-8833-4b83-b93c-050467d21e03.mtxwtxme-61028-1f4519fbc4.baseline/2ac5eaac28eaaee2178c4b32014df8e732f9dd432a285a872f5b7f31c1395fa4.source

@@ -0,0 +1,157 @@
+/**
+ * 审计实验 1 —— DCW 单节点写在飞互斥 + 周期读互斥(只读:不碰任何源码/数据文件)。
+ *
+ * 驱动真实 DcwNodeRuntime(dcw-runtime.ts),host 全部打桩,统计同一节点的
+ * 并发在飞写/读数;断言心跳重下发(tick)与手动 write() 共享同一 writing 闸门。
+ *
+ * 运行:node --experimental-transform-types scripts/_audit/run.mjs scripts/_audit/dcw-write-mutex.ts
+ */
+import { DcwNode } from '../../server/services/workshop/dcw/dcw-node'
+import { DcwNodeRuntime } from '../../server/services/workshop/dcw/dcw-runtime'
+
+let failures = 0
+function check(name: string, cond: boolean, extra = ''): void {
+  if (cond) {
+    console.log(`  PASS  ${name}${extra ? ` (${extra})` : ''}`)
+  }
+  else {
+    failures++
+    console.log(`  FAIL  ${name}${extra ? ` (${extra})` : ''}`)
+  }
+}
+
+const statusOf = (e: unknown): string => {
+  const s = (e as { status?: number }).status
+  return s ? String(s) : `no-status:${(e as Error)?.message ?? String(e)}`
+}
+
+interface Stats {
+  writeCalls: number
+  readCalls: number
+  inFlightWrites: number
+  maxInFlightWrites: number
+  inFlightReads: number
+  maxInFlightReads: number
+  writeEng: number[]
+  concurrentReadPairs: number
+}
+
+function makeNode(): DcwNode {
+  return DcwNode.fromRow({
+    id: 'n-audit-1',
+    templateRef: 'cw-temp',
+    name: 'audit-node',
+    driver: 'mock',
+    min: 0,
+    max: 200,
+    decimals: 2,
+    holdIntervalMs: 10,
+    readIntervalMs: 1000,
+    enabled: true,
+    lineId: 'ln-audit',
+  })
+}
+
+function makeHarness(opts: { writeDelayMs: number, readDelayMs: number }) {
+  const stats: Stats = {
+    writeCalls: 0,
+    readCalls: 0,
+    inFlightWrites: 0,
+    maxInFlightWrites: 0,
+    inFlightReads: 0,
+    maxInFlightReads: 0,
+    writeEng: [],
+    concurrentReadPairs: 0,
+  }
+  const sleep = (ms: number): Promise<void> => new Promise(r => setTimeout(r, ms))
+  const host = {
+    running: () => true,
+    defaults: () => ({ holdIntervalMs: 10, readIntervalMs: 1000 }),
+    async executeWrite(node: DcwNode, eng: number) {
+      stats.writeCalls++
+      stats.writeEng.push(eng)
+      stats.inFlightWrites++
+      stats.maxInFlightWrites = Math.max(stats.maxInFlightWrites, stats.inFlightWrites)
+      await sleep(opts.writeDelayMs)
+      stats.inFlightWrites--
+      node.applyWriteResult(eng, true, 'stub ok', new Date().toISOString())
+      return { ok: true, message: 'stub ok', raw: eng, readback: eng }
+    },
+    async executeRead() {
+      stats.readCalls++
+      stats.inFlightReads++
+      stats.maxInFlightReads = Math.max(stats.maxInFlightReads, stats.inFlightReads)
+      if (stats.inFlightReads > 1)
+        stats.concurrentReadPairs++
+      await sleep(opts.readDelayMs)
+      stats.inFlightReads--
+      return { ok: true, value: 1, raw: 1, message: 'stub read', at: new Date().toISOString() }
+    },
+  }
+  return { host, stats }
+}
+
+async function main(): Promise<void> {
+  // ---------- 场景 A:手动写在飞时,保写心跳必须跳过本拍(不得并发) ----------
+  console.log('\n[A] manual write in flight -> tick keep-alive must skip')
+  {
+    const node = makeNode()
+    const { host, stats } = makeHarness({ writeDelayMs: 120, readDelayMs: 0 })
+    const rt = new DcwNodeRuntime(node, host as never)
+    const p = rt.write(50)
+    let tickAt = 1_000_000
+    for (let i = 0; i < 20; i++) {
+      tickAt += 50 // 远超 holdIntervalMs=10,心跳到点
+      rt.tick(tickAt)
+    }
+    const concurrentSecondWrite = await rt.write(60).then(() => 'resolved', e => `rejected:${statusOf(e)}`)
+    const outcome = await p
+    check('manual write ok', outcome.ok === true)
+    check('heartbeat skipped while manual write in flight (executeWrite called once)', stats.writeCalls === 1, `calls=${stats.writeCalls}`)
+    check('max concurrent in-flight writes == 1', stats.maxInFlightWrites === 1, `max=${stats.maxInFlightWrites}`)
+    check('second concurrent manual write rejected with 409', concurrentSecondWrite === 'rejected:409', concurrentSecondWrite)
+  }
+
+  // ---------- 场景 B:手动写结束后,心跳按节奏重下发且仍与手动写互斥 ----------
+  console.log('\n[B] heartbeat re-write shares the same gate')
+  {
+    const node = makeNode()
+    const { host, stats } = makeHarness({ writeDelayMs: 60, readDelayMs: 0 })
+    const rt = new DcwNodeRuntime(node, host as never)
+    await rt.write(80)
+    const callsAfterManual = stats.writeCalls
+    const t = 2_000_100
+    rt.tick(t) // 到点 -> 心跳下发 node.value
+    rt.tick(t) // 同一拍再次 tick:心跳在飞,必须跳过
+    await new Promise(r => setTimeout(r, 5))
+    const second = await rt.write(90).then(() => 'resolved', e => `rejected:${statusOf(e)}`)
+    await new Promise(r => setTimeout(r, 150))
+    check('heartbeat issued at least one write', stats.writeCalls > callsAfterManual, `calls=${stats.writeCalls}`)
+    check('heartbeat wrote current setpoint 80', stats.writeEng.includes(80), JSON.stringify(stats.writeEng))
+    check('manual write during heartbeat in flight rejected with 409', second === 'rejected:409', second)
+    check('max concurrent in-flight writes == 1 (whole scenario)', stats.maxInFlightWrites === 1, `max=${stats.maxInFlightWrites}`)
+  }
+
+  // ---------- 场景 C:周期读的在飞互斥(readNow 与 tick 读) ----------
+  console.log('\n[C] readNow() while periodic read in flight')
+  {
+    const node = makeNode()
+    const { host, stats } = makeHarness({ writeDelayMs: 0, readDelayMs: 120 })
+    const rt = new DcwNodeRuntime(node, host as never)
+    rt.tick(3_000_000) // 触发周期读(不 await)
+    await new Promise(r => setTimeout(r, 10)) // 让周期读进入在飞
+    const res = await rt.readNow().then(() => 'resolved', e => `rejected:${statusOf(e)}`)
+    await new Promise(r => setTimeout(r, 250))
+    check('periodic read started', stats.readCalls >= 1, `readCalls=${stats.readCalls}`)
+    check(
+      'readNow() rejected (expect rejected:409) while periodic read in flight',
+      res === 'rejected:409',
+      `actual=${res}; concurrent read pairs=${stats.concurrentReadPairs}, maxInFlightReads=${stats.maxInFlightReads}`,
+    )
+  }
+
+  console.log(`\nresult: ${failures === 0 ? 'ALL PASS' : `${failures} FAILED`}`)
+  process.exit(failures === 0 ? 0 : 1)
+}
+
+void main()

package/scripts/.mimosa/hook-state/sess_aeaecb58-8833-4b83-b93c-050467d21e03.mtxwtxme-61028-1f4519fbc4.baseline/33a0db0d2d95d2c11d0720090458e5fba1425376f5ceb5b422d1d3471be3226b.source

@@ -0,0 +1,348 @@
+/**
+ * AgentRuntime 运行时核心测试(node + tsx 直跑,无浏览器)。
+ *
+ * 覆盖:
+ *  1. idle 自动消费
+ *  2. busy 时 enqueue 不打断(排队)
+ *  3. 结束后续消费积压
+ *  4. assign 消息触发 transition('WORKING')
+ *  5. 单条 run 抛错不阻塞下一条
+ *  6. abort 终止事件流
+ *  7. stop 优雅(等当前事件流结束)
+ *
+ * 注入 fake TaskEngine(与契约相同签名),真实引擎装配留到集成阶段。
+ */
+import { randomUUID } from 'node:crypto'
+import type { DatabaseSync } from 'node:sqlite'
+import { openWorkshopDb } from '../server/services/workshop/db/database'
+import { createMessageRepo } from '../server/services/workshop/db/message.repo'
+import type { MessageRepo } from '../server/services/workshop/db/message.repo'
+import { Mailbox } from '../server/services/workshop/runtime/mailbox'
+import { AgentRuntime } from '../server/services/workshop/runtime/agent-runtime'
+import type { ChannelBus, TaskEngine } from '../server/services/workshop/runtime/agent-runtime'
+import type { A2AMessage, Part } from '../server/services/workshop/types/a2a'
+import type { AgentTaskQueueView, TaskState, WorkspaceTask } from '../server/services/workshop/types/task'
+import type {
+  AgentEvent,
+  AgentInfo,
+  AgentInterface,
+  AgentRunContext,
+  AgentRunRequest,
+  AgentWorkspace,
+} from '../server/services/workshop/agents/agent-interface'
+
+let failures = 0
+function check(name: string, ok: boolean, detail = ''): void {
+  console.log(`${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` — ${detail}` : ''}`)
+  if (!ok) {
+    failures += 1
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(r => setTimeout(r, ms))
+}
+
+async function waitUntil(cond: () => boolean, timeoutMs = 3000): Promise<void> {
+  const start = Date.now()
+  while (!cond()) {
+    if (Date.now() - start > timeoutMs) throw new Error('等待超时')
+    await sleep(5)
+  }
+}
+
+/** 落库一个 channel(messages.channel_id 外键依赖) */
+function seedChannel(db: DatabaseSync, id: string): void {
+  const now = new Date().toISOString()
+  db.prepare(
+    `INSERT INTO channels (id, name, description, lead_agent_id, enabled, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)`,
+  ).run(id, id, '', null, 1, now, now)
+}
+
+function mkAgent(id: string, role: 'lead' | 'worker', channelId: string): AgentInfo {
+  return { id, channelId, name: id, harness: 'mock', role, config: {} }
+}
+
+function mkMessage(channelId: string, parts: Part[], metadata?: Record<string, unknown>): A2AMessage {
+  return { messageId: randomUUID(), contextId: channelId, role: 'ROLE_USER', parts, metadata }
+}
+
+function mkTask(channelId: string, assigneeId: string, title: string): WorkspaceTask {
+  return {
+    id: randomUUID(),
+    channelId,
+    assigneeId,
+    creatorId: '',
+    title,
+    state: 'SUBMITTED',
+    progress: 0,
+    retryCount: 0,
+    artifacts: [],
+    history: [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  }
+}
+
+/** fake TaskEngine:记录 transition/applyEvent,提供 get/create 等(与契约相同签名) */
+function makeFakeEngine() {
+  const transitions: { taskId: string, state: TaskState, by: string }[] = []
+  const applied: { taskId: string, event: AgentEvent }[] = []
+  const tasks = new Map<string, WorkspaceTask>()
+  const engine = {
+    create(input: {
+      channelId: string
+      creatorId: string
+      assigneeId: string
+      title: string
+      description?: string
+      parentId?: string
+      parts?: Part[]
+    }): WorkspaceTask {
+      const t = mkTask(input.channelId, input.assigneeId, input.title)
+      tasks.set(t.id, t)
+      return t
+    },
+    dispatch(): WorkspaceTask {
+      throw new Error('dispatch 未在测试中使用')
+    },
+    transition(taskId: string, state: TaskState, by: string): WorkspaceTask {
+      transitions.push({ taskId, state, by })
+      const t = tasks.get(taskId)
+      if (t) t.state = state
+      return t ?? mkTask('', '', '')
+    },
+    applyEvent(taskId: string, event: AgentEvent): void {
+      applied.push({ taskId, event })
+    },
+    list(): WorkspaceTask[] {
+      return [...tasks.values()]
+    },
+    get(taskId: string): WorkspaceTask | undefined {
+      return tasks.get(taskId)
+    },
+    complete(): WorkspaceTask {
+      throw new Error('complete 未在测试中使用')
+    },
+    reassign(): WorkspaceTask {
+      throw new Error('reassign 未在测试中使用')
+    },
+    cancel(): WorkspaceTask {
+      throw new Error('cancel 未在测试中使用')
+    },
+    onChildCompleted(): void {},
+    queueViewOf(channelId: string, agentId: string): AgentTaskQueueView {
+      const mine = [...tasks.values()].filter(t => t.channelId === channelId && t.assigneeId === agentId)
+      return {
+        agentId,
+        channelId,
+        queued: mine.filter(t => t.state === 'SUBMITTED' || t.state === 'ASSIGNED'),
+        current: mine.find(t => t.state === 'WORKING'),
+        completed: mine.filter(t => t.state === 'COMPLETED'),
+      }
+    },
+  }
+  return { engine: engine as TaskEngine, transitions, applied, tasks }
+}
+
+/** 可配置 fake impl:记录 run 调用,按注入的生成器产出事件流 */
+class FakeImpl implements AgentInterface {
+  calls: AgentRunRequest[] = []
+  constructor(
+    private behavior: (req: AgentRunRequest, ctx: AgentRunContext) => AsyncGenerator<AgentEvent, void, unknown>,
+  ) {}
+
+  run(req: AgentRunRequest, ctx: AgentRunContext): AsyncIterable<AgentEvent> {
+    this.calls.push(req)
+    return this.behavior(req, ctx)
+  }
+}
+
+interface Setup {
+  messages: MessageRepo
+  busEvents: { event: AgentEvent, source: A2AMessage }[]
+  bus: ChannelBus
+  engine: ReturnType<typeof makeFakeEngine>
+}
+
+function setup(): Setup {
+  const db = openWorkshopDb(':memory:')
+  seedChannel(db, 'ch1')
+  const messages = createMessageRepo(db)
+  const busEvents: { event: AgentEvent, source: A2AMessage }[] = []
+  const bus: ChannelBus = {
+    emit: (event, source) => busEvents.push({ event, source }),
+    onEvent: () => () => {},
+    notifyTask: () => {},
+    notifyAgent: () => {},
+    onAgentStatus: () => {},
+    onTaskEvent: () => {},
+    wakeScheduler: () => {},
+  }
+  return { messages, busEvents, bus, engine: makeFakeEngine() }
+}
+
+function makeRuntime(s: Setup, agent: AgentInfo, impl: AgentInterface): AgentRuntime {
+  const mailbox = new Mailbox(s.messages, agent.channelId, agent.id, () => {})
+  const workspace = {} as AgentWorkspace
+  return new AgentRuntime(agent, impl, { mailbox, taskEngine: s.engine.engine, bus: s.bus, workspace })
+}
+
+async function testAutoConsume(): Promise<void> {
+  console.log('\n--- 1. idle 自动消费 ---')
+  const s = setup()
+  const impl = new FakeImpl(async function* () {
+    yield { kind: 'status', status: { state: 'working', timestamp: new Date().toISOString() } }
+    yield { kind: 'done' }
+  })
+  const rt = makeRuntime(s, mkAgent('a1', 'worker', 'ch1'), impl)
+  rt.start()
+  const msg = mkMessage('ch1', [])
+  rt.enqueue(msg)
+  await waitUntil(() => impl.calls.length === 1)
+  await waitUntil(() => rt.getState() === 'idle')
+  check('enqueue 后自动消费:run 被调用', impl.calls.length === 1)
+  check('自动消费:事件逐条广播', s.busEvents.length === 2, `收到 ${s.busEvents.length} 个事件`)
+  check('自动消费:消息标记已消费', s.messages.listPendingByChannelAgent('ch1', 'a1').length === 0)
+  await rt.stop()
+}
+
+async function testBusyQueue(): Promise<void> {
+  console.log('\n--- 2/3. busy 不打断 + 积压消费 ---')
+  const s = setup()
+  let release!: () => void
+  const hold = new Promise<void>((r) => {
+    release = r
+  })
+  const impl = new FakeImpl(async function* () {
+    yield { kind: 'status', status: { state: 'started', timestamp: new Date().toISOString() } }
+    await hold
+    yield { kind: 'done' }
+  })
+  const rt = makeRuntime(s, mkAgent('a1', 'worker', 'ch1'), impl)
+  rt.start()
+  const msgA = mkMessage('ch1', [])
+  const msgB = mkMessage('ch1', [])
+  rt.enqueue(msgA)
+  await waitUntil(() => impl.calls.length === 1)
+  check('busy 时不打断:state=busy', rt.getState() === 'busy')
+  rt.enqueue(msgB)
+  await sleep(30)
+  check('busy 时不打断:B 排队未处理', impl.calls.length === 1)
+  release()
+  await waitUntil(() => impl.calls.length === 2)
+  await waitUntil(() => rt.getState() === 'idle')
+  check('结束后续消费积压:B 被消费', impl.calls.length === 2)
+  check('积压消费:两条消息均已消费', s.messages.listPendingByChannelAgent('ch1', 'a1').length === 0)
+  await rt.stop()
+}
+
+async function testAssignTransition(): Promise<void> {
+  console.log('\n--- 4. assign 消息触发 transition WORKING ---')
+  const s = setup()
+  const impl = new FakeImpl(async function* () {
+    yield { kind: 'done' }
+  })
+  const rt = makeRuntime(s, mkAgent('a1', 'worker', 'ch1'), impl)
+  rt.start()
+  const task = mkTask('ch1', 'a1', '任务A')
+  s.engine.tasks.set(task.id, task)
+  const msg = mkMessage('ch1', [], { 'x-aw-task-kind': 'assign', 'x-aw-task-id': task.id })
+  msg.taskId = task.id
+  rt.enqueue(msg)
+  await waitUntil(() => impl.calls.length === 1)
+  await waitUntil(() => rt.getState() === 'idle')
+  check(
+    'assign 消息触发 transition("WORKING", agentId)',
+    s.engine.transitions.some(t => t.taskId === task.id && t.state === 'WORKING' && t.by === 'a1'),
+  )
+  await rt.stop()
+}
+
+async function testErrorDoesNotBlock(): Promise<void> {
+  console.log('\n--- 5. 单条 run 抛错不阻塞下一条 ---')
+  const s = setup()
+  let callCount = 0
+  const impl = new FakeImpl(async function* () {
+    callCount += 1
+    if (callCount === 1) {
+      yield { kind: 'status', status: { state: 'boom', timestamp: new Date().toISOString() } }
+      throw new Error('boom')
+    }
+    yield { kind: 'done' }
+  })
+  const rt = makeRuntime(s, mkAgent('a1', 'worker', 'ch1'), impl)
+  rt.start()
+  rt.enqueue(mkMessage('ch1', []))
+  rt.enqueue(mkMessage('ch1', []))
+  await waitUntil(() => impl.calls.length >= 3 && rt.getState() === 'idle')
+  check('单条抛错重投重试:失败消息重试成功且不阻塞下一条', impl.calls.length === 3)
+  check('重试后消息仍标记消费', s.messages.listPendingByChannelAgent('ch1', 'a1').length === 0)
+  await rt.stop()
+}
+
+async function testAbort(): Promise<void> {
+  console.log('\n--- 6. abort 终止事件流 ---')
+  const s = setup()
+  let events = 0
+  const impl = new FakeImpl(async function* (_req, ctx) {
+    for (let i = 0; i < 300; i++) {
+      if (ctx.signal.aborted) break
+      events += 1
+      yield { kind: 'status', status: { state: `step${i}`, timestamp: new Date().toISOString() } }
+      await sleep(2)
+    }
+    yield { kind: 'done' }
+  })
+  const rt = makeRuntime(s, mkAgent('a1', 'worker', 'ch1'), impl)
+  rt.start()
+  rt.enqueue(mkMessage('ch1', []))
+  await waitUntil(() => events >= 3)
+  rt.abortCurrent()
+  await waitUntil(() => rt.getState() === 'idle')
+  check('abort 后事件流终止', events < 300, `终止于第 ${events} 个事件`)
+  await rt.stop()
+}
+
+async function testStop(): Promise<void> {
+  console.log('\n--- 7. stop 优雅 ---')
+  const s = setup()
+  let release!: () => void
+  const hold = new Promise<void>((r) => {
+    release = r
+  })
+  const impl = new FakeImpl(async function* () {
+    yield { kind: 'status', status: { state: 'working', timestamp: new Date().toISOString() } }
+    await hold
+    yield { kind: 'done' }
+  })
+  const rt = makeRuntime(s, mkAgent('a1', 'worker', 'ch1'), impl)
+  rt.start()
+  rt.enqueue(mkMessage('ch1', []))
+  await waitUntil(() => impl.calls.length === 1)
+  let stopResolved = false
+  const _stopPromise = rt.stop().then(() => {
+    stopResolved = true
+  })
+  await sleep(30)
+  check('stop 等当前事件流结束(未提前返回)', !stopResolved)
+  release()
+  await waitUntil(() => stopResolved)
+  check('stop 优雅:state=stopped', rt.getState() === 'stopped')
+}
+
+async function main(): Promise<void> {
+  await testAutoConsume()
+  await testBusyQueue()
+  await testAssignTransition()
+  await testErrorDoesNotBlock()
+  await testAbort()
+  await testStop()
+  console.log(`\n${failures === 0 ? 'ALL PASS' : `${failures} FAILURE(S)`}`)
+  process.exit(failures === 0 ? 0 : 1)
+}
+
+main().catch((e) => {
+  console.error('测试异常:', e)
+  process.exit(1)
+})