agentworkshop 0.2.1

package/scripts/e2e-lead-team-mgmt.ts

@@ -0,0 +1,217 @@
+/**
+ * E2E:Lead 执行中自主团队管理(成员 创建/更新/删除 + 孤儿任务回收)。
+ *
+ * 覆盖面:
+ *  1. 工具注入按角色差异化:hostToolsForRole(worker 剔除调度/团队管理;lead 全量含新工具)
+ *  2. 决策路径:mock lead 首个 supervise tick 发 spawn_agent → SchedulerLoop 执行 → 新成员入册
+ *  3. 工具桥路径(与 omp host tool 同源):manager.createTeamMember/updateTeamMember/removeTeamMember
+ *     - 权限:worker 调用 → 403;lead 改/删自己 → 400
+ *     - 事件:AEP agent.member(op=added/updated/removed,by=lead:<id>)广播
+ *  4. 新成员可被调度:queueOverview 可见 → 接收 dispatch → 完成任务
+ *  5. 孤儿任务回收:
+ *     - 排队中(ASSIGNED)成员被移除 → 任务重派给剩余最短队列成员
+ *     - 执行中(WORKING)成员被移除 → 任务 FAILED → 调度循环重试重派 → 最终 COMPLETED
+ */
+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 { createUserRepo } from '../server/services/workshop/db/user.repo'
+import { createAgentChannelManager } from '../server/services/workshop/runtime/manager'
+import type { AgentChannelManager } from '../server/services/workshop/runtime/manager'
+import type { MemberChangeEvent } from '../server/services/workshop/runtime/agent-runtime'
+import { createAgentImpl } from '../server/services/workshop/agents/factory'
+import { hostToolsForRole } from '../server/services/workshop/agents/omp-agent'
+import { AppError } from '../server/utils/errors'
+
+let failures = 0
+function check(name: string, ok: boolean, detail = ''): void {
+  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(50)
+  }
+  return false
+}
+
+function setup(): { manager: AgentChannelManager } {
+  const db = openWorkshopDb(':memory:')
+  const repos = {
+    users: createUserRepo(db),
+    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 }
+}
+
+async function main(): Promise<void> {
+  console.log('== 1. 工具注入按角色差异化 ==')
+  {
+    const leadTools = hostToolsForRole('lead').map(t => t.name)
+    const workerTools = hostToolsForRole('worker').map(t => t.name)
+    check('lead 拥有团队管理三工具', ['create_team_agent', 'update_team_agent', 'remove_team_agent'].every(n => leadTools.includes(n)))
+    check('worker 无团队管理/派发工具', ['create_team_agent', 'update_team_agent', 'remove_team_agent', 'dispatch_task', 'reassign_task'].every(n => !workerTools.includes(n)))
+    check('worker 保留执行/通信/记忆面', ['complete_task', 'report_progress', 'send_message_to_agent', 'search_memory', 'save_memory'].every(n => workerTools.includes(n)))
+    check('lead 保留全量(worker 工具不缺)', workerTools.every(n => leadTools.includes(n)), `lead=${leadTools.length} worker=${workerTools.length}`)
+  }
+
+  console.log('== 2. 决策路径:lead spawn_agent → 新成员入册 ==')
+  const { manager } = setup()
+  const memberEvents: MemberChangeEvent[] = []
+  const leadConfig = {
+    delayMs: 100,
+    // mock lead 首个 supervise tick 的团队管理剧本
+    teamOps: [
+      { kind: 'spawn_agent' as const, name: 'test-writer', harness: 'mock', config: { delayMs: 120 }, reason: '扩容:任务需要专职测试编写' },
+    ],
+  }
+  const { channelId, leadAgentId } = await manager.createChannel({
+    name: 'team-mgmt',
+    leadAgent: { name: 'lead', harness: 'mock', config: leadConfig },
+  })
+  manager.subscribeMemberEvents(channelId, e => memberEvents.push(e))
+  const w1tpl = await manager.createAgent({ name: 'w1', harness: 'mock', config: { delayMs: 120 } })
+  await manager.addAgentToChannel({ channelId, agentId: w1tpl.id, role: 'worker' })
+
+  const task = await manager.submitChannelTask({ channelId, title: '交付一个功能', description: '分解并完成' })
+  const spawned = await waitUntil(async () => (await manager.listChannelAgents(channelId)).some(a => a.name === 'test-writer'), 10_000)
+  check('spawn_agent 决策落地:新成员入册', spawned)
+  const spawnEvt = memberEvents.find(e => e.op === 'added' && e.name === 'test-writer')
+  check('agent.member(added) 事件广播(by=lead:…)', !!spawnEvt && spawnEvt.by === `lead:${leadAgentId}`, JSON.stringify(spawnEvt ?? null))
+  check('新成员为 worker 角色', spawnEvt?.role === 'worker')
+
+  const completed = await waitUntil(async () =>
+    (await manager.listTasks(channelId, leadAgentId!)).find(t => t.id === task.id)?.state === 'COMPLETED', 15_000)
+  check('主任务在新团队配置下正常完成', completed)
+
+  console.log('== 3. 工具桥路径:createTeamMember/updateTeamMember ==')
+  const docWriter = await manager.createTeamMember(channelId, leadAgentId!, {
+    name: 'doc-writer',
+    harness: 'mock',
+    config: { systemPromptPrefix: '你是文档专家', delayMs: 100 },
+    reason: '需要文档专员',
+  })
+  check('createTeamMember 成功返回实例', !!docWriter.id && docWriter.role === 'worker' && docWriter.harness === 'mock')
+  const templates = await manager.listAgents()
+  check('按需落模板(可复用)', templates.some(t => t.name === 'doc-writer'))
+  const renamed = await manager.updateTeamMember(channelId, leadAgentId!, docWriter.id, { name: 'doc-writer-v2', reason: '更名' })
+  check('updateTeamMember 改名生效', renamed.name === 'doc-writer-v2')
+  const updEvt = memberEvents.find(e => e.op === 'updated' && e.agentId === docWriter.id)
+  check('agent.member(updated) 事件广播', !!updEvt && updEvt.name === 'doc-writer-v2')
+
+  console.log('== 4. 权限校验 ==')
+  const workers = (await manager.listChannelAgents(channelId)).filter(a => a.role === 'worker')
+  const anyWorker = workers[0]!
+  let saw403 = false
+  try {
+    await manager.createTeamMember(channelId, anyWorker.id, { name: 'rogue', harness: 'mock' })
+  }
+  catch (err) { saw403 = err instanceof AppError && err.status === 403 }
+  check('worker 调 createTeamMember → 403', saw403)
+  let saw400self = false
+  try {
+    await manager.removeTeamMember(channelId, leadAgentId!, leadAgentId!)
+  }
+  catch (err) { saw400self = err instanceof AppError && err.status === 400 }
+  check('lead 移除自己 → 400', saw400self)
+  let saw400selfUpd = false
+  try {
+    await manager.updateTeamMember(channelId, leadAgentId!, leadAgentId!, { name: 'x' })
+  }
+  catch (err) { saw400selfUpd = err instanceof AppError && err.status === 400 }
+  check('lead 更新自己 → 400', saw400selfUpd)
+
+  console.log('== 5. 新成员可被调度 ==')
+  const testWriter = (await manager.listChannelAgents(channelId)).find(a => a.name === 'test-writer')!
+  const overview = await manager.queueOverview(channelId, leadAgentId!)
+  check('queueOverview 可见新成员', overview.some(o => o.agentId === testWriter.id))
+  // 直接以 lead 身份 dispatch 给新成员(验证完整投递链)
+  const directTask = await manager.dispatchTask(channelId, leadAgentId!, {
+    assigneeId: testWriter.id,
+    title: '编写测试用例',
+    parentTaskId: undefined,
+    description: '为核心模块编写测试',
+  })
+  const directDone = await waitUntil(async () => (await manager.getTask(channelId, leadAgentId!, directTask.id)).state === 'COMPLETED', 10_000)
+  check('新成员接取并完成任务', directDone)
+
+  console.log('== 6. 孤儿任务回收:排队中(ASSIGNED)成员移除 → 重派 ==')
+  // 造一个"排队中"任务:给启用成员连发两个任务(FIFO)——第一个进入 WORKING,
+  // 第二个滞留其信箱 ASSIGNED(排队中,未消费)——随后移除成员经回收路径重派。
+  // (注:新版有"投递失败补偿",向已禁用成员派发会被 DELIVERY_FAILED 拒绝并回收任务,
+  //  因此排队任务只可能存在于"曾可投递但未及消费"的成员队列中)
+  const idleTpl = await manager.createAgent({ name: 'idle-queue', harness: 'mock', config: { delayMs: 100 } })
+  const idleMember = await manager.addAgentToChannel({ channelId, agentId: idleTpl.id, role: 'worker' })
+  await manager.dispatchTask(channelId, leadAgentId!, {
+    assigneeId: idleMember.id,
+    title: '队列首任务',
+    description: '先被消费',
+  })
+  const queuedTask = await manager.dispatchTask(channelId, leadAgentId!, {
+    assigneeId: idleMember.id,
+    title: '排队中的任务',
+    description: '等待回收',
+  })
+  await sleep(200)
+  const queuedState = (await manager.getTask(channelId, leadAgentId!, queuedTask.id)).state
+  check('第二个任务滞留排队(ASSIGNED)', queuedState === 'ASSIGNED', queuedState)
+  const recycle = await manager.removeTeamMember(channelId, leadAgentId!, idleMember.id, '清理闲置成员')
+  check('removeTeamMember 返回回收任务列表', recycle.recycledTasks.includes(queuedTask.id), JSON.stringify(recycle.recycledTasks))
+  const afterTask = await manager.getTask(channelId, leadAgentId!, queuedTask.id)
+  check('排队任务已重派给剩余成员', afterTask.assigneeId !== idleMember.id, `→ ${afterTask.assigneeId.slice(0, 8)}`)
+  const gone = !(await manager.listChannelAgents(channelId)).some(a => a.id === idleMember.id)
+  check('成员已从名册移除', gone)
+  const rmEvt = memberEvents.find(e => e.op === 'removed' && e.agentId === idleMember.id)
+  check('agent.member(removed) 事件广播(含 reason)', !!rmEvt && rmEvt.reason === '清理闲置成员')
+  const recycleDone = await waitUntil(async () => (await manager.getTask(channelId, leadAgentId!, queuedTask.id)).state === 'COMPLETED', 10_000)
+  check('重派任务最终完成(工作不丢失)', recycleDone)
+
+  console.log('== 7. 孤儿任务回收:执行中(WORKING)成员移除 → FAILED → 重试 ==')
+  const slowTpl = await manager.createAgent({ name: 'slow-worker', harness: 'mock', config: { delayMs: 60_000 } })
+  const slowMember = await manager.addAgentToChannel({ channelId, agentId: slowTpl.id, role: 'worker' })
+  const workingTask = await manager.dispatchTask(channelId, leadAgentId!, {
+    assigneeId: slowMember.id,
+    title: '长任务',
+    description: '会被中途裁撤',
+  })
+  const isWorking = await waitUntil(async () => (await manager.getTask(channelId, leadAgentId!, workingTask.id)).state === 'WORKING', 10_000)
+  check('慢 worker 进入 WORKING', isWorking)
+  const recycle2 = await manager.removeTeamMember(channelId, leadAgentId!, slowMember.id, '执行太慢,裁撤')
+  check('执行中任务被回收(转 FAILED 待重试)', recycle2.recycledTasks.includes(workingTask.id))
+  const retryDone = await waitUntil(async () =>
+    (await manager.getTask(channelId, leadAgentId!, workingTask.id)).state === 'COMPLETED', 15_000)
+  const afterRetry = await manager.getTask(channelId, leadAgentId!, workingTask.id)
+  check('调度循环重试重派并最终完成(工作不丢失)', retryDone && afterRetry.assigneeId !== slowMember.id, `state=${afterRetry.state}, retry=${afterRetry.retryCount}`)
+
+  await manager.shutdown()
+  console.log(failures === 0 ? '\n全部通过 🎉' : `\n${failures} 项失败`)
+  process.exit(failures === 0 ? 0 : 1)
+}
+
+main().catch((err) => {
+  console.error('e2e 异常:', err)
+  process.exit(1)
+})

package/scripts/e2e-memory-persistence.ts

@@ -0,0 +1,320 @@
+/**
+ * 记忆持久化跨重启端到端验证 — 文件型 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)
+})