agentworkshop 0.7.34 → 0.7.37

package/scripts/e2e-line-live.mjs

@@ -1,144 +0,0 @@
-/**
- * 产线管理 + 数控(DCW) + 数采(DAQ) 真实端到端(PLC 工艺模拟器):
- *   node scripts/e2e-line-live.mjs [--base http://127.0.0.1:3000]
- *
- * 链路:建产线 → 挂数采/数控节点 → 产品+配方 → 开跑 → 数采出数 →
- *       数控下发(write,带回读校验)→ 越界拒绝 → 产线查询打标 → 清理。
- */
-const BASE = (() => {
-  const i = process.argv.indexOf('--base')
-  return i > 0 ? process.argv[i + 1] : 'http://127.0.0.1:3000'
-})()
-const TAG = Date.now().toString(36)
-
-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 = 30_000, intervalMs = 1000) {
-  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 main() {
-  console.log(`\n━━━ 产线/数控/数采 真实端到端 @ ${BASE} ━━━`)
-
-  const reg = await api('POST', '/api/users/register', {
-    body: { email: `line-e2e-${TAG}@test.local`, password: 'Passw0rd!123', name: `line-e2e-${TAG}` },
-  })
-  const token = reg.data?.token
-  if (!token) throw new Error(`注册失败: ${JSON.stringify(reg).slice(0, 160)}`)
-
-  // ── 1. 产线 + 节点 + 产品 + 配方 ──
-  const line = (await api('POST', '/api/workshop/dcw/lines', { body: { name: `线-e2e-${TAG}` }, token })).data?.line
-  check('1.1 建产线', Boolean(line?.id), `id=${line?.id?.slice(0, 8)}`)
-
-  const dq = (await api('POST', '/api/workshop/daq', {
-    body: { templateRef: 'daq-temp-tc', name: `温度采集-${TAG}`, lineId: line.id, intervalMs: 500 },
-    token,
-  })).data?.node
-  check('1.2 挂数采节点(daq-temp-tc)', Boolean(dq?.id), `id=${dq?.id?.slice(0, 8)}`)
-
-  const dw = (await api('POST', '/api/workshop/dcw', {
-    body: { templateRef: 'dcw-temp-sp', name: `温度设定-${TAG}`, lineId: line.id },
-    token,
-  })).data?.node
-  check('1.3 挂数控节点(dcw-temp-sp)', Boolean(dw?.id), `id=${dw?.id?.slice(0, 8)}`)
-
-  const prod = (await api('POST', '/api/workshop/dcw/products', {
-    body: { name: `产品-${TAG}`, lineId: line.id },
-    token,
-  })).data?.product
-  check('1.4 建产品', Boolean(prod?.id))
-
-  const recipe = (await api('POST', '/api/workshop/dcw/recipes', {
-    body: {
-      productId: prod.id,
-      name: `配方-${TAG}`,
-      params: [{ templateRef: 'dcw-temp-sp', nodeId: dw.id, value: 180, min: 176, max: 188 }],
-      daqWindows: [{ nodeId: dq.id, min: 100, max: 260 }],
-    },
-    token,
-  })).data?.recipe
-  check('1.5 建配方(SP=180 窗口 176-188 + 数采窗口)', Boolean(recipe?.id))
-
-  // ── 2. 开跑 → 数采出数 ──
-  const start = await api('POST', `/api/workshop/dcw/lines/${line.id}/start`, { body: { recipeId: recipe.id }, token })
-  check('2.1 产线开跑(配方激活)', start.code === 0 && (start.data?.line?.active ?? start.data?.run?.active ?? true), start.message ?? '')
-
-  console.log('  … 等待 PLC 工艺模拟器产出样本(10s)…')
-  await sleep(10_000)
-  const samples = await api('GET', `/api/workshop/daq/${dq.id}/samples`, { token, query: undefined })
-  const pts = samples.data?.points ?? samples.data ?? []
-  check('2.2 数采时序出数(模拟器)', Array.isArray(pts) && pts.length >= 3, `points=${Array.isArray(pts) ? pts.length : 'n/a'}`)
-  const latest = Array.isArray(pts) && pts.length > 0 ? pts.at(-1) : null
-  const latestVal = latest?.value ?? latest?.v
-  check('2.3 样本含工程量数值', Number.isFinite(Number(latestVal)), `latest=${JSON.stringify(latest)?.slice(0, 80)}`)
-
-  // ── 3. 数控下发(带回读校验) + 越界拒绝 ──
-  const write = await api('POST', `/api/workshop/dcw/${dw.id}/write`, { body: { value: 182 }, token })
-  check('3.1 手动下发 SP=182(写+回读校验 ACK)', write.code === 0 && write.data?.outcome?.ok !== false, JSON.stringify(write.data?.outcome ?? write.message)?.slice(0, 100))
-
-  const inRange = await waitUntil('3.2 设定值收敛到 182±2(工艺响应)', async () => {
-    const list = await api('GET', '/api/workshop/dcw', { token })
-    const nodes = Array.isArray(list.data) ? list.data : (list.data?.nodes ?? [])
-    const node = nodes.find(n => n.id === dw.id)
-    const v = Number(node?.readValue ?? node?.value ?? NaN)
-    return Number.isFinite(v) && Math.abs(v - 182) <= 2 ? v : null
-  }, 30_000, 1500).catch(() => null)
-  check('3.2 设定值收敛(182±2)', inRange !== null, `value=${inRange}`)
-
-  const bad = await api('POST', `/api/workshop/dcw/${dw.id}/write`, { body: { value: 999 }, token })
-  check('3.3 越界下发被拒(400 量程校验)', bad.status === 400 || bad.code === 400 || bad.code === 'VALIDATION_ERROR', `status=${bad.status} code=${bad.code}`)
-
-  // ── 4. 产线查询(工艺打标)──
-  // lineQuery 的 productId/recipeId 是过滤器:带上产品/配方过滤仍能查到样本,
-  // 即证明数采样本确实按「产品+配方」打标(开跑激活窗口后逐样本打标)
-  const lineData = await waitUntil('4.1 产线查询返回打标样本', async () => {
-    const q = await api('GET', `/api/workshop/dcw/line/query?lineId=${line.id}&nodeId=${dq.id}&from=${Date.now() - 600_000}`, { token })
-    const d = q.data ?? {}
-    const pts = (d.channels ?? []).reduce((acc, c) => acc + (c.points?.length ?? 0), 0)
-    return pts >= 1 ? d : null
-  }, 30_000, 2000).catch(() => null)
-  check('4.1 产线查询返回工艺样本(channels.points)', Boolean(lineData), lineData ? `channels=${lineData.channels?.length}` : 'empty')
-
-  const tagged = await api('GET', `/api/workshop/dcw/line/query?lineId=${line.id}&nodeId=${dq.id}&from=${Date.now() - 600_000}&productId=${prod.id}&recipeId=${recipe.id}`, { token })
-  const taggedPts = ((tagged.data?.channels ?? [])[0]?.points ?? []).length
-  check('4.2 按产品+配方过滤仍命中(样本打标验证)', taggedPts >= 1, `taggedPoints=${taggedPts}`)
-
-  // ── 清理 ──
-  await api('POST', `/api/workshop/dcw/lines/${line.id}/stop`, { token }).catch(() => {})
-  for (const [p, id] of [['/api/workshop/daq', dq.id], ['/api/workshop/dcw', dw.id]]) {
-    await api('DELETE', `${p}/${id}`, { token }).catch(() => {})
-  }
-  await api('DELETE', `/api/workshop/dcw/lines/${line.id}`, { token }).catch(() => {})
-
-  console.log(`\n━━━ 结果: ${passed} passed / ${failures} failed ━━━`)
-  process.exit(failures === 0 ? 0 : 1)
-}
-
-main().catch((err) => {
-  console.error('FATAL', err.message)
-  process.exit(1)
-})

package/scripts/e2e-memory-persistence.ts

@@ -1,320 +0,0 @@
-/**
- * 记忆持久化跨重启端到端验证 — 文件型 sqlite + 双 manager 生命周期:
- * ① 并行创建两个 Channel(A: 记忆链路 / B: 隔离对照),各 lead + 2 worker
- * ② 双 Channel 交错提交任务并行闭环 → 各 agent 记忆自动落库(私有)
- * ③ Channel A 的 worker 经 workspace.saveMemory 沉淀 shared 公共记忆
- * ④ 注入验证(重启前):A 相关任务 request.memory 含 A 私有 + A 公共;B 不含 A 的任何内容
- * ⑤ 中断卸载:manager.shutdown() + db.close() → 全新 manager 同一 DB 文件 restore()(模拟进程重启)
- * ⑥ 重启后各 Channel 重新下发相关任务:
- *    - request.memory(记忆引子)仍召回重启前的私有/公共记忆
- *    - echo 执行中主动调 ctx.workspace.recallMemory(动态抓取工具桥)→ deliverable 携带命中内容
- * ⑦ Channel 隔离:重启后 A 仍看不到 B 的私有记忆,B 看不到 A 的公共记忆
- * 向量链已由 test-memory-vector 覆盖;本 E2E 纯 FTS 路径。
- * 运行: npx tsx scripts/e2e-memory-persistence.ts
- */
-import { randomUUID } from 'node:crypto'
-import { mkdtempSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { openWorkshopDb } from '../server/services/workshop/db/database'
-import type { DatabaseSync } from 'node:sqlite'
-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, AllRepos } from '../server/services/workshop/runtime/manager'
-import type { AgentInfo, AgentInterface, AgentRunContext, AgentRunRequest, AgentEvent } from '../server/services/workshop/agents/agent-interface'
-import type { A2AArtifact, Part } from '../server/services/workshop/types/a2a'
-
-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
-}
-
-function partsText(parts: Part[]): string {
-  return parts.map(p => ('text' in p ? p.text : '')).filter(Boolean).join('\n')
-}
-
-// ═══════════ echo harness ═══════════
-
-interface EchoOptions {
-  /** 重启后的 worker:执行中主动调 recallMemory 工具桥,把命中放进 deliverable */
-  useMemoryTools?: boolean
-}
-
-class EchoWorkerImpl implements AgentInterface {
-  readonly captured: AgentRunRequest[] = []
-  constructor(private opts: EchoOptions = {}) {}
-
-  async* run(request: AgentRunRequest, ctx: AgentRunContext): AsyncGenerator<AgentEvent, void, unknown> {
-    this.captured.push(request)
-    const kind = request.message.metadata?.['x-aw-task-kind']
-    if (kind === 'assign' && request.taskId) {
-      yield { kind: 'status', status: { state: 'WORKING', timestamp: new Date().toISOString() } }
-      const taskText = partsText(request.message.parts)
-      // 动态记忆抓取工具桥(search_memory 路径同源):执行中按任务内容检索记忆(仅重启后轮开启)
-      let toolRecall = ''
-      if (this.opts.useMemoryTools) {
-        const snippets = await ctx.workspace.recallMemory({ query: taskText.slice(0, 60), scope: 'auto', limit: 5 })
-        toolRecall = snippets.map(s => `[${s.source}]${s.title}:${s.content.slice(0, 60)}`).join(' | ')
-      }
-      const artifact: A2AArtifact = {
-        artifactId: randomUUID(),
-        name: 'deliverable',
-        parts: [{ text: `echo 完成(${ctx.agentId}):${taskText.slice(0, 60)}${toolRecall || this.opts.useMemoryTools ? `;记忆抓取=${toolRecall || '(无)'}` : ''}` }],
-      }
-      yield { kind: 'artifact', artifact, lastChunk: true, totalChunks: 1 }
-      await ctx.workspace.completeTask(request.taskId, [artifact])
-      yield { kind: 'done', final: { taskId: request.taskId } }
-      return
-    }
-    yield { kind: 'done' }
-  }
-}
-
-class EchoLeadImpl implements AgentInterface {
-  readonly captured: AgentRunRequest[] = []
-
-  async* run(request: AgentRunRequest, ctx: AgentRunContext): AsyncGenerator<AgentEvent, void, unknown> {
-    this.captured.push(request)
-    if (request.message.metadata?.['x-aw-task-kind'] === 'child-completed' && request.taskId) {
-      const parent = await ctx.workspace.getTask(request.taskId)
-      if (parent && parent.state !== 'COMPLETED' && parent.state !== 'FAILED' && parent.state !== 'CANCELED') {
-        const summary: A2AArtifact = {
-          artifactId: randomUUID(),
-          name: 'summary',
-          parts: [{ text: `汇总:子任务完成(${partsText(request.message.parts).slice(0, 60)})` }],
-        }
-        await ctx.workspace.completeTask(request.taskId, [summary])
-      }
-      yield { kind: 'done' }
-    }
-  }
-}
-
-// ═══════════ 装配 ═══════════
-
-const tmpDir = mkdtempSync(join(tmpdir(), 'aw-e2e-mem-persist-'))
-const dbFile = join(tmpDir, 'workshop.sqlite')
-
-function openRepos(db: DatabaseSync): AllRepos {
-  return {
-    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 echoByAgent = new Map<string, EchoWorkerImpl | EchoLeadImpl>()
-
-function makeManager(db: DatabaseSync, opts?: { workerOpts?: EchoOptions }): AgentChannelManager {
-  echoByAgent.clear()
-  const repos = openRepos(db)
-  const implFactory = (agent: AgentInfo): AgentInterface => {
-    const impl = agent.role === 'lead'
-      ? new EchoLeadImpl()
-      : new EchoWorkerImpl({ ...(opts?.workerOpts ?? {}) })
-    echoByAgent.set(agent.id, impl)
-    return impl
-  }
-  return createAgentChannelManager({ repos, implFactory, db })
-}
-
-let db = openWorkshopDb(dbFile)
-let manager = makeManager(db)
-
-interface Ch {
-  id: string
-  lead: AgentInfo
-  workers: AgentInfo[]
-}
-
-async function setupChannel(name: string, workerCount: number): Promise<Ch> {
-  const ch = await manager.createChannel({ name, workspace: join(tmpDir, name) })
-  const leadTpl = await manager.createAgent({ name: `${name}-lead`, harness: 'echo' })
-  const lead = await manager.addAgentToChannel({ channelId: ch.channelId, agentId: leadTpl.id, role: 'lead' })
-  const workers: AgentInfo[] = []
-  for (let i = 1; i <= workerCount; i++) {
-    const tpl = await manager.createAgent({ name: `${name}-w${i}`, harness: 'echo' })
-    workers.push(await manager.addAgentToChannel({ channelId: ch.channelId, agentId: tpl.id, role: 'worker' }))
-  }
-  manager.ensureChannelActive(ch.channelId, { tickMs: 50 })
-  return { id: ch.channelId, lead, workers }
-}
-
-function submit(chId: string, title: string, description: string): Promise<unknown> {
-  return manager.submitChannelTask({ channelId: chId, title, description })
-}
-
-function waitDone(chId: string, leadId: string, title: string): Promise<boolean> {
-  return waitUntil(async () =>
-    (await manager.listTasks(chId, leadId)).some(t => t.title === title && t.state === 'COMPLETED'), 15_000)
-}
-
-function workerRequests(agentId: string): AgentRunRequest[] {
-  return (echoByAgent.get(agentId) as EchoWorkerImpl | undefined)?.captured ?? []
-}
-
-/** 找标题匹配的任务请求中最近一个带记忆块的 */
-function lastMemoryReq(agentIds: string[], title: string): AgentRunRequest | undefined {
-  return agentIds
-    .flatMap(id => workerRequests(id))
-    .reverse()
-    .find(r => partsText(r.message.parts).includes(title) && r.memory !== undefined)
-}
-
-async function main(): Promise<void> {
-  // ── ① 并行创建两个 Channel(各 lead + 2 worker)──
-  console.log('=== ① 并行双 Channel 装配(A: 记忆链路 / B: 隔离对照) ===')
-  const [chA, chB] = await Promise.all([setupChannel('alpha', 2), setupChannel('beta', 2)])
-  check('双 Channel 各装配 3 实例',
-    (await manager.listChannelAgents(chA.id)).length === 3 && (await manager.listChannelAgents(chB.id)).length === 3)
-  const st = manager.runtimeStatus()
-  // worker 懒装配:任务分发时才接线,此处仅要求两 channel 激活 + 双 lead 在线
-  check('两 Channel 激活且双 lead runtime 在线',
-    st.activeChannels.includes(chA.id) && st.activeChannels.includes(chB.id)
-    && st.wiredAgents.includes(chA.lead.id) && st.wiredAgents.includes(chB.lead.id),
-    `wired=${st.wiredAgents.length}`)
-
-  // ── ② 交错并行提交任务 → 记忆自动落库 ──
-  console.log('\n=== ② 双 Channel 交错并行任务(记忆自动落库) ===')
-  await Promise.all([
-    submit(chA.id, '实现支付网关对接', '为订单系统对接支付宝网关,完成签名与回调验签'),
-    submit(chB.id, '实现报表导出', '为运营后台实现CSV报表导出功能'),
-    submit(chA.id, '支付网关签名算法', '实现支付网关的RSA2签名算法与验签'),
-    submit(chB.id, '报表分页优化', '优化大报表导出的分页查询性能'),
-  ])
-  check('A 任务1 闭环', await waitDone(chA.id, chA.lead.id, '实现支付网关对接'))
-  check('A 任务2 闭环', await waitDone(chA.id, chA.lead.id, '支付网关签名算法'))
-  check('B 任务1 闭环', await waitDone(chB.id, chB.lead.id, '实现报表导出'))
-  check('B 任务2 闭环', await waitDone(chB.id, chB.lead.id, '报表分页优化'))
-
-  const memRepo = openRepos(db).memories
-  const hasMem = (agentId: string, kw: string): boolean =>
-    memRepo.listByAgent(agentId, 50).some(r => r.title.includes(kw))
-  check('A 两个 worker 均有任务记忆落库',
-    await waitUntil(() => chA.workers.every(w => hasMem(w.id, '支付')), 5000),
-    chA.workers.map(w => `${w.name}:${memRepo.listByAgent(w.id, 50).length}`).join(' '))
-  check('B 两个 worker 均有任务记忆落库',
-    await waitUntil(() => chB.workers.every(w => hasMem(w.id, '报表')), 5000),
-    chB.workers.map(w => `${w.name}:${memRepo.listByAgent(w.id, 50).length}`).join(' '))
-
-  // ── ③ A 公共记忆入 Channel 共享域(save_memory(scope=shared) 同一存储域;
-  //     工具桥的私有/共享分流动作已由 test-memory-dynamic.ts 全覆盖,此处注入 A 专属公共记忆供隔离验证) ──
-  console.log('\n=== ③ A 公共记忆写入 Channel 共享域 ===')
-  manager.addTeamMemory(chA.id, chA.lead.id, {
-    title: '支付网关接入规范',
-    content: '所有支付相关代码必须使用 RSA2 签名并在沙箱环境验证',
-    dedupKey: 'team:pay-conv',
-  })
-  const teamRows = manager.listTeamMemories(chA.id, 50)
-  const teamRowsB = manager.listTeamMemories(chB.id, 50)
-  check('A 公共记忆入列(__team__@A)', teamRows.some(r => r.title === '支付网关接入规范'))
-  check('B 公共域无 A 的记忆(隔离)', !teamRowsB.some(r => r.title === '支付网关接入规范'))
-
-  // ── ④ 重启前注入验证(记忆引子) ──
-  console.log('\n=== ④ 重启前记忆引子注入 ===')
-  await submit(chA.id, '支付回调验签补全', '补全支付网关回调验签逻辑,遵循支付网关接入规范')
-  check('A 相关任务闭环', await waitDone(chA.id, chA.lead.id, '支付回调验签补全'))
-  const aReq = lastMemoryReq(chA.workers.map(w => w.id), '支付回调验签补全')
-  check('A worker 引子含自身私有记忆(支付)', aReq?.memory?.includes('支付') === true, aReq?.memory?.slice(0, 80))
-  check('A worker 引子含 A 公共记忆(RSA2)', aReq?.memory?.includes('RSA2') === true)
-  check('A worker 引子不含 B 的记忆(报表)', aReq?.memory?.includes('报表') === false)
-
-  await submit(chB.id, '报表导出字段调整', '调整CSV报表导出的字段顺序')
-  check('B 相关任务闭环', await waitDone(chB.id, chB.lead.id, '报表导出字段调整'))
-  const bReq = lastMemoryReq(chB.workers.map(w => w.id), '报表导出字段调整')
-  check('B worker 引子含自身私有记忆(报表)', bReq?.memory?.includes('报表') === true, bReq?.memory?.slice(0, 80))
-  check('B worker 引子不含 A 的公共记忆(RSA2/支付)', bReq?.memory?.includes('RSA2') === false && bReq?.memory?.includes('支付网关接入规范') === false)
-
-  // ── ⑤ 中断 + 卸载 Channel(db.close 模拟进程重启) ──
-  console.log('\n=== ⑤ 中断卸载(shutdown + db.close → 全新 manager 同 DB restore) ===')
-  await manager.shutdown()
-  check('shutdown 后 runtime 全卸载', manager.runtimeStatus().wiredAgents.length === 0)
-  db.close()
-  db = openWorkshopDb(dbFile)
-  manager = makeManager(db, { workerOpts: { useMemoryTools: true } })
-  await manager.restore()
-  check('重启后 manager 就绪(0 wired,lazy)', manager.runtimeStatus().wiredAgents.length === 0)
-  check('重启后记忆仍在文件库',
-    openRepos(db).memories.listByAgent(chA.workers[0].id, 50).some(r => r.title.includes('支付')))
-
-  // ── ⑥ 重启后重新下发任务:引子召回 + 动态抓取工具桥 ──
-  console.log('\n=== ⑥ 重启后任务重发(引子 + recallMemory 工具桥) ===')
-  await Promise.all([
-    submit(chA.id, '支付网关重试机制', '为支付网关对接增加失败重试机制,遵循既有签名规范'),
-    submit(chB.id, '报表模板定制', '为CSV报表导出增加自定义模板'),
-  ])
-  check('A 重启后任务闭环', await waitDone(chA.id, chA.lead.id, '支付网关重试机制'))
-  check('B 重启后任务闭环', await waitDone(chB.id, chB.lead.id, '报表模板定制'))
-
-  const aReq2 = lastMemoryReq(chA.workers.map(w => w.id), '支付网关重试机制')
-  check('重启后 A 引子召回重启前私有记忆(支付)', aReq2?.memory?.includes('支付') === true, aReq2?.memory?.slice(0, 80))
-  check('重启后 A 引子召回 A 公共记忆(RSA2)', aReq2?.memory?.includes('RSA2') === true)
-
-  const bReq2 = lastMemoryReq(chB.workers.map(w => w.id), '报表模板定制')
-  check('重启后 B 引子召回重启前私有记忆(报表)', bReq2?.memory?.includes('报表') === true, bReq2?.memory?.slice(0, 80))
-  check('重启后 B 引子仍不见 A 记忆', bReq2?.memory?.includes('支付') === false && bReq2?.memory?.includes('RSA2') === false)
-
-  // 动态抓取工具桥:重启后 echo 执行中主动 recallMemory → deliverable 携带命中(deliverable 在子任务上)
-  const deliverableTextOf = async (chId: string, leadId: string, title: string): Promise<string> => {
-    const tasks = await manager.listTasks(chId, leadId)
-    const hits = tasks
-      .filter(t => t.title === title || t.parentId !== undefined)
-      .flatMap(t => t.artifacts.filter(a => a.name === 'deliverable'))
-      .map(a => partsText(a.parts))
-    return hits.find(t => t.includes('记忆抓取=')) ?? hits.join('\n') ?? ''
-  }
-  const toolText = await deliverableTextOf(chA.id, chA.lead.id, '支付网关重试机制')
-  check('重启后 recallMemory 工具桥抓到私有记忆(支付)', toolText.includes('[private]') && toolText.includes('支付'), toolText.slice(0, 160))
-  check('重启后 recallMemory 工具桥抓到公共记忆(RSA2,source=shared)', toolText.includes('[shared]') && toolText.includes('RSA2'))
-
-  const bToolText = await deliverableTextOf(chB.id, chB.lead.id, '报表模板定制')
-  check('重启后 B 工具桥只见 B 域记忆', bToolText.includes('报表') && !bToolText.includes('RSA2') && !bToolText.includes('支付网关接入规范'), bToolText.slice(0, 160))
-
-  // ── ⑦ 收尾:第二次 shutdown 干净退出 ──
-  console.log('\n=== ⑦ 最终 shutdown ===')
-  await manager.shutdown()
-  db.close()
-  rmSync(tmpDir, { recursive: true, force: true })
-  console.log(`\n${failures === 0 ? 'ALL PASS' : `${failures} FAILED`}`)
-  process.exit(failures === 0 ? 0 : 1)
-}
-
-main().catch(async (e) => {
-  console.error('E2E 异常:', e)
-  try {
-    await manager.shutdown()
-    db.close()
-  }
-  catch { /* 尽力清理 */ }
-  rmSync(tmpDir, { recursive: true, force: true })
-  process.exit(1)
-})