agentworkshop 0.2.1

package/scripts/test-collab-omp.mjs

@@ -0,0 +1,192 @@
+/**
+ * AgentTeam 协作 omp 实测(goal + pipeline + 防重复验证):
+ *  - 模型:zhipu-coding-plan/glm-5-turbo(快速;agent config 注入 provider/model)
+ *  - GOAL:lead 分解 → worker 完成 → lead 判断满意度 → 父任务 COMPLETED(含结语交付)
+ *          并断言无同标题重复子任务(防重复守卫 + lead 邮件知情)
+ *  - PIPELINE:两阶段顺序执行,阶段 2 引用阶段 1 产出 → COMPLETED
+ *  - 统计:lead supervise 轮数(事件流 agent.status/message 计数)观察节流效果
+ * 运行:node scripts/test-collab-omp.mjs(默认 http://127.0.0.1:3101;需 omp CLI)
+ */
+const BASE = process.env.AW_BASE ?? 'http://127.0.0.1:3101'
+const PROVIDER = 'zhipu-coding-plan'
+const MODEL = 'glm-5-turbo'
+
+let failures = 0
+let passed = 0
+const check = (name, ok, detail = '') => {
+  console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` — ${detail}` : ''}`)
+  if (ok) passed += 1
+  else failures += 1
+}
+const sleep = ms => new Promise(r => setTimeout(r, ms))
+
+async function waitUntil(name, cond, timeoutMs, intervalMs = 2000) {
+  const deadline = Date.now() + timeoutMs
+  let last = null
+  while (Date.now() < deadline) {
+    try {
+      last = await cond()
+      if (last) return last
+    }
+    catch (e) { last = e }
+    await sleep(intervalMs)
+  }
+  throw new Error(`waitUntil timeout: ${name} (last=${String(last).slice(0, 160)})`)
+}
+
+const api = async (method, path, { body, token } = {}) => {
+  const headers = { 'content-type': 'application/json' }
+  if (token) headers.authorization = `Bearer ${token}`
+  const res = await fetch(`${BASE}${path}`, { method, headers, body: body !== undefined ? JSON.stringify(body) : undefined })
+  return { status: res.status, ...(await res.json().catch(() => ({}))) }
+}
+
+async function makeTeam(token, name) {
+  const ch = await api('POST', '/api/workshop/channels', {
+    body: {
+      name,
+      leadAgent: { name: `${name}-lead`, harness: 'omp', config: { provider: PROVIDER, model: MODEL } },
+    },
+    token,
+  })
+  if (ch.code !== 0) throw new Error(`channel 创建失败: ${JSON.stringify(ch).slice(0, 140)}`)
+  const channelId = ch.data.channelId
+  const w = await api('POST', `/api/workshop/channels/${channelId}/agents`, {
+    body: { name: `${name}-worker`, harness: 'omp', role: 'worker', config: { provider: PROVIDER, model: MODEL } },
+    token,
+  })
+  if (w.code !== 0) throw new Error('worker 创建失败')
+  return { channelId, leadId: ch.data.leadAgentId, workerId: w.data.id }
+}
+
+const tasksOf = async (token, channelId) =>
+  (await api('GET', `/api/workshop/channels/${channelId}/tasks`, { token })).data ?? []
+
+const eventsOf = async (token, channelId, limit = 500) =>
+  (await api('GET', `/api/workshop/channels/${channelId}/events?limit=${limit}`, { token })).data?.items ?? []
+
+// ═══════════ GOAL 模式 ═══════════
+
+async function testGoal(token) {
+  console.log('\n━━━ GOAL 模式(omp)━━━')
+  const { channelId } = await makeTeam(token, `goal-${Date.now().toString(36)}`)
+  check('团队就绪(omp lead + worker, glm-5-turbo)', true, `channel=${channelId.slice(0, 8)}`)
+
+  const t0 = Date.now()
+  const task = await api('POST', `/api/workshop/channels/${channelId}/tasks`, {
+    body: {
+      title: 'goal-marker',
+      description: '[mode:goal][criteria:worker 已给出含单词 GOAL-DONE 的回复] Delegate to the worker: reply with a sentence containing the word GOAL-DONE, then complete. Judge satisfaction and finish.',
+    },
+    token,
+  })
+  const parentId = task.data.id
+
+  const finalState = await waitUntil('goal 父任务终态', async () => {
+    const t = (await tasksOf(token, channelId)).find(x => x.id === parentId)
+    return ['COMPLETED', 'FAILED', 'CANCELED'].includes(t?.state ?? '') ? t.state : null
+  }, 480_000)
+  const elapsed = Math.round((Date.now() - t0) / 1000)
+  check('goal 父任务完成', finalState === 'COMPLETED', `state=${finalState} 耗时=${elapsed}s`)
+
+  const tasks = await tasksOf(token, channelId)
+  const children = tasks.filter(t => t.parentId === parentId)
+  check('子任务已派发(lead 分解)', children.length >= 1, `children=${children.length}`)
+
+  // 防重复:同标题子任务唯一(无重复派发)
+  const titles = children.map(c => c.title.replace(/\s+/g, ' ').trim().toLowerCase())
+  const dupTitles = titles.filter((t, i) => titles.indexOf(t) !== i)
+  check('无重复派发(同标题子任务唯一)', dupTitles.length === 0, `children=${children.length}, titles=${JSON.stringify(titles).slice(0, 120)}`)
+
+  // 交付链:worker 交付存在;父任务结语存在
+  const childDone = children.find(c => c.state === 'COMPLETED')
+  check('worker 子任务完成且带交付', !!childDone && (childDone.artifacts?.length ?? 0) > 0)
+  const parent = tasks.find(t => t.id === parentId)
+  const parentText = JSON.stringify(parent?.artifacts ?? '')
+  check('父任务含最终结语交付(goal close-out)', (parent?.artifacts?.length ?? 0) > 0 && parentText.includes('GOAL-DONE'), parentText.slice(0, 90))
+
+  // lead 知情:邮件中含 worker 的任务交付回执
+  const mails = (await api('GET', `/api/workshop/mailbox/all`, { token }).catch(() => ({ data: [] }))).data ?? []
+  check('channel 邮件含协作记录(lead 可见 worker 行为)', Array.isArray(mails))
+
+  // supervise 节流观察:lead 的 status 消息次数(supervise 回合≈agent.status.message/agent.message 计数)
+  const evs = await eventsOf(token, channelId)
+  const leadMsgs = evs.filter(e => e.type === 'agent.status.message' || e.type === 'agent.message').length
+  check('supervise 轮数受节流控制(无忙轮转)', leadMsgs < 30, `lead 消息事件=${leadMsgs}, 总事件=${evs.length}`)
+
+  return { channelId }
+}
+
+// ═══════════ PIPELINE 模式 ═══════════
+
+async function testPipeline(token) {
+  console.log('\n━━━ PIPELINE 模式(omp)━━━')
+  const { channelId } = await makeTeam(token, `pipe-${Date.now().toString(36)}`)
+  check('团队就绪', true, `channel=${channelId.slice(0, 8)}`)
+
+  const t0 = Date.now()
+  const task = await api('POST', `/api/workshop/channels/${channelId}/tasks`, {
+    body: {
+      title: 'pipe-marker',
+      description: '[mode:pipeline][stages:produce->verify] Produce the secret word PIPE-42 in stage 1; stage 2 must verify stage 1 output contains PIPE-42 and complete with a verdict.',
+    },
+    token,
+  })
+  const parentId = task.data.id
+
+  const finalState = await waitUntil('pipeline 父任务终态', async () => {
+    const t = (await tasksOf(token, channelId)).find(x => x.id === parentId)
+    return ['COMPLETED', 'FAILED', 'CANCELED'].includes(t?.state ?? '') ? t.state : null
+  }, 480_000)
+  const elapsed = Math.round((Date.now() - t0) / 1000)
+  check('pipeline 父任务完成', finalState === 'COMPLETED', `state=${finalState} 耗时=${elapsed}s`)
+
+  const tasks = await tasksOf(token, channelId)
+  const children = tasks.filter(t => t.parentId === parentId).sort((a, b) => a.createdAt < b.createdAt ? -1 : 1)
+  check('两阶段子任务存在', children.length >= 2, `children=${children.length}`)
+
+  // 顺序依赖:阶段 2 的 description 引用阶段 1 的产出
+  if (children.length >= 2) {
+    const second = children[1]
+    const referenced = String(second.description ?? '').includes('PIPE-42')
+    check('阶段 2 引用阶段 1 产出(顺序依赖传导)', referenced, `stage2 desc=${String(second.description).slice(0, 110)}`)
+  }
+
+  // 无重复派发
+  const titles = children.map(c => c.title.replace(/\s+/g, ' ').trim().toLowerCase())
+  const dup = titles.filter((t, i) => titles.indexOf(t) !== i)
+  check('无重复派发', dup.length === 0, `titles=${JSON.stringify(titles).slice(0, 120)}`)
+
+  // 最终交付含 verify 结论
+  const parent = tasks.find(t => t.id === parentId)
+  const text = JSON.stringify(parent?.artifacts ?? '')
+  check('父任务含流水线最终交付', (parent?.artifacts?.length ?? 0) > 0, text.slice(0, 90))
+
+  return { channelId }
+}
+
+async function main() {
+  console.log(`目标: ${BASE}(模型 ${PROVIDER}/${MODEL})`)
+  const user = await api('POST', '/api/workshop/users/register', { body: { name: `collab-omp-${Date.now().toString(36)}` } })
+  const token = user.data?.token
+  if (!token) throw new Error('注册失败')
+
+  const goal = await testGoal(token)
+  const pipe = await testPipeline(token)
+
+  // 清理
+  for (const { channelId } of [goal, pipe]) {
+    const members = await api('GET', `/api/workshop/channels/${channelId}/agents`, { token })
+    for (const m of members.data ?? []) {
+      await api('POST', '/api/system/monitor/terminate', { body: { channelId, agentId: m.id }, token }).catch(() => {})
+    }
+    await api('DELETE', `/api/workshop/channels/${channelId}`, { token })
+  }
+  console.log(`\n★ 结果: ${passed} passed, ${failures} failed`)
+  process.exit(failures === 0 ? 0 : 1)
+}
+
+main().catch((err) => {
+  console.error('e2e 异常:', err.message)
+  process.exit(1)
+})

package/scripts/test-dedup-logic.ts

@@ -0,0 +1,132 @@
+/**
+ * 事件消费去重回归(逻辑级):
+ *  断言"每个 WS 事件恰好消费一次、绝不重复渲染"的三条防线:
+ *  R1. delta 合并(ingest)× loadHistory 历史回填 → 同段文本只出现一次(consumed seq 集合)
+ *  R2. 历史头部插入 × 聚类器增量推进 → 已聚类事件不成第二块(头部 seq 检测重建;真实 BlockClusterer)
+ *  R3. 快照对齐/重放与过滤切换 → 聚类重建后仍无重复(真实 BlockClusterer)
+ * 注:events store 的 ingest/loadHistory 含 $fetch,纯 Node 环境按实现等价复刻
+ *     (与 stores/workshop/events.ts 保持同步);聚类器为真实导入。
+ * 运行:pnpm exec tsx scripts/test-dedup-logic.ts
+ */
+import { BlockClusterer } from '../app/composables/workshop/useEventBlocks'
+import type { AepEnvelope } from '../shared/workshop-protocol'
+
+const env = (seq: number, type: string, payload: Record<string, unknown>, agentId = 'w1'): AepEnvelope =>
+  ({ v: 1, type, seq, at: new Date().toISOString(), channelId: 'c1', agentId, payload }) as AepEnvelope
+
+let failures = 0
+const check = (name: string, ok: boolean, detail = ''): void => {
+  console.log(`  [${ok ? 'PASS' : 'FAIL'}] ${name}${detail ? ` — ${detail}` : ''}`)
+  if (!ok) failures += 1
+}
+
+// ===== events.ingest / loadHistory 等价复刻(与 stores/workshop/events.ts 同步) =====
+function makeRing() {
+  return { lastSeq: 0, items: [] as AepEnvelope[], consumed: new Set<number>() }
+}
+type Ring = ReturnType<typeof makeRing>
+function ingest(ring: Ring, e: AepEnvelope): void {
+  if (e.type === 'channel.snapshot') {
+    ring.lastSeq = e.seq
+    ring.items = []
+    ring.consumed = new Set([e.seq])
+    return
+  }
+  if (typeof e.seq === 'number' && e.seq > ring.lastSeq) {
+    ring.consumed.add(e.seq)
+    if (e.type === 'agent.delta') {
+      const last = ring.items[ring.items.length - 1]
+      if (last && last.type === 'agent.delta' && last.agentId === e.agentId && (last.taskId ?? null) === (e.taskId ?? null)) {
+        (last.payload as { delta: string }).delta += (e.payload as { delta: string }).delta
+        ring.lastSeq = e.seq
+        return
+      }
+    }
+    ring.items.push(e)
+    ring.lastSeq = e.seq
+  }
+}
+function loadHistoryInto(ring: Ring, frames: AepEnvelope[]): void {
+  for (const e of frames) {
+    if (typeof e.seq !== 'number' || e.seq > ring.lastSeq) continue
+    if (ring.consumed.has(e.seq)) continue
+    ring.items.push(e)
+    ring.consumed.add(e.seq)
+  }
+  ring.items.sort((a, b) => a.seq - b.seq)
+}
+
+// ===== R1:delta 合并 × loadHistory 历史回填 =====
+console.log('R1. delta 合并 × 历史回填(consumed seq 去重)')
+{
+  const ring = makeRing()
+  ingest(ring, env(100, 'channel.snapshot', {}))
+  ingest(ring, env(101, 'agent.delta', { delta: '你好' }))
+  ingest(ring, env(102, 'agent.delta', { delta: '，worker' })) // 合并进 seq=101
+  const history = [env(101, 'agent.delta', { delta: '你好' }), env(102, 'agent.delta', { delta: '，worker' }), env(99, 'task.status', { state: 'WORKING' })]
+  loadHistoryInto(ring, history)
+  const texts = ring.items.filter(i => i.type === 'agent.delta').map(i => (i.payload as { delta: string }).delta)
+  const dupCount = texts.join('\n').split('，worker').length - 1
+  check('合并过的 delta 不被历史回填重复插入', dupCount === 1, `delta frames=${JSON.stringify(texts)}`)
+  check('未被消费的历史帧正常补入(可见)', ring.items.some(i => i.seq === 99 && i.type === 'task.status'))
+  check('items 按 seq 升序', ring.items.every((it, i, a) => i === 0 || a[i - 1]!.seq <= it.seq))
+}
+
+// ===== R2:历史头部插入 × 聚类器增量推进(真实 BlockClusterer) =====
+console.log('R2. 历史头部插入 × 聚类器增量(头部 seq 检测重建)')
+{
+  const clusterer = new BlockClusterer()
+  const live = [
+    env(101, 'agent.delta', { delta: '流式输出A' }),
+    env(102, 'task.status', { state: 'WORKING' }),
+    env(103, 'agent.delta', { delta: '流式输出B' }),
+    env(104, 'agent.delta', { delta: '续' }), // 与 103 同源连续 → 聚类器层再合并进同块
+  ]
+  clusterer.sync(live)
+  const before = clusterer.blocks.length
+
+  // 历史回填:seq ≤ 快照游标(100)的 100 帧(与 live 101+ 无重叠;
+  // 与 live 重叠的场景由 store 的 consumed 闸门拦截,见 R1)
+  const history = Array.from({ length: 100 }, (_, i) => env(i + 1, 'task.status', { state: 'SUBMITTED' }))
+  const merged = [...history, ...live].sort((a, b) => a.seq - b.seq)
+  clusterer.sync(merged)
+
+  const blocksWith = (text: string) => clusterer.blocks.filter(b => b.events.some(e => (e.payload as { delta?: string }).delta === text)).length
+  check('已聚类流事件不成第二块(A)', blocksWith('流式输出A') === 1, `A块数=${blocksWith('流式输出A')}`)
+  check('已聚类流事件不成第二块(B)', blocksWith('流式输出B') === 1, `B块数=${blocksWith('流式输出B')}`)
+  check('历史事件被全量重建聚类(可见)', clusterer.blocks.length >= before, `blocks=${clusterer.blocks.length}`)
+  // 全序列无任何事件被消费两次:逐块 events 展开后 seq 无重复
+  const allSeqs = clusterer.blocks.flatMap(b => b.events.map(e => e.seq))
+  check('全部块内事件 seq 无重复(每事件恰好消费一次)', new Set(allSeqs).size === allSeqs.length, `events=${allSeqs.length}`)
+}
+
+// ===== R3:重放对齐 + 过滤切换重建 =====
+console.log('R3. 重放对齐 / 过滤切换(每事件恰好一次)')
+{
+  // 快照对齐:同批事件二次投递(重连重放)→ ingest seq 闸门丢弃
+  const ring = makeRing()
+  ingest(ring, env(100, 'channel.snapshot', {}))
+  const batch = [env(101, 'agent.delta', { delta: 'x' }), env(102, 'task.status', { state: 'WORKING' })]
+  for (const e of batch) ingest(ring, e)
+  for (const e of batch) ingest(ring, e) // 重放
+  check('重放帧被 seq 闸门丢弃', ring.items.length === 2, `items=${ring.items.length}`)
+
+  // 过滤切换:聚类器对不同子序列切换后仍无重复消费
+  const c = new BlockClusterer()
+  const events = [
+    env(1, 'agent.delta', { delta: 's1' }, 'w1'),
+    env(2, 'task.status', { state: 'WORKING' }),
+    env(3, 'agent.delta', { delta: 's2' }, 'w1'),
+    env(4, 'agent.delta', { delta: 's3' }, 'w2'),
+  ]
+  c.sync(events) // 全量
+  c.sync(events.filter(e => e.agentId === 'w1')) // 切换到过滤视图
+  c.sync(events) // 切回全量
+  const allSeqs = c.blocks.flatMap(b => b.events.map(e => e.seq))
+  const w1StreamBlocks = c.blocks.filter(b => b.events.some(e => (e.payload as { delta?: string }).delta === 's1')).length
+  check('过滤来回切换后事件仍只消费一次', new Set(allSeqs).size === allSeqs.length && allSeqs.length === 4, `events=${allSeqs.length}`)
+  check('过滤来回切换后流块不重复', w1StreamBlocks === 1, `s1块数=${w1StreamBlocks}`)
+}
+
+console.log(failures === 0 ? '\n★ 全部通过:每事件恰好消费一次,无重复渲染' : `\n${failures} 项失败 ❌`)
+process.exit(failures === 0 ? 0 : 1)

package/scripts/test-dual-drive.ts

@@ -0,0 +1,227 @@
+/**
+ * 双驱动端到端测试 — MCP(Streamable HTTP)与 REST API 同流程驱动真实 Manager。
+ *
+ * 覆盖:
+ *  1. MCP 驱动: 真实 WebStandardStreamableHTTPServerTransport + MCP SDK Client 连接
+ *     → initialize → tools/list(16 工具)→ channel.create → agent.create(lead/worker, 取 token)
+ *     → task.submit → task.list → a2a.send(带 token) → task.dispatch/report/complete
+ *     → 无 token → UNAUTHORIZED
+ *  2. REST 驱动: 同一 Manager,经 h3 app 调用 REST 端点
+ *     → 创建 channel/agent → 发任务 → Bearer token 调 mailbox/subscribe/report/complete/dispatch/tasks
+ *     → 无 token → 401;跨 channel → SCOPE_VIOLATION
+ *
+ * 测试环境: :memory: db + 真实 Manager + mock impl(delayMs=0),h3 toWebHandler 供 MCP client fetch 注入。
+ */
+import { randomUUID } from 'node:crypto'
+import { toWebHandler, createApp, eventHandler } from 'h3'
+import { Client } from '@modelcontextprotocol/sdk/client/index.js'
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'
+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 { createAgentImpl } from '../server/services/workshop/agents/factory'
+import { SchedulerLoop } from '../server/services/workshop/runtime/scheduler-loop'
+import type { AgentChannelManager } from '../server/services/workshop/runtime/manager'
+import type { ChannelRuntime } from '../server/services/workshop/runtime/channel-runtime'
+
+let failures = 0
+function check(name: string, ok: boolean, detail = ''): void {
+  console.log(`${ok ? 'PASS' : 'FAIL'}  ${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
+}
+
+/** 白盒取 manager 内部 ChannelRuntime(测试装配 SchedulerLoop 用) */
+function channelRuntimeOf(manager: AgentChannelManager, channelId: string): ChannelRuntime {
+  const internals = manager as unknown as { channels: Map<string, ChannelRuntime> }
+  const cr = internals.channels.get(channelId)
+  if (!cr) throw new Error(`channel runtime 不存在: ${channelId}`)
+  return cr
+}
+
+function attachScheduler(manager: AgentChannelManager, channelId: string, tickMs: number): SchedulerLoop {
+  // 懒加载时代:先激活 channel(装配 lead 运行时与默认循环),再换成测试配置的循环
+  manager.ensureChannelActive(channelId)
+  const cr = channelRuntimeOf(manager, channelId)
+  cr.scheduler?.stop()
+  const lead = cr.getAgents().find(a => a.role === 'lead')
+  if (!lead) throw new Error('无 lead')
+  const internals = manager as unknown as { agentIndex: Map<string, unknown> }
+  const runtime = internals.agentIndex.get(lead.agentId) as { role: string } & { abortCurrent(): void }
+  void runtime
+  const loop = new SchedulerLoop(cr, lead as never, { tickMs })
+  cr.scheduler = loop
+  loop.start()
+  return loop
+}
+
+interface Harness {
+  db: ReturnType<typeof openWorkshopDb>
+  manager: AgentChannelManager
+  loops: SchedulerLoop[]
+  channels: string[]
+  fetchLike: typeof fetch
+}
+
+function setup(): Harness {
+  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 })
+
+  // h3 app 挂 REST 入口(与生产路由同 handler;MCP 端点单独用原生 fetch 包)
+  const app = createApp()
+  app.use(
+    '/api/workshop/channels',
+    eventHandler(async (_event) => {
+      // 简化:直接走 manager(端点行为在 test-rest 段显式断言)
+      return { code: 0, data: await manager.listChannels() }
+    }),
+  )
+  const webHandle = toWebHandler(app)
+  const fetchLike: typeof fetch = (input, init) => webHandle(input as Request, init)
+  return { db, manager, loops: [], channels: [], fetchLike }
+}
+
+async function main(): Promise<void> {
+  const h = setup()
+  console.log('\n=== 1. MCP Streamable HTTP 驱动(真实 transport + SDK Client) ===')
+
+  // 手动构造 MCP 端点 handler 的 web 包装(与 server/api/mcp/workshop.ts 同逻辑)
+  const sessions = new Map<string, { handle(request: Request): Promise<Response> }>()
+  const mcpFetch: typeof fetch = async (input, init) => {
+    const request = new Request(input, init)
+    const url = new URL(request.url)
+    const sessionId = url.searchParams.get('sessionId') ?? request.headers.get('mcp-session-id')
+    if (request.method === 'DELETE' && sessionId) {
+      sessions.delete(sessionId)
+      return new Response(null, { status: 204 })
+    }
+    let entry = sessionId ? sessions.get(sessionId) : undefined
+    if (!entry) {
+      const { WebStandardStreamableHTTPServerTransport } = await import('@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js')
+      const { createWorkshopMcpServer } = await import('../server/mcp/workshop-server')
+      const newSessionId = randomUUID()
+      const transport = new WebStandardStreamableHTTPServerTransport({ sessionIdGenerator: () => newSessionId })
+      const server = createWorkshopMcpServer(h.manager)
+      await server.connect(transport)
+      entry = { handle: req => transport.handleRequest(req) }
+      sessions.set(newSessionId, entry)
+    }
+    const res = await entry.handle(request)
+    console.log(`[mcp] ${request.method} in-session=${sessionId ?? '-'} -> ${res.status} out-session=${res.headers.get('mcp-session-id') ?? '-'}`)
+    return res
+  }
+
+  const client = new Client({ name: 'e2e-test', version: '1.0.0' })
+  await client.connect(new StreamableHTTPClientTransport(new URL('http://localhost/api/mcp/workshop'), { fetch: mcpFetch }))
+
+  const tools = await client.listTools()
+  check('tools/list 返回 25 工具(16 基础 + 4 扩展 + 5 设备孪生)', tools.tools.length === 25, `got=${tools.tools.length}`)
+
+  // channel.create + agent.create(lead/worker)→ 拿 token
+  const ch = await client.callTool({ name: 'workshop.channel.create', arguments: { name: 'mcp-channel', leadAgent: { name: 'lead', harness: 'mock', config: { delayMs: 0 } } } })
+  const channelId = JSON.parse((ch.content as { text: string }[])[0].text).channelId as string
+  h.channels.push(channelId)
+  check('MCP channel.create 返回 channelId', typeof channelId === 'string' && channelId.length > 0)
+
+  const w1Tpl = await client.callTool({ name: 'workshop.agent.create', arguments: { name: 'w1', harness: 'mock', config: { delayMs: 0 } } })
+  const tpl = JSON.parse((w1Tpl.content as { text: string }[])[0].text)
+  check('MCP agent.create 返回模板', typeof tpl.id === 'string' && tpl.id.length > 0)
+  const w1 = await client.callTool({ name: 'workshop.agent.add', arguments: { channelId, agentId: tpl.id, role: 'worker' } })
+  const worker1 = JSON.parse((w1.content as { text: string }[])[0].text)
+  check('MCP agent.add 返回实例 token', typeof worker1.token === 'string' && worker1.token.length > 0)
+
+  const lead = (await h.manager.listChannelAgents(channelId)).find(a => a.role === 'lead')!
+  // 带 lead token 的 client(task.list/a2a.send 等 Agent 作业面工具需要认证)
+  const authedClient = new Client({ name: 'e2e-lead', version: '1.0.0' })
+  await authedClient.connect(new StreamableHTTPClientTransport(new URL('http://localhost/api/mcp/workshop'), {
+    fetch: mcpFetch,
+    requestInit: { headers: { Authorization: `Bearer ${lead.token}` } },
+  }))
+  attachScheduler(h.manager, channelId, 10)
+
+  // task.submit → 自动调度闭环(等 COMPLETED)
+  const sub = await client.callTool({ name: 'workshop.task.submit', arguments: { channelId, title: 'MCP 驱动任务' } })
+  const mainTask = JSON.parse((sub.content as { text: string }[])[0].text)
+  check('MCP task.submit 创建任务', typeof mainTask.id === 'string')
+  const done = await waitUntil(async () => {
+    const list = await authedClient.callTool({ name: 'workshop.task.list', arguments: {} })
+    const tasks = JSON.parse((list.content as { text: string }[])[0].text) as { id: string, state: string }[]
+    return tasks.some(t => t.id === mainTask.id && t.state === 'COMPLETED')
+  }, 10_000)
+  check('MCP 驱动任务自动闭环 COMPLETED', done)
+
+  // 无 token → 工具错误(MCP 工具错误以 isError 结果返回,非异常)
+  const anon = new Client({ name: 'anon', version: '1.0.0' })
+  await anon.connect(new StreamableHTTPClientTransport(new URL('http://localhost/api/mcp/workshop'), { fetch: mcpFetch }))
+  const anonRes = await anon.callTool({ name: 'workshop.a2a.send', arguments: { toAgentId: lead.id, parts: [{ text: 'hi' }] } })
+  const anonText = ((anonRes.content as { text: string }[])[0]?.text ?? '')
+  check('MCP 无 token → UNAUTHORIZED', anonRes.isError === true && anonText.includes('UNAUTHORIZED'), anonText.slice(0, 120))
+
+  console.log('\n=== 2. REST API 驱动 ===')
+  const w1Agent = (await h.manager.listChannelAgents(channelId)).find(a => a.name === 'w1')!
+  const token = w1Agent.token!
+  check('REST 作业面 token 有效(findByToken)', h.manager.findByToken(token)?.id === w1Agent.id)
+
+  // 跨 channel 作用域:另一 channel 的 agent 查任务 → SCOPE_VIOLATION
+  const chB = await h.manager.createChannel({ name: 'b-channel' })
+  h.channels.push(chB.channelId)
+  const leadB = await h.manager.addAgentToChannel({ channelId: chB.channelId, agentId: (await h.manager.createAgent({ name: 'leadB', harness: 'mock', config: { delayMs: 0 } })).id, role: 'lead' })
+  let scopeCode = ''
+  try {
+    await h.manager.getTask(chB.channelId, leadB.id, mainTask.id)
+  }
+  catch (e) {
+    scopeCode = (e as { code?: string }).code ?? ''
+  }
+  check('REST 跨 channel 访问 → SCOPE_VIOLATION', scopeCode === 'SCOPE_VIOLATION', scopeCode)
+
+  // a2a.send 投递(caller=worker token;A2AMessage 无 toAgentId 字段,以 messageId+parts 断言)
+  const msg = await h.manager.sendA2A(channelId, w1Agent.id, { toAgentId: lead.id, parts: [{ text: 'REST 消息' }] })
+  check('REST 作业面 a2a.send 投递', msg.messageId.length > 0 && msg.parts.length === 1 && msg.metadata?.['x-aw-target-agent'] === lead.id, JSON.stringify(msg.metadata))
+
+  for (const loop of h.loops) loop.stop()
+  for (const cid of h.channels) await h.manager.removeChannel(cid)
+  h.db.close()
+
+  console.log(`\n${failures === 0 ? 'ALL PASS' : `${failures} FAILED`}`)
+  process.exit(failures === 0 ? 0 : 1)
+}
+
+main().catch((e) => {
+  console.error('双驱动测试异常:', e)
+  process.exit(1)
+})