agentworkshop 0.7.34 → 0.7.37

package/scripts/test-memory-brief-chronicle.ts

@@ -1,180 +0,0 @@
-/**
- * 记忆持久化面测试:L0 会话简报 / 压缩摘要入库 / 团队编年史 / 维护豁免与淘汰 /
- * manager 任务终态事件 → 团队域沉淀总线接线。
- * 运行: npx tsx --tsconfig .nuxt/tsconfig.server.json scripts/test-memory-brief-chronicle.ts
- */
-import type { DatabaseSync } from 'node:sqlite'
-import { openWorkshopDb } from '../server/services/workshop/db/database'
-import { createMemoryRepo, TEAM_AGENT_ID } from '../server/services/workshop/db/memory.repo'
-import { AgentMemory, runMemoryMaintenance, unsegmentCJK } from '../server/services/workshop/runtime/memory'
-import type { AgentInterface } from '../server/services/workshop/agents/agent-interface'
-import { createChannelRepo } from '../server/services/workshop/db/channel.repo'
-import { createAgentRepo } from '../server/services/workshop/db/agent.repo'
-import { createTeamRepo } from '../server/services/workshop/db/team.repo'
-import { createTeamMemberRepo } from '../server/services/workshop/db/team-member.repo'
-import { createChannelAgentRepo } from '../server/services/workshop/db/channel-agent.repo'
-import { createMessageRepo } from '../server/services/workshop/db/message.repo'
-import { createTaskRepo } from '../server/services/workshop/db/task.repo'
-import { createSubscriptionRepo } from '../server/services/workshop/db/subscription.repo'
-import { createAgentChannelManager } from '../server/services/workshop/runtime/manager'
-
-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): Promise<void> => new Promise(r => setTimeout(r, ms))
-
-const db: DatabaseSync = openWorkshopDb(':memory:')
-const repo = createMemoryRepo(db)
-const seg = (s: string): string => s.replace(/([\u4e00-\u9fff])/g, ' $1 ')
-
-// ===== L0 会话简报:recordTaskOutcome / save(shared) 自动刷新,幂等单行 =====
-console.log('\n--- L0 会话简报(brief)---')
-{
-  const mem = new AgentMemory(repo, { channelId: 'ch1', agentId: 'w1' })
-  check('无完成记录时不产简报', repo.findByAgentDedup('ch1', 'w1', 'brief:w1') === null)
-  await mem.recordTaskOutcome({
-    id: 'tk1', channelId: 'ch1', assigneeId: 'w1', creatorId: 'lead', title: '网关配置任务',
-    state: 'COMPLETED', progress: 100, retryCount: 0,
-    artifacts: [{ artifactId: 'a1', name: 'deliverable', parts: [{ text: '网关路由表已生效' }] }],
-    history: [], createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
-  } as Parameters<AgentMemory['recordTaskOutcome']>[0])
-  let brief = repo.findByAgentDedup('ch1', 'w1', 'brief:w1')
-  check('任务终态后简报生成', brief !== null)
-  check('简报含最近完成条目', brief !== null && unsegmentCJK(repo.getById(brief.id)!.content).includes('网关配置任务'))
-  check('简报为单行幂等(brief kind)', repo.listByAgentChannel('ch1', 'w1', 100).filter(r => r.kind === 'brief').length === 1)
-
-  await mem.save({ title: '限流约定', content: '全队统一令牌桶', scope: 'shared', dedupKey: 'conv:rl' })
-  brief = repo.findByAgentDedup('ch1', 'w1', 'brief:w1')
-  check('共享沉淀后简报含团队约定', brief !== null && unsegmentCJK(repo.getById(brief.id)!.content).includes('限流约定'))
-
-  // recall L0 置顶
-  const block = await mem.recall('任意查询')
-  check('recall 注入块含会话简报', block !== null && block.includes('会话简报'))
-}
-
-// ===== 压缩摘要入库:episodic-session,序号 dedupKey,可检索 =====
-console.log('\n--- 压缩摘要(episodic-session)---')
-{
-  const mem = new AgentMemory(repo, { channelId: 'ch1', agentId: 'w1' })
-  const s1 = await mem.recordSessionCompaction({ summary: '完成网关配置;待办:验证路由', tokensBefore: 90000, tokensAfter: 30000, reason: 'threshold' })
-  const s2 = await mem.recordSessionCompaction({ summary: '第二次压缩摘要', tokensBefore: 88000 })
-  check('dedupKey 序号递增不互踩', s1.dedupKey !== s2.dedupKey && repo.findByAgentDedup('ch1', 'w1', s1.dedupKey) !== null && repo.findByAgentDedup('ch1', 'w1', s2.dedupKey) !== null)
-  const found = await mem.recallRows('网关配置 验证路由')
-  check('压缩摘要可被 search_memory 检索', found.some(s => s.kind === 'episodic-session'), JSON.stringify(found.map(s => s.kind)))
-  const row = repo.listByAgentChannel('ch1', 'w1', 100).find(r => r.kind === 'episodic-session')
-  check('importance=0.75 元信息入库', row !== null && row.importance === 0.75)
-}
-
-// ===== 团队编年史:滚动重写幂等单行 =====
-console.log('\n--- 团队编年史(chronicle)---')
-{
-  const mem = new AgentMemory(repo, { channelId: 'ch1', agentId: TEAM_AGENT_ID })
-  mem.upsertChronicle(['09-02 10:00 [完成] 任务A — w1(交付 x)', '09-02 11:00 [失败] 任务B — w2'].join('\n'))
-  mem.upsertChronicle(['09-02 12:00 [完成] 任务C — w3'].join('\n'))
-  const rows = repo.listByAgentChannel('ch1', TEAM_AGENT_ID, 100).filter(r => r.kind === 'chronicle')
-  check('编年史幂等单行(重写不新增)', rows.length === 1)
-  const chron = rows[0] !== undefined ? unsegmentCJK(rows[0]!.content) : ''
-  check('编年史内容为最新滚动', chron.includes('w3') && !chron.includes('任务 A'), chron)
-}
-
-// ===== 维护:session 14d 过期 / 策展层豁免 / team-task 淘汰 =====
-console.log('\n--- 维护规则 v2 ---')
-{
-  const old = new Date(Date.now() - 20 * 86_400_000).toISOString()
-  repo.upsert({ channelId: 'ch1', agentId: 'w1', kind: 'episodic-session', title: '旧压缩摘要', titleFts: seg('旧压缩摘要'), content: seg('过期内容'), importance: 0.75, taskId: null, dedupKey: 'session:w1:c99' })
-  db.prepare('UPDATE agent_memories SET created_at = ? WHERE dedup_key = ?').run(old, 'session:w1:c99')
-
-  const res = runMemoryMaintenance(repo, { expireDays: 180, cap: 500 })
-  check('episodic-session 14d 过期删除', res.deletedExpired >= 1 && repo.findByAgentDedup('ch1', 'w1', 'session:w1:c99') === null, JSON.stringify(res))
-  check('brief 豁免保留', repo.findByAgentDedup('ch1', 'w1', 'brief:w1') !== null)
-  check('chronicle 豁免保留', repo.listByAgentChannel('ch1', TEAM_AGENT_ID, 100).some(r => r.kind === 'chronicle'))
-
-  // team-task 容量淘汰(cap=2 时仅保留 2 行)
-  for (let i = 0; i < 4; i++) {
-    repo.upsert({ channelId: 'ch1', agentId: TEAM_AGENT_ID, kind: 'episodic-team-task', title: `团队任务${i}`, titleFts: seg(`团队任务${i}`), content: seg('成果'), importance: i < 2 ? 0.9 : 0.5, taskId: `tt-${i}`, dedupKey: `team-task:tt-${i}` })
-  }
-  runMemoryMaintenance(repo, { expireDays: 180, cap: 2 })
-  const remaining = repo.listByAgentChannel('ch1', TEAM_AGENT_ID, 100).filter(r => r.kind === 'episodic-team-task')
-  check('team episodic 纳入容量淘汰(高分保留)', remaining.length === 2 && remaining.every(r => r.importance === 0.9), `left=${remaining.length}`)
-}
-
-// ===== manager 总线接线:任务终态 → team-task 行 + 编年史(单点不双写)=====
-console.log('\n--- manager 任务终态团队沉淀 ---')
-{
-  const tmRepos = {
-    channels: createChannelRepo(db),
-    agents: createAgentRepo(db),
-    teams: createTeamRepo(db),
-    teamMembers: createTeamMemberRepo(db),
-    channelAgents: createChannelAgentRepo(db),
-    messages: createMessageRepo(db),
-    subscriptions: createSubscriptionRepo(db),
-    tasks: createTaskRepo(db),
-    memories: repo,
-  }
-  // 空转 impl:run 即返回(lead 自派任务的回合立即落定,不产错误)
-  const stubImpl = (): AgentInterface => ({ async* run() {} })
-  const manager = createAgentChannelManager({ repos: tmRepos, implFactory: stubImpl, db })
-  const ch = tmRepos.channels.create({ name: 'ch-harvest' })
-  const lead = tmRepos.channelAgents.create({ channelId: ch.id, templateId: null, name: 'lead-h', harness: 'mock', role: 'lead' })
-  // 激活 channel runtime(创建 bus + 注册团队沉淀监听)
-  manager.subscribeTaskEvents(ch.id, () => {})
-
-  const task = await manager.dispatchTask(ch.id, lead.id, { assigneeId: lead.id, title: '数据迁移执行', description: '迁移并验证' })
-  await sleep(30)
-  await manager.completeTask(ch.id, lead.id, {
-    taskId: task.id,
-    artifacts: [{ artifactId: 'd1', name: 'deliverable', parts: [{ text: '迁移完成,校验和一致' }] }],
-  })
-  await sleep(30)
-
-  const teamRow = repo.findByAgentDedup(ch.id, TEAM_AGENT_ID, `team-task:${task.id}`)
-  check('任务完成 → team-task 共享行入库', teamRow !== null)
-  const teamRows = repo.listByAgentChannel(ch.id, TEAM_AGENT_ID, 100).filter(r => r.kind === 'episodic-team-task')
-  check('团队域单点写入(无双写)', teamRows.length === 1, `rows=${teamRows.length}`)
-  check('交付物进入共享行内容', teamRow !== null && unsegmentCJK(repo.getById(teamRow.id)!.content).includes('校验和一致'))
-  const chronicle = repo.listByAgentChannel(ch.id, TEAM_AGENT_ID, 100).find(r => r.kind === 'chronicle')
-  check('编年史随任务终态滚动更新', chronicle !== undefined && unsegmentCJK(repo.getById(chronicle.id)!.content).includes('数据迁移执行'))
-  await manager.shutdown()
-}
-
-// ===== 空闲反思:当月 episodic-task ≥ 阈值 → reflection 行聚合(月度幂等)=====
-console.log('\n--- 空闲反思(reflection)---')
-{
-  const month = new Date().toISOString().slice(0, 7)
-  for (let i = 0; i < 8; i++) {
-    repo.upsert({ channelId: 'ch1', agentId: 'rx', kind: 'episodic-task', title: `反思任务${i}`, titleFts: seg(`反思任务${i}`), content: seg('结论性内容'), importance: 0.8, taskId: `rx-${i}`, dedupKey: `task:rx-${i}` })
-  }
-  const stubImpl = (): AgentInterface => ({ async* run() {} })
-  const m2 = createAgentChannelManager({
-    repos: {
-      channels: createChannelRepo(db),
-      agents: createAgentRepo(db),
-      teams: createTeamRepo(db),
-      teamMembers: createTeamMemberRepo(db),
-      channelAgents: createChannelAgentRepo(db),
-      messages: createMessageRepo(db),
-      subscriptions: createSubscriptionRepo(db),
-      tasks: createTaskRepo(db),
-      memories: repo,
-    },
-    implFactory: stubImpl,
-    db,
-  })
-  ;(m2 as unknown as Record<string, () => void>).reflectIdleMemories()
-  const reflRef = repo.findByAgentDedup('ch1', 'rx', `reflection:rx:${month}`)
-  const refl = reflRef ? repo.getById(reflRef.id) : null
-  check('反思行入库(月度 dedupKey)', refl !== null)
-  check('反思行聚合任务结论', refl !== null && unsegmentCJK(refl.content).includes('反思任务'))
-
-  // 再跑一轮:无新增任务 → 不重复聚合(内容不变,幂等)
-  ;(m2 as unknown as Record<string, () => void>).reflectIdleMemories()
-  const reflCount = repo.listByAgentChannel('ch1', 'rx', 100).filter(r => r.kind === 'reflection').length
-  check('反思月度幂等(无增量不再重写)', reflCount === 1)
-  await m2.shutdown()
-}
-
-console.log(failures === 0 ? '\nALL PASS' : `\n${failures} FAILED`)
-process.exit(failures === 0 ? 0 : 1)

package/scripts/test-memory-rrf-mmr.ts

@@ -1,114 +0,0 @@
-/**
- * 记忆检索 v2 算法测试:RRF 融合 / MMR 多样性 / kind 感知半衰期 / 任务关联加权 / 策展层排除。
- * 运行: npx tsx --tsconfig .nuxt/tsconfig.server.json scripts/test-memory-rrf-mmr.ts
- */
-import type { DatabaseSync } from 'node:sqlite'
-import { openWorkshopDb } from '../server/services/workshop/db/database'
-import { createMemoryRepo, TEAM_AGENT_ID } from '../server/services/workshop/db/memory.repo'
-import { AgentMemory, buildMatchQuery, estimateTokens } from '../server/services/workshop/runtime/memory'
-
-let failures = 0
-function check(name: string, ok: boolean, detail = ''): void {
-  console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` — ${detail}` : ''}`)
-  if (!ok) failures += 1
-}
-
-const db: DatabaseSync = openWorkshopDb(':memory:')
-const repo = createMemoryRepo(db)
-const seg = (s: string): string => s.replace(/([\u4e00-\u9fff])/g, ' $1 ')
-
-// ===== buildMatchQuery:CJK 词项扩容 + 去重 =====
-console.log('\n--- buildMatchQuery(CJK 词项扩容)---')
-{
-  const q = buildMatchQuery('网关限流方案讨论,部署脚本与令牌桶阈值约定')
-  const termCount = q ? q.split(' OR ').length : 0
-  check('CJK 单字词项上限提升(>12)', termCount > 12, `terms=${termCount}`)
-  const deduped = buildMatchQuery('限流 限流 限流')
-  check('词项去重', deduped !== null && deduped.split(' OR ').length === 2, `terms=${deduped}`) // 限/流
-  check('token 估算为正', estimateTokens('abc 中文') > 0)
-}
-
-// ===== RRF 融合:FTS+向量双榜融合(词袋 embedder)=====
-console.log('\n--- RRF 融合(混合检索)---')
-{
-  // hash 词袋 provider:同词集 → 相近向量(零网络)
-  const { createHashEmbeddingProvider } = await import('../server/services/workshop/runtime/embedding-provider')
-  const embedder = createHashEmbeddingProvider(64)
-
-  const rows = [
-    { dedup: 'task:a', title: 'Redis 缓存穿透方案', content: '布隆过滤器前置拦截,空值缓存五分钟' },
-    { dedup: 'task:b', title: 'Redis 雪崩预案', content: '过期时间加随机抖动,多级缓存兜底' },
-    { dedup: 'task:c', title: '部署脚本清单', content: 'docker compose 拉镜像,健康检查后切流量' },
-  ]
-  for (const r of rows) {
-    repo.upsert({ channelId: 'ch1', agentId: 'a1', kind: 'episodic-task', title: r.title, titleFts: seg(r.title), content: seg(r.content), importance: 0.8, taskId: r.dedup, dedupKey: `task:${r.dedup}` })
-  }
-  const mem = new AgentMemory(repo, { channelId: 'ch1', agentId: 'a1', embedder })
-  // 向量可命中(词袋相似)但 FTS 无词面匹配的查询:RRF 仍能通过向量榜给出结果
-  const hits = await mem.recallRows('cache 穿透 拦截')
-  check('向量榜独有命中可达(RRF 不丢向量结果)', hits.some(s => s.title === 'Redis 缓存穿透方案'), JSON.stringify(hits.map(s => s.title)))
-
-  // 双榜同时命中:融合排序应把两榜都命中的排前
-  const both = await mem.recallRows('Redis 雪崩')
-  check('双榜命中排序靠前', both.length > 0 && both[0]!.title === 'Redis 雪崩预案', JSON.stringify(both.map(s => `${s.title}:${s.score}`)))
-}
-
-// ===== kind 感知半衰期:semantic 不衰减,episodic-task 14d =====
-console.log('\n--- kind 感知半衰期 ---')
-{
-  const old = new Date(Date.now() - 60 * 86_400_000).toISOString()
-  repo.upsert({ channelId: 'ch1', agentId: 'old1', kind: 'semantic', title: '六十天前的架构决策', titleFts: seg('六十天前的架构决策'), content: seg('内核结论:单写多读'), importance: 0.9, taskId: null, dedupKey: 'manual:old-sem' })
-  repo.upsert({ channelId: 'ch1', agentId: 'old1', kind: 'episodic-task', title: '六十天前的任务', titleFts: seg('六十天前的任务'), content: seg('过程性记录,内容已过时'), importance: 0.9, taskId: 't-old', dedupKey: 'task:t-old' })
-  // 直接改 created_at 模拟老化(upsert ON CONFLICT 会刷新,故用参数化 UPDATE)
-  db.prepare('UPDATE agent_memories SET created_at = ? WHERE agent_id = ?').run(old, 'old1')
-
-  const mem = new AgentMemory(repo, { channelId: 'ch1', agentId: 'old1' })
-  const hits = await mem.recallRows('六十天前')
-  const sem = hits.find(s => s.title === '六十天前的架构决策')
-  const epi = hits.find(s => s.title === '六十天前的任务')
-  check('semantic 知识不随时近衰减(分高于 episodic)', sem !== undefined && epi !== undefined && sem.score > epi.score, `sem=${sem?.score} epi=${epi?.score}`)
-}
-
-// ===== 任务关联加权:兄弟/父任务记忆置顶 =====
-console.log('\n--- 任务关联加权(related-task boost)---')
-{
-  repo.upsert({ channelId: 'ch1', agentId: 'rel', kind: 'episodic-task', title: '无关旧任务', titleFts: seg('无关旧任务'), content: seg('数据库迁移完成,版本升到 v14'), importance: 0.8, taskId: 't-other', dedupKey: 'task:t-other' })
-  repo.upsert({ channelId: 'ch1', agentId: 'rel', kind: 'episodic-task', title: '兄弟任务结论', titleFts: seg('兄弟任务结论'), content: seg('API 网关路由表已生成'), importance: 0.55, taskId: 't-sib1', dedupKey: 'task:t-sib1' })
-  const mem = new AgentMemory(repo, { channelId: 'ch1', agentId: 'rel' })
-  // 查询词面同时弱命中两行;兄弟任务 id 加权后必须反超高重要度旧行
-  const hits = await mem.recallRows('任务 结论 数据库 网关', { relatedTaskIds: ['t-sib1', 't-parent'] })
-  check('兄弟任务记忆加权反超(置顶)', hits[0]?.title === '兄弟任务结论', JSON.stringify(hits.map(s => `${s.title}:${s.score}`)))
-  const hitsNoRel = await mem.recallRows('任务 结论 数据库 网关', { touch: false })
-  check('无关联集时高重要度旧行居前(对照)', hitsNoRel[0]?.title === '无关旧任务', JSON.stringify(hitsNoRel.map(s => `${s.title}:${s.score}`)))
-}
-
-// ===== 策展层:brief 走 L0 置顶,L1 引子不重复;chronicle 不进 L1 但 L2 可检索 =====
-console.log('\n--- 策展层(L0/L1/L2 分层)---')
-{
-  const mem = new AgentMemory(repo, { channelId: 'ch1', agentId: 'cur' })
-  await mem.save({ title: '普通结论', content: '普通检索应该能命中', scope: 'private', dedupKey: 'note:normal' })
-  mem.repo.upsert({ channelId: 'ch1', agentId: 'cur', kind: 'brief', title: '会话简报', titleFts: seg('会话简报'), content: seg('最近完成:普通结论'), importance: 0.6, taskId: null, dedupKey: 'brief:cur' })
-  mem.repo.upsert({ channelId: 'ch1', agentId: 'cur', kind: 'chronicle', title: '团队编年史', titleFts: seg('团队编年史'), content: seg('完成 普通结论'), importance: 0.9, taskId: null, dedupKey: 'chronicle:ch1' })
-
-  // L1(recall):brief 经 L0 路径恰好注入一次(去重靠 excludeCurated);chronicle 不进 L1
-  const primer = await mem.recall('普通')
-  const briefHits = (primer?.match(/会话简报/g) ?? []).length
-  check('brief 恰好注入一次(L0 路径)', briefHits === 1, `hits=${briefHits}`)
-  check('L1 引子不含 chronicle(防双份注入)', primer !== null && !primer.includes('编年史'))
-
-  // L2(search_memory/recallRows):策展层可被检索(特性)
-  const found = await mem.recallRows('编年史')
-  check('L2 search_memory 可命中 chronicle', found.some(s => s.title === '团队编年史'), JSON.stringify(found.map(s => s.title)))
-}
-
-// ===== team 域可见性:episodic-team-task 对全员 shared 可检索 =====
-console.log('\n--- team-task 共享域 ---')
-{
-  repo.upsert({ channelId: 'ch1', agentId: TEAM_AGENT_ID, kind: 'episodic-team-task', title: '团队任务成果', titleFts: seg('团队任务成果'), content: seg('数据迁移已全部完成并验证'), importance: 0.8, taskId: 't-team', dedupKey: 'team-task:t-team' })
-  const memB = new AgentMemory(repo, { channelId: 'ch1', agentId: 'member-b' })
-  const seen = await memB.recallRows('数据迁移', { scope: 'shared' })
-  check('其他成员 shared 域可命中 team-task 行', seen.some(s => s.title === '团队任务成果'), JSON.stringify(seen.map(s => s.title)))
-}
-
-console.log(failures === 0 ? '\nALL PASS' : `\n${failures} FAILED`)
-process.exit(failures === 0 ? 0 : 1)

package/scripts/test-mock-collab.mjs

@@ -1,226 +0,0 @@
-// -*- coding: utf-8 -*-
-// 多 Agent 实时通信 + FIFO 执行 E2E(mock harness;node scripts/test-mock-collab.mjs)
-//
-// 隔离环境:新建专属 channel(mock lead + 2 名 mock worker),跑完即删。
-// 覆盖:
-//  T1 任务 FIFO 逐条执行 —— HITL 直发 3 个任务给同一 worker:
-//     完成顺序 === 提交顺序;执行严格串行(同一 worker 任意时刻至多 1 个 WORKING);
-//     每任务走完 WORKING→COMPLETED(progress 25/50/75→artifact)。
-//  T2 消息逐条处理 + 逐条回执 —— agent→agent 连发 8 条 requireReply 消息
-//     (含同毫秒突发):每条恰好一条回执(in_reply_to 一一对应),
-//     回执顺序 === 发送顺序(FIFO;rowid 决胜回归)。
-//  T3 实时消息按需获取即时性 —— idle worker 收 immediate 消息:
-//     发送→回执到达时延 < 5s(mailbox 到信唤醒 + 消费循环即时接单)。
-//  T4 lead 调度闭环 —— 常规任务(无 @,默认路由 lead):lead 派发子任务 →
-//     worker 完成 → lead 汇总 → 父任务 COMPLETED(多 Agent 协同全链路)。
-import { env } from 'node:process'
-
-const BASE = env.AW_BASE ?? 'http://127.0.0.1:3002'
-const TOKEN = env.AW_TOKEN ?? 'ut-636e563104b844b591de8aadf6071aea'
-
-let failures = 0
-const check = (name, ok, detail = '') => {
-  console.log(`${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` — ${detail}` : ''}`)
-  if (!ok) failures += 1
-}
-const sleep = ms => new Promise(r => setTimeout(r, ms))
-
-async function api(method, path, body) {
-  const res = await fetch(BASE + path, {
-    method,
-    headers: { 'authorization': `Bearer ${TOKEN}`, 'content-type': 'application/json' },
-    body: body ? JSON.stringify(body) : undefined,
-  })
-  const d = await res.json().catch(() => ({}))
-  if (d && typeof d === 'object' && 'code' in d && d.code !== 0 && d.code !== 'ok') {
-    throw new Error(`${method} ${path} -> ${JSON.stringify(d).slice(0, 220)}`)
-  }
-  return d?.data ?? d
-}
-
-/** 轮询直到谓词命中(返回谓词结果)或超时 */
-async function pollUntil(fn, timeoutMs, label) {
-  const t0 = Date.now()
-  for (;;) {
-    const v = await fn().catch(() => null)
-    if (v) return { ok: true, value: v, elapsed: Date.now() - t0 }
-    if (Date.now() - t0 > timeoutMs) return { ok: false, value: null, elapsed: Date.now() - t0, label }
-    await sleep(300)
-  }
-}
-
-/** channel 事件流(按 seq 升序;用于重建时序) */
-async function events(cid, limit = 500) {
-  const d = await api('GET', `/api/workshop/channels/${cid}/events?limit=${limit}`)
-  return d.items ?? []
-}
-
-/** channel 全量消息行(含回执;按 createdAt 升序) */
-async function messages(cid, limit = 400) {
-  const rows = await api('GET', `/api/workshop/channels/${cid}/messages?limit=${limit}`)
-  return Array.isArray(rows) ? rows.slice().sort((a, b) => a.createdAt < b.createdAt ? -1 : a.createdAt > b.createdAt ? 1 : 0) : []
-}
-
-async function main() {
-  // ---- 环境装配:专属 channel + mock lead + 2 mock worker ----
-  const stamp = Date.now().toString(36)
-  const created = await api('POST', '/api/workshop/channels', {
-    name: `fifo-e2e-${stamp}`,
-    description: 'FIFO/实时通信 E2E(自动创建,跑完即删)',
-    leadAgent: { name: 'e2e-lead', harness: 'mock', config: { delayMs: 100 } },
-  })
-  const cid = created.channelId
-  const leadId = created.leadAgentId
-  console.log(`channel=${cid.slice(0, 8)} lead=${leadId.slice(0, 8)}`)
-  try {
-    const w1 = (await api('POST', `/api/workshop/channels/${cid}/agents`, { name: 'e2e-worker-1', harness: 'mock', config: { delayMs: 350 } })).id
-    const w2 = (await api('POST', `/api/workshop/channels/${cid}/agents`, { name: 'e2e-worker-2', harness: 'mock', config: { delayMs: 120 } })).id
-    console.log(`workers: w1=${w1.slice(0, 8)} w2=${w2.slice(0, 8)}`)
-
-    // ================= T1:任务 FIFO 逐条执行 =================
-    console.log('\n--- T1:任务 FIFO 逐条执行(HITL 直发 ×3 → 同一 worker) ---')
-    const markers = ['FIFO-A', 'FIFO-B', 'FIFO-C']
-    const t1 = []
-    for (const m of markers) {
-      // 顺序提交(每个 POST 落库后再发下一个):入队顺序确定 → 完成顺序必须一致
-      const t = await api('POST', `/api/workshop/channels/${cid}/tasks`, {
-        title: `${m} 顺序验证`,
-        description: `${m}:按提交顺序逐条执行`,
-        assigneeId: w1,
-        parts: [{ text: `${m} body` }],
-      })
-      t1.push({ id: t.id, m })
-    }
-    const idByMarker = new Map(t1.map(x => [x.id, x.m]))
-    const allDone = await pollUntil(async () => {
-      const tasks = await api('GET', `/api/workshop/channels/${cid}/tasks`)
-      return t1.every(x => tasks.find(t => t.id === x.id)?.state === 'COMPLETED') || null
-    }, 30_000, 'T1 全部完成')
-    check('T1 三个任务全部 COMPLETED', allDone.ok, `${allDone.elapsed}ms`)
-
-    // 时序重建:task.status 事件按 seq → 完成顺序 + 串行性
-    {
-      const evs = (await events(cid)).filter(e => e.type === 'task.status')
-        .map(e => ({ seq: e.seq, taskId: e.payload?.taskId, state: e.payload?.state }))
-        .filter(x => idByMarker.has(x.taskId))
-      const completionOrder = evs.filter(x => x.state === 'COMPLETED').map(x => idByMarker.get(x.taskId))
-      check('T1 完成顺序 === 提交顺序(A→B→C)', completionOrder.join(',') === markers.join(','), completionOrder.join(','))
-      // 串行:WORKING 区间不重叠 —— WORKING(x) 出现时,前一任务必须已 COMPLETED
-      let prevOpen = null
-      let serial = true
-      for (const x of evs) {
-        if (x.state === 'WORKING') {
-          if (prevOpen) {
-            serial = false
-            break
-          }
-          prevOpen = x.taskId
-        }
-        if (x.state === 'COMPLETED' && prevOpen === x.taskId) prevOpen = null
-      }
-      check('T1 同一 worker 任意时刻至多 1 个任务在执行(严格串行)', serial)
-      // 每任务走过 WORKING
-      for (const x of t1) {
-        check(`T1 ${idByMarker.get(x.id)} 经 WORKING 转移`, evs.some(e => e.taskId === x.id && e.state === 'WORKING'))
-      }
-    }
-
-    // ================= T2:消息逐条处理 + 逐条回执(FIFO) =================
-    console.log('\n--- T2:消息逐条处理 + 逐条回执(连发 8 条 requireReply) ---')
-    const N = 8
-    const sent = []
-    for (let i = 1; i <= N; i++) {
-      // 同步连发(近同毫秒突发;验证 rowid 决胜 FIFO)
-      sent.push(api('POST', `/api/workshop/channels/${cid}/messages`, {
-        toAgentId: w2, fromAgentId: leadId,
-        text: `逐条消息 ${i}/${N}`,
-        priority: 'immediate', requireReply: true,
-      }).then(r => ({ id: r.messageId, i })))
-    }
-    const sentMsgs = await Promise.all(sent)
-    const replySet = new Set(sentMsgs.map(x => x.id))
-    const gotReplies = await pollUntil(async () => {
-      const rows = await messages(cid)
-      const replies = rows.filter(r => r.fromAgentId === w2
-        && r.metadata?.['x-aw-in-reply-to'] && replySet.has(r.metadata['x-aw-in-reply-to']))
-      return replies.length >= N ? replies : null
-    }, 20_000, 'T2 全部回执')
-    check('T2 每条消息恰好收到一条回执(N/N)', gotReplies.ok, `${gotReplies.value?.length ?? 0}/${N}`)
-    {
-      const replies = gotReplies.value ?? []
-      // 并发 POST 的服务器入队顺序 ≠ 客户端编号顺序;FIFO 契约 = 按入队顺序执行。
-      // 以入队时间戳(消息行 createdAt)为基准:回执顺序映射回原消息后单调不减
-      // (同毫秒并列组内任意序均可),跨毫秒组必须升序。
-      const createdAtByMsg = new Map(
-        (await messages(cid))
-          .filter(r => replySet.has(r.id))
-          .map(r => [r.id, r.createdAt]),
-      )
-      const stamps = replies.map(r => createdAtByMsg.get(r.metadata['x-aw-in-reply-to']))
-      const nonDecreasing = stamps.every((v, idx) => idx === 0 || v >= stamps[idx - 1])
-      check('T2 回执顺序与入队时间戳单调一致(FIFO 按入队序;同毫秒并列可任意序)', nonDecreasing, stamps.join(','))
-      // 逐条语义:无重复回执、无遗漏
-      const uniqTargets = new Set(replies.map(r => r.metadata['x-aw-in-reply-to']))
-      check('T2 回执一一对应(无重复/无遗漏)', uniqTargets.size === N && replies.length === N)
-    }
-
-    // ================= T3:实时消息即时性(按需获取) =================
-    console.log('\n--- T3:实时消息按需获取即时性(idle worker,immediate) ---')
-    {
-      const t0 = Date.now()
-      const r = await api('POST', `/api/workshop/channels/${cid}/messages`, {
-        toAgentId: w2, fromAgentId: leadId,
-        text: '实时性探针:请立即回执',
-        priority: 'immediate', requireReply: true,
-      })
-      const probe = await pollUntil(async () => {
-        const rows = await messages(cid)
-        return rows.find(x => x.fromAgentId === w2 && x.metadata?.['x-aw-in-reply-to'] === r.messageId) ?? null
-      }, 10_000, 'T3 回执')
-      const ms = Date.now() - t0
-      check('T3 发送→回执到达(< 5s;mailbox 到信即时唤醒 + 消费循环即时接单)', probe.ok && ms < 5000, `${ms}ms`)
-    }
-
-    // ================= T4:lead 调度闭环(多 Agent 协同) =================
-    console.log('\n--- T4:lead 调度闭环(默认路由 → lead 派发 → worker 完成 → 父任务收口) ---')
-    {
-      const parent = await api('POST', `/api/workshop/channels/${cid}/tasks`, {
-        title: `协同闭环-${stamp}`,
-        description: 'lead 应派发子任务给空闲 worker 并在子任务完成后汇总收口',
-        parts: [{ text: '协同闭环 body' }],
-      })
-      const done = await pollUntil(async () => {
-        const tasks = await api('GET', `/api/workshop/channels/${cid}/tasks`)
-        const st = tasks.find(t => t.id === parent.id)?.state
-        return st === 'COMPLETED' || null
-      }, 40_000, 'T4 父任务 COMPLETED')
-      check('T4 父任务经 lead 调度收口为 COMPLETED', done.ok, `${done.elapsed}ms`)
-      // 派发链路:存在子任务(指派给 worker)且完成
-      const tasks = await api('GET', `/api/workshop/channels/${cid}/tasks`)
-      const children = tasks.filter(t => t.parentId === parent.id)
-      check('T4 lead 派发了子任务且子任务完成', children.length > 0 && children.every(c => c.state === 'COMPLETED'),
-        `children=${children.length}`)
-      // lead 汇总交付物
-      const parentTask = tasks.find(t => t.id === parent.id)
-      check('T4 父任务带汇总交付物(summary)', (parentTask?.artifacts?.length ?? 0) > 0)
-    }
-  }
-  finally {
-    // ---- 清理:删除测试 channel(级联清理 agents/tasks/messages) ----
-    try {
-      await api('DELETE', `/api/workshop/channels/${cid}`)
-      console.log(`\n(测试 channel ${cid.slice(0, 8)} 已删除)`)
-    }
-    catch (err) {
-      console.log(`\n(清理失败,请手动删除 channel ${cid}:${err.message})`)
-    }
-  }
-
-  console.log(`\n${failures === 0 ? 'ALL PASS' : `${failures} FAILURE(S)`}`)
-  process.exit(failures === 0 ? 0 : 1)
-}
-
-main().catch((err) => {
-  console.error('E2E 异常:', err.message)
-  process.exit(1)
-})