agentworkshop 0.7.34 → 0.7.37

package/scripts/test-exec-modes.ts

@@ -1,316 +0,0 @@
-/**
- * 执行模式差异验证(mock)— goal / loop / pipeline 三模式核心语义。
- *
- * 语义契约(与 execution-mode.ts 及 lead prompt 同构):
- *  - goal:     lead 接收目标 → dispatch 给 worker → worker 完成 → lead 判定目标是否满足;
- *              不满足 → 继续补充分发(goalRejectRounds 次);满足 → complete 父任务。
- *  - loop:     按 intervalMs 定时循环重放同一任务,达到 maxIterations 后停止(idle)。
- *  - pipeline: 按 stages 严格顺序分阶段执行,阶段 N 完成才启动 N+1;
- *              全部阶段完成后 complete 父任务,随即 idle(不判定 goal、不重放)。
- *
- * 运行: npx tsx scripts/test-exec-modes.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(40)
-  }
-  return false
-}
-
-interface Harness {
-  manager: AgentChannelManager
-  db: ReturnType<typeof openWorkshopDb>
-}
-
-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 })
-  return { manager, db }
-}
-
-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 = 50): void {
-  manager.ensureChannelActive(channelId, { tickMs, stallMs: 60_000 })
-}
-
-async function cleanup(h: Harness): Promise<void> {
-  await h.manager.shutdown()
-  h.db.close()
-}
-
-const ms = (iso: string) => Date.parse(iso)
-
-// ===== GOAL 模式:lead 判定不满足 → 继续分发;满足 → 标记完成 =====
-async function testGoalMode(): Promise<void> {
-  console.log('\n━━━ GOAL 模式:lead 满意度判定驱动补充分发(mock)━━━')
-
-  const h = setup()
-  try {
-    const ch = await h.manager.createChannel({
-      name: 'goal 测试',
-      leadAgent: { name: 'lead-goal', harness: 'mock', config: { delayMs: 20, goalRejectRounds: 2 } },
-    })
-    await h.manager.addAgentToChannel({
-      channelId: ch.channelId,
-      agentId: (await h.manager.createAgent({ name: 'w-goal', harness: 'mock', config: { delayMs: 20 } })).id,
-      role: 'worker',
-    })
-    attachScheduler(h.manager, ch.channelId)
-
-    const engine = getEngine(h.manager)
-    const task = await h.manager.submitChannelTask({
-      channelId: ch.channelId,
-      title: '目标任务',
-      description: '交付完整设计文档',
-      mode: 'goal',
-      modeConfig: { goalCriteria: '设计文档需覆盖 3 项要点' },
-    })
-
-    const done = await waitUntil(() => engine.get(task.id)?.state === 'COMPLETED', 20_000)
-    const root = engine.get(task.id)
-    const children = engine.list(ch.channelId).filter(t => t.parentId === task.id)
-
-    check('goal 模式任务最终 COMPLETED', done && root?.state === 'COMPLETED', `state=${root?.state}`)
-    // lead 判定"未完成"2 次 → 补充分发 2 轮;首轮 + 2 补充 = 3 个子任务
-    check('lead 判断未满足 → 继续分发(子任务数=1+2)', children.length === 3, `子任务数=${children.length}`)
-    check('补充轮次标题正确(第 1/2 轮)', children.some(c => c.title.includes('目标补充第 1 轮')) && children.some(c => c.title.includes('目标补充第 2 轮')))
-    check('全部子任务 COMPLETED', children.every(c => c.state === 'COMPLETED'))
-    // 补充轮严格在上一轮完成后才创建(先判定后分发,不会并行)
-    const ordered = children.length === 3
-      && ms(children[1]!.createdAt) >= ms(children[0]!.updatedAt)
-      && ms(children[2]!.createdAt) >= ms(children[1]!.updatedAt)
-    check('补充分发为顺序判定(上一轮完成才判下一轮)', ordered)
-    check('父任务在最终轮完成后才收口', ms(root!.updatedAt) >= ms(children[2]!.updatedAt))
-    check('goal criteria 编码进 description', root?.description?.includes('[criteria:设计文档需覆盖 3 项要点]') ?? false)
-    // 目标满足判定后的总结性输出约束:lead 必须产出 goal-summary(结论化最终描述)
-    const goalSummary = root!.artifacts.find(a => a.name === 'goal-summary')
-    const summaryText = goalSummary ? goalSummary.parts.map(p => ('text' in p ? p.text : '')).join('\n') : ''
-    check('目标满足后产出 goal-summary 总结 artifact', !!goalSummary)
-    check('goal-summary 含结论化最终描述(标题+结论)', summaryText.includes('【目标完成总结】') && summaryText.includes('结论: 目标已达成'))
-
-    // 对照:goalRejectRounds=0 → lead 一次判定即满足,仅 1 个子任务(不无谓补发)
-    const ch2 = await h.manager.createChannel({
-      name: 'goal 一次通过',
-      leadAgent: { name: 'lead-goal-ok', harness: 'mock', config: { delayMs: 20, goalRejectRounds: 0 } },
-    })
-    await h.manager.addAgentToChannel({
-      channelId: ch2.channelId,
-      agentId: (await h.manager.createAgent({ name: 'w-goal-ok', harness: 'mock', config: { delayMs: 20 } })).id,
-      role: 'worker',
-    })
-    attachScheduler(h.manager, ch2.channelId)
-    const task2 = await h.manager.submitChannelTask({
-      channelId: ch2.channelId,
-      title: '一次通过目标',
-      description: '简单目标',
-      mode: 'goal',
-      modeConfig: { goalCriteria: '完成即可' },
-    })
-    await waitUntil(() => engine.get(task2.id)?.state === 'COMPLETED', 20_000)
-    const children2 = engine.list(ch2.channelId).filter(t => t.parentId === task2.id)
-    check('判定满足时一次分发即完成(子任务数=1)', children2.length === 1, `子任务数=${children2.length}`)
-  }
-  finally {
-    await cleanup(h)
-  }
-}
-
-// ===== PIPELINE 模式:顺序阶段执行,完成后即 idle(不判定 goal、不重放) =====
-async function testPipelineMode(): Promise<void> {
-  console.log('\n━━━ PIPELINE 模式:阶段顺序执行 + 完成后 idle(mock)━━━')
-
-  const h = setup()
-  try {
-    const ch = await h.manager.createChannel({
-      name: 'pipeline 测试',
-      leadAgent: { name: 'lead-pipe', harness: 'mock', config: { delayMs: 20 } },
-    })
-    await h.manager.addAgentToChannel({
-      channelId: ch.channelId,
-      agentId: (await h.manager.createAgent({ name: 'w-pipe', harness: 'mock', config: { delayMs: 20 } })).id,
-      role: 'worker',
-    })
-    attachScheduler(h.manager, ch.channelId)
-
-    const engine = getEngine(h.manager)
-    const task = await h.manager.submitChannelTask({
-      channelId: ch.channelId,
-      title: '流水线任务',
-      description: '分阶段交付',
-      mode: 'pipeline',
-      modeConfig: {
-        stages: [
-          { name: '需求分析', description: '输出需求清单' },
-          { name: '编码实现', description: '按需求落码' },
-          { name: '测试验证', description: '回归通过' },
-        ],
-      },
-    })
-
-    const done = await waitUntil(() => engine.get(task.id)?.state === 'COMPLETED', 20_000)
-    const root = engine.get(task.id)
-    const children = engine.list(ch.channelId).filter(t => t.parentId === task.id)
-      .sort((a, b) => a.createdAt.localeCompare(b.createdAt))
-
-    check('pipeline 主任务 COMPLETED', done && root?.state === 'COMPLETED', `state=${root?.state}`)
-    check('阶段子任务数 = 阶段数(3)', children.length === 3, `子任务数=${children.length}`)
-    check('子任务标题按阶段命名', children[0]?.title.includes('Stage 1: 需求分析') === true
-    && children[1]?.title.includes('Stage 2: 编码实现') === true
-    && children[2]?.title.includes('Stage 3: 测试验证') === true)
-    check('全部阶段子任务 COMPLETED', children.every(c => c.state === 'COMPLETED'))
-    // 严格顺序:阶段 N+1 必须在阶段 N 完成后创建
-    const ordered = children.length === 3
-      && ms(children[1]!.createdAt) >= ms(children[0]!.updatedAt)
-      && ms(children[2]!.createdAt) >= ms(children[1]!.updatedAt)
-    check('阶段顺序:上一阶段完成才启动下一阶段', ordered,
-      `S2创建=${children[1]?.createdAt.slice(17, 23)} vs S1完成=${children[0]?.updatedAt.slice(17, 23)}`)
-    // 上一阶段产出作为下一阶段输入(dispatch parts → 子任务初始 artifact)
-    const stage2Artifacts = children[1]!.artifacts.flatMap(a => a.parts)
-    check('阶段交接:阶段 2 收到上一阶段成果', stage2Artifacts.some(p => 'text' in p && p.text.includes('上一阶段成果')))
-    check('父任务汇总产物存在', (root?.artifacts.length ?? 0) > 0, `artifacts=${root?.artifacts.length}`)
-
-    // 执行结束即 idle:完成后无 goal 判定、无循环重放、无新任务产生
-    const before = engine.list(ch.channelId).length
-    await sleep(800)
-    const after = engine.list(ch.channelId).length
-    const afterRoot = engine.get(task.id)
-    check('执行结束即 idle(800ms 内无新任务/重放)', before === after && afterRoot?.state === 'COMPLETED',
-      `任务数 ${before} → ${after}`)
-  }
-  finally {
-    await cleanup(h)
-  }
-}
-
-// ===== LOOP 模式:定时循环重放,限次后停止 =====
-async function testLoopMode(): Promise<void> {
-  console.log('\n━━━ LOOP 模式:定时循环重放 + maxIterations 停止(mock)━━━')
-
-  const h = setup()
-  try {
-    const ch = await h.manager.createChannel({
-      name: 'loop 测试',
-      leadAgent: { name: 'lead-loop', harness: 'mock', config: { delayMs: 20 } },
-    })
-    await h.manager.addAgentToChannel({
-      channelId: ch.channelId,
-      agentId: (await h.manager.createAgent({ name: 'w-loop', harness: 'mock', config: { delayMs: 20 } })).id,
-      role: 'worker',
-    })
-    attachScheduler(h.manager, ch.channelId, 40)
-
-    const engine = getEngine(h.manager)
-    const title = '循环采集任务'
-    const intervalMs = 350
-    const maxIterations = 3
-    const task = await h.manager.submitChannelTask({
-      channelId: ch.channelId,
-      title,
-      description: '周期采集',
-      mode: 'loop',
-      modeConfig: { intervalMs, maxIterations },
-    })
-
-    // maxIterations=3 → 首轮 + 2 次重放,共 3 个同题任务全部完成
-    const ok = await waitUntil(() => {
-      const rounds = engine.list(ch.channelId).filter(t => t.title === title && !t.parentId)
-      return rounds.length >= maxIterations && rounds.every(t => t.state === 'COMPLETED')
-    }, 20_000)
-
-    const rounds = engine.list(ch.channelId).filter(t => t.title === title && !t.parentId)
-      .sort((a, b) => a.createdAt.localeCompare(b.createdAt))
-
-    check('loop 按限次重放完毕(任务数=maxIterations)', ok && rounds.length === maxIterations, `轮数=${rounds.length}`)
-    check('全部轮次 COMPLETED', rounds.every(t => t.state === 'COMPLETED'))
-    const spaced = rounds.length >= 2
-      && ms(rounds[1]!.createdAt) - ms(rounds[0]!.updatedAt) >= intervalMs - 120
-    check('定时循环:重放间隔 ≥ intervalMs(容差 120ms)',
-      spaced,
-      rounds.length >= 2 ? `实测间隔=${ms(rounds[1]!.createdAt) - ms(rounds[0]!.updatedAt)}ms(要求 ≥ ${intervalMs - 120})` : '轮数不足')
-    const secondSpaced = rounds.length >= 3
-      && ms(rounds[2]!.createdAt) - ms(rounds[1]!.updatedAt) >= intervalMs - 120
-    check('第二轮重放同样遵循间隔', secondSpaced,
-      rounds.length >= 3 ? `实测间隔=${ms(rounds[2]!.createdAt) - ms(rounds[1]!.updatedAt)}ms` : '')
-    // 每轮 = 一次 dispatch → 执行 → complete(无 goal 判定,无多子任务)
-    check('每轮仅 1 个子任务(loop 不判定 goal)', rounds.every(r =>
-      engine.list(ch.channelId).filter(t => t.parentId === r.id).length === 1))
-    check('首轮任务 COMPLETED', engine.get(task.id)?.state === 'COMPLETED')
-
-    // 达到 maxIterations 后停止:再等待 > 一个周期,任务数不再增长
-    const before = rounds.length
-    await sleep(intervalMs + 600)
-    const after = engine.list(ch.channelId).filter(t => t.title === title && !t.parentId).length
-    check('达到 maxIterations 后停止循环(不再重放)', after === before, `轮数 ${before} → ${after}`)
-  }
-  finally {
-    await cleanup(h)
-  }
-}
-
-async function main(): Promise<void> {
-  console.log('╔══════════════════════════════════════════════════════════════╗')
-  console.log('║  执行模式差异验证(mock):goal / pipeline / loop               ║')
-  console.log('╚══════════════════════════════════════════════════════════════╝')
-
-  await testGoalMode()
-  await testPipelineMode()
-  await testLoopMode()
-
-  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-fifo-realtime.mjs

@@ -1,193 +0,0 @@
-/**
- * 队列 FIFO 消费 + 实时信息处理真实监控(omp + glm-5-turbo):
- *  - 团队:lead + 1 worker;goal 任务要求 ONE 轮内向同一 worker 派 3 个微任务
- *    (fifo-a/b/c) → 同时入队,验证 FIFO 顺序消费
- *  - 实时探测:worker 忙于第一个任务时,经 REST 注入 immediate+require_reply 消息
- *    (要求回复附 ACK-773) → 验证注入运行中会话并被处理(回执关联)
- *  - 监控断言:
- *    F1 3 个子任务同 worker 串行完成(busy/idle 序列无重叠)
- *    F2 完成顺序 == 派发顺序(FIFO)
- *    F3 注入消息被消费且回执含 ACK-773(实时注入生效)
- *    F4 父任务 COMPLETED 带总结
- * 运行:node scripts/test-fifo-realtime.mjs
- */
-const BASE = process.env.AW_BASE ?? 'http://127.0.0.1:3101'
-const PROVIDER = 'zhipu-coding-plan'
-const MODEL = 'glm-5-turbo'
-const sleep = ms => new Promise(r => setTimeout(r, ms))
-
-let passed = 0, failures = 0
-const check = (name, ok, detail = '') => {
-  console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` — ${detail}` : ''}`)
-  if (ok) passed += 1
-  else failures += 1
-}
-
-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 main() {
-  // ═══ 组队 ═══
-  const user = await api('POST', '/api/workshop/users/register', { body: { name: `fifo-${Date.now().toString(36)}` } })
-  const token = user.data?.token
-  if (!token) throw new Error('注册失败')
-
-  const ch = await api('POST', '/api/workshop/channels', {
-    body: {
-      name: 'fifo-check',
-      leadAgent: { name: 'fifo-lead', harness: 'omp', config: { provider: PROVIDER, model: MODEL } },
-    },
-    token,
-  })
-  if (ch.code !== 0) throw new Error('channel 创建失败')
-  const channelId = ch.data.channelId
-  const w = await api('POST', `/api/workshop/channels/${channelId}/agents`, {
-    body: { name: 'fifo-worker', harness: 'omp', role: 'worker', config: { provider: PROVIDER, model: MODEL } },
-    token,
-  })
-  if (w.code !== 0) throw new Error('worker 创建失败')
-  const workerId = w.data.id
-  check('团队就绪(lead + 单 worker)', true, `channel=${channelId.slice(0, 8)}`)
-
-  // ═══ goal 任务:一轮派 3 个微任务给同一 worker ═══
-  const task = await api('POST', `/api/workshop/channels/${channelId}/tasks`, {
-    body: {
-      title: 'fifo-consume-check',
-      description: [
-        '[mode:goal][criteria:三个微任务全部完成且交付含各自标记词]',
-        '委派要求:在本轮监督中一次性(dispatch 三次,同一轮)把以下三个微任务全部派给同一个 worker fifo-worker',
-        '(assignee 相同,让它们同时进入其队列,按 FIFO 依次消费):',
-        '- 子任务1 title=fifo-a:description=回复标记词 FFO-A 与一句话结果',
-        '- 子任务2 title=fifo-b:description=回复标记词 FFO-B 与一句话结果',
-        '- 子任务3 title=fifo-c:description=回复标记词 FFO-C 与一句话结果',
-        '全部完成后以总结交付完成父任务(列出三个子任务完成顺序)。',
-      ].join('\n'),
-    },
-    token,
-  })
-  const parentId = task.data?.id
-  if (!parentId) throw new Error('任务提交失败')
-
-  const tasksOf = async () => (await api('GET', `/api/workshop/channels/${channelId}/tasks`, { token })).data ?? []
-  const eventsOf = async () => (await api('GET', `/api/workshop/channels/${channelId}/events?limit=800`, { token })).data?.items ?? []
-
-  // ═══ 监控循环:事件流采集 + 忙时注入实时消息 ═══
-  let injected = null
-  let busyAtInject = false
-  const busySeq = []
-  const seenEvents = new Set()
-  const completionOrder = []
-  const deadline = Date.now() + 600_000
-  let parentState = ''
-  while (Date.now() < deadline) {
-    const evs = await eventsOf()
-    for (const e of evs) {
-      if (seenEvents.has(e.seq)) continue
-      seenEvents.add(e.seq)
-      const p = e.payload ?? {}
-      // worker 状态序列
-      if (e.type === 'agent.status' && e.agentId === workerId && (p.state === 'busy' || p.state === 'idle')) {
-        busySeq.push(p.state)
-      }
-      // 子任务完成顺序
-      if (e.type === 'task.status' && p.state === 'COMPLETED' && p.taskId && p.taskId !== parentId) {
-        if (!completionOrder.includes(p.taskId)) completionOrder.push(p.taskId)
-      }
-    }
-    // 忙时注入一次实时消息(要求回执 ACK-773)
-    if (!injected && busySeq.includes('busy')) {
-      busyAtInject = true
-      const res = await api('POST', `/api/workshop/channels/${channelId}/messages`, {
-        body: {
-          toAgentId: workerId,
-          text: '[实时检查] 收到请在你当前或下一个交付中确认,并立即用 send_message_to_agent 回复本消息(附 ACK-773)。',
-          priority: 'immediate',
-          requireReply: true,
-        },
-        token,
-      })
-      if (res.data?.messageId || res.messageId) injected = res.data?.messageId ?? res.messageId
-    }
-    const st = (await tasksOf()).find(t => t.id === parentId)?.state ?? ''
-    if (['COMPLETED', 'FAILED', 'CANCELED'].includes(st)) {
-      parentState = st
-      break
-    }
-    await sleep(4000)
-  }
-  // 宽限
-  if (!parentState) {
-    for (let i = 0; i < 12; i++) {
-      const st = (await tasksOf()).find(t => t.id === parentId)?.state ?? ''
-      if (['COMPLETED', 'FAILED', 'CANCELED'].includes(st)) {
-        parentState = st
-        break
-      }
-      await sleep(5000)
-    }
-  }
-
-  // ═══ 断言 ═══
-  const tasks = await tasksOf()
-  const children = tasks.filter(t => t.parentId === parentId).sort((a, b) => a.createdAt < b.createdAt ? -1 : 1)
-  check('F4a goal 父任务完成', parentState === 'COMPLETED', `state=${parentState}`)
-  check('F1a 子任务(≥3)全部完成', children.length >= 3 && children.every(c => c.state === 'COMPLETED'), `n=${children.length}, states=${children.map(c => c.state).join('/')}`)
-
-  // FIFO:完成顺序 == 创建顺序
-  const createOrder = children.map(c => c.id)
-  const fifoOk = completionOrder.length >= 3 && createOrder.every((id, i) => {
-    const idx = completionOrder.indexOf(id)
-    return idx >= 0 && idx === i
-  })
-  check('F2 完成顺序 == 派发顺序(FIFO 消费)', fifoOk, `create=[${createOrder.map(i => i.slice(0, 6)).join(',')}] done=[${completionOrder.map(i => i.slice(0, 6)).join(',')}]`)
-
-  // 串行:busy/idle 无重叠(busy 后必须 idle 才可再 busy)
-  let serial = true
-  for (let i = 1; i < busySeq.length; i++) {
-    if (busySeq[i] === busySeq[i - 1]) serial = false
-  }
-  check('F1b 串行消费(busy/idle 交替无重叠)', serial && busySeq.filter(s => s === 'busy').length >= 3, `seq=${busySeq.join('→').slice(0, 60)}`)
-
-  // 标记词交付
-  // 标记词交付(按 title 精确匹配,容错 includes)
-  const marks = ['FFO-A', 'FFO-B', 'FFO-C']
-  const titleKeys = ['fifo-a', 'fifo-b', 'fifo-c']
-  const markOk = marks.every((m, i) => {
-    const child = children.find(c => c.title === titleKeys[i]) ?? children.find(c => (c.title ?? '').includes(titleKeys[i]))
-    return child && JSON.stringify(child.artifacts ?? '').includes(m)
-  })
-  check('F1c 子任务交付含各自标记词', markOk, '')
-
-  // ═══ 实时注入断言 ═══
-  const mails = (await api('GET', `/api/workshop/channels/${channelId}/messages?limit=400`, { token })).data ?? []
-  const injectedRow = injected ? mails.find(m => m.id === injected) : null
-  // 硬断言:worker busy 期间注入 → 实时送达(steer 进会话)且被消费(送达即消费/读即取)
-  check('F3a 实时注入送达且消费(busy 期间 steer 进会话)', !!injectedRow && injectedRow.state === 'consumed' && busyAtInject, `state=${injectedRow?.state ?? 'n/a'}, busyAtInject=${busyAtInject}`)
-  // 软观察:模型是否按触发器回执 ACK(LLM 合规性,不计分)
-  const ackReply = mails.find(m => m.fromAgentId === workerId
-    && String(JSON.stringify(m.metadata ?? {})).includes(String(injected))
-    && (m.parts ?? []).some(p => String(p.text ?? '').includes('ACK-773')))
-  console.log(`  [obs] ACK-773 回执(软观察): ${ackReply ? '已回执且关联' : '模型未回执(管道已送达;LLM 合规性波动)'}`)
-
-  const parent = tasks.find(t => t.id === parentId)
-  check('F4b 结语总结含顺序', (parent?.artifacts?.length ?? 0) > 0, JSON.stringify(parent?.artifacts ?? '').slice(0, 80))
-
-  // 清理
-  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(() => {})
-  }
-  if (failures === 0) await api('DELETE', `/api/workshop/channels/${channelId}`, { token }).catch(() => {})
-
-  console.log(`\n★ 结果: ${passed} passed, ${failures} failed`)
-  process.exit(failures === 0 ? 0 : 1)
-}
-
-main().catch((err) => {
-  console.error('e2e 异常:', err.message)
-  process.exit(1)
-})