agentworkshop 0.2.1

package/scripts/test-hitl.ts

@@ -0,0 +1,360 @@
+/**
+ * HITL 与成员生命周期 mock 测试:
+ *  A. lead 创建团队成员 → 立即装配进 channel 运行时 + DB 同步(无需等首次投递)
+ *  B. lead 移除团队成员 → 运行时卸载 + DB 成员行删除 + 一次性模板连带删除
+ *  C. 每个 AgentRuntime 独立 stop(HITL 中断):成员保留、可重新装配、lead 停止后自动重激活
+ *  D. 任务 HITL:用户可取消(lead/worker 任务均可)+ 重试 FAILED 任务
+ *
+ * 运行: npx tsx scripts/test-hitl.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'
+import type { SupervisionDecision } from '../server/services/workshop/agents/agent-interface'
+
+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[]
+      transition(taskId: string, state: string, by: 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()
+}
+
+// ===== A. lead 建员:立即装配 + DB 同步 =====
+async function testLeadSpawnWiresMember(): Promise<void> {
+  console.log('\n━━━ A. lead 创建成员 → 立即装配 + DB 同步(mock)━━━')
+
+  const h = setup()
+  try {
+    const spawn: SupervisionDecision = {
+      kind: 'spawn_agent',
+      name: 'w2',
+      harness: 'mock',
+      config: { delayMs: 20 },
+      reason: 'lead 扩容测试',
+    }
+    const ch = await h.manager.createChannel({
+      name: '建员装配测试',
+      leadAgent: { name: 'lead', harness: 'mock', config: { delayMs: 20, teamOps: [spawn] } },
+    })
+    await h.manager.addAgentToChannel({
+      channelId: ch.channelId,
+      agentId: (await h.manager.createAgent({ name: 'w1', harness: 'mock', config: { delayMs: 20 } })).id,
+      role: 'worker',
+    })
+    attachScheduler(h.manager, ch.channelId)
+
+    // 首个 supervise tick 触发 spawn_agent → 新成员落库
+    const spawned = await waitUntil(async () => {
+      const members = await h.manager.listChannelAgents(ch.channelId)
+      return members.some(m => m.name === 'w2')
+    }, 5000)
+    check('lead spawn_agent 后成员落库(channel_agents 行)', spawned)
+
+    const w2 = (await h.manager.listChannelAgents(ch.channelId)).find(m => m.name === 'w2')
+    check('DB 成员行包含 w2', !!w2, w2 ? `id=${w2.id.slice(0, 8)}` : '')
+    const w2Detail = w2 ? h.manager.getChannelAgent(w2.id) : undefined
+    check('新成员已装配(立即 wire,无需首次投递)', w2Detail?.wired === true, `wired=${w2Detail?.wired}`)
+
+    // 装配后即可被调度:提交 2 个任务,w2 应实际执行到至少一个
+    const engine = getEngine(h.manager)
+    const t1 = await h.manager.submitChannelTask({ channelId: ch.channelId, title: '任务A' })
+    const t2 = await h.manager.submitChannelTask({ channelId: ch.channelId, title: '任务B' })
+    const allDone = await waitUntil(() =>
+      engine.get(t1.id)?.state === 'COMPLETED' && engine.get(t2.id)?.state === 'COMPLETED', 15_000)
+    check('装配成员可正常承接任务(全部完成)', allDone)
+    const children = engine.list(ch.channelId).filter(t => t.parentId && (t.parentId === t1.id || t.parentId === t2.id))
+    const byW2 = children.filter(t => t.assigneeId === w2?.id)
+    check('w2 实际执行了任务', byW2.length >= 1, `w2 执行 ${byW2.length}/${children.length}`)
+  }
+  finally {
+    await cleanup(h)
+  }
+}
+
+// ===== B. lead 删员:运行时卸载 + DB 删除(成员行 + 一次性模板) =====
+async function testLeadRemoveUnloadsAndDeletes(): Promise<void> {
+  console.log('\n━━━ B. lead 移除成员 → 卸载运行时 + 删除数据库信息(mock)━━━')
+
+  const h = setup()
+  try {
+    const spawn: SupervisionDecision = {
+      kind: 'spawn_agent',
+      name: 'w2',
+      harness: 'mock',
+      config: { delayMs: 20 },
+      reason: '扩容',
+    }
+    const ch = await h.manager.createChannel({
+      name: '删员卸载测试',
+      leadAgent: { name: 'lead', harness: 'mock', config: { delayMs: 20, teamOps: [spawn] } },
+    })
+    const w1 = await h.manager.addAgentToChannel({
+      channelId: ch.channelId,
+      agentId: (await h.manager.createAgent({ name: 'w1', harness: 'mock', config: { delayMs: 20 } })).id,
+      role: 'worker',
+    })
+    attachScheduler(h.manager, ch.channelId)
+
+    await waitUntil(async () => (await h.manager.listChannelAgents(ch.channelId)).some(m => m.name === 'w2'), 5000)
+    const w2 = (await h.manager.listChannelAgents(ch.channelId)).find(m => m.name === 'w2')!
+    // templateId 不经 AgentInfo 暴露,测试直接查库
+    const row = h.db.prepare('SELECT template_id AS templateId FROM channel_agents WHERE id = ?').get(w2.id) as { templateId: string } | undefined
+    const templateId = row?.templateId ?? ''
+    check('w2 模板存在(删除前)', !!templateId && !!h.manager.getAgent(templateId), templateId ? '' : '模板 id 缺失')
+
+    // 等 w2 完成装配
+    await waitUntil(() => h.manager.getChannelAgent(w2.id)?.wired === true, 5000)
+
+    // 模拟 lead remove_agent 决策路径(与 SchedulerLoop.execute remove 同源)
+    const lead = (await h.manager.listChannelAgents(ch.channelId)).find(m => m.role === 'lead')!
+    const result = await h.manager.removeTeamMember(ch.channelId, lead.id, w2.id, 'HITL 测试裁撤')
+    check('移除返回回收任务列表(无在途)', Array.isArray(result.recycledTasks))
+
+    const members = await h.manager.listChannelAgents(ch.channelId)
+    check('成员行已删除(DB)', !members.some(m => m.id === w2.id), `剩余 ${members.length} 人`)
+    check('运行时已卸载(wired=false/无 runtime)', h.manager.getChannelAgent(w2.id) === undefined)
+    check('一次性模板已连带删除(DB)', h.manager.getAgent(templateId) === undefined)
+
+    // 剩余成员仍可正常执行(等一轮调度快照稳定,避开删员与决策竞态窗口)
+    await sleep(250)
+    const engine = getEngine(h.manager)
+    const t = await h.manager.submitChannelTask({ channelId: ch.channelId, title: '删员后任务' })
+    const done = await waitUntil(() => engine.get(t.id)?.state === 'COMPLETED', 15_000)
+    // 根任务 assignee 恒为 lead;校验实际执行的是剩余 worker w1
+    const child = engine.list(ch.channelId).find(c => c.parentId === t.id)
+    check('删员后 channel 仍可正常执行', done && child?.assigneeId === w1.id,
+      `state=${engine.get(t.id)?.state} child=${child?.assigneeId.slice(0, 8)}`)
+  }
+  finally {
+    await cleanup(h)
+  }
+}
+
+// ===== C. 每个 AgentRuntime 独立 stop(HITL 中断) =====
+async function testStopAgentRuntime(): Promise<void> {
+  console.log('\n━━━ C. AgentRuntime 独立 stop(HITL 中断,mock)━━━')
+
+  const h = setup()
+  try {
+    const ch = await h.manager.createChannel({
+      name: '停止运行时测试',
+      leadAgent: { name: 'lead', harness: 'mock', config: { delayMs: 20 } },
+    })
+    const w1 = await h.manager.addAgentToChannel({
+      channelId: ch.channelId,
+      agentId: (await h.manager.createAgent({ name: 'w1', harness: 'mock', config: { delayMs: 30 } })).id,
+      role: 'worker',
+    })
+    attachScheduler(h.manager, ch.channelId)
+    const engine = getEngine(h.manager)
+
+    // worker 忙时 HITL stop
+    await h.manager.submitChannelTask({ channelId: ch.channelId, title: '停止测试任务1' })
+    await waitUntil(() => h.manager.getChannelAgent(w1.id)?.runtimeState === 'busy', 8000)
+    const stopped = await h.manager.stopAgentRuntime(ch.channelId, w1.id, 'test')
+    check('stopAgentRuntime 返回成功', stopped.stopped === true)
+    check('worker 运行时已卸载(detached)', h.manager.getChannelAgent(w1.id)?.wired === false
+    || h.manager.getChannelAgent(w1.id) === undefined)
+    const members = await h.manager.listChannelAgents(ch.channelId)
+    check('worker 成员行保留(interrupt 语义)', members.some(m => m.id === w1.id))
+
+    // 中断后可重新装配执行新任务
+    const t2 = await h.manager.submitChannelTask({ channelId: ch.channelId, title: '停止后重装任务' })
+    const done2 = await waitUntil(() => engine.get(t2.id)?.state === 'COMPLETED', 15_000)
+    check('stop 后新任务自动重新装配并完成', done2, `state=${engine.get(t2.id)?.state}`)
+
+    // lead 停止:调度器随停;下次提交自动重激活
+    const lead = (await h.manager.listChannelAgents(ch.channelId)).find(m => m.role === 'lead')!
+    await h.manager.stopAgentRuntime(ch.channelId, lead.id, 'test')
+    const cr = (h.manager as unknown as { channels: Map<string, { scheduler: unknown }> }).channels.get(ch.channelId)
+    check('lead 停止后调度器已停', cr?.scheduler === null || cr?.scheduler === undefined)
+
+    const t3 = await h.manager.submitChannelTask({ channelId: ch.channelId, title: 'lead 重启后任务' })
+    const done3 = await waitUntil(() => engine.get(t3.id)?.state === 'COMPLETED', 20_000)
+    check('lead 停止后提交任务自动重激活并完成', done3, `state=${engine.get(t3.id)?.state}`)
+  }
+  finally {
+    await cleanup(h)
+  }
+}
+
+// ===== D. 任务 HITL:取消 + 重试(lead 根任务 / worker 子任务均可) =====
+async function testTaskHITL(): Promise<void> {
+  console.log('\n━━━ D. 任务 HITL:用户取消 / 重试(mock)━━━')
+
+  const h = setup()
+  try {
+    const ch = await h.manager.createChannel({
+      name: '任务HITL测试',
+      leadAgent: { name: 'lead', harness: 'mock', config: { delayMs: 20 } },
+    })
+    // 慢 worker:拉开 HITL 操作时间窗,防任务在操作前自然完成(300ms×3 进度 ≈ 1s 一轮)
+    const w1 = await h.manager.addAgentToChannel({
+      channelId: ch.channelId,
+      agentId: (await h.manager.createAgent({ name: 'w1', harness: 'mock', config: { delayMs: 300 } })).id,
+      role: 'worker',
+    })
+    attachScheduler(h.manager, ch.channelId)
+    const engine = getEngine(h.manager)
+    const lead = (await h.manager.listChannelAgents(ch.channelId)).find(m => m.role === 'lead')!
+
+    // 1. lead 根任务取消(HITL):提交后立即取消(SUBMITTED/WORKING/WAITING 均合法,1s 内不会完成)
+    const t1 = await h.manager.submitChannelTask({ channelId: ch.channelId, title: '根任务可取消' })
+    await sleep(150) // 等 lead 接取/派发(快照稳定)
+    const canceledRoot = await h.manager.cancelTask(ch.channelId, lead.id, { taskId: t1.id })
+    check('lead 根任务可被用户取消', canceledRoot.state === 'CANCELED', `state=${canceledRoot.state}`)
+
+    // 2. worker 子任务取消(HITL):子任务执行中取消
+    const t2 = await h.manager.submitChannelTask({ channelId: ch.channelId, title: '子任务可取消' })
+    const child2 = await waitChildOf(h, engine, ch.channelId, t2.id)
+    check('子任务已派发并执行(测试前置)', !!child2 && child2?.state === 'WORKING', `state=${child2?.state}`)
+    const canceledChild = await h.manager.cancelTask(ch.channelId, lead.id, { taskId: child2!.id })
+    check('worker 子任务可被用户取消', canceledChild.state === 'CANCELED', `state=${canceledChild.state}`)
+
+    // 3. FAILED 任务重试(HITL):子任务置 FAILED 后经 retryTask 恢复执行
+    const t3 = await h.manager.submitChannelTask({ channelId: ch.channelId, title: '可重试任务' })
+    const child3 = await waitChildOf(h, engine, ch.channelId, t3.id)
+    check('重试目标已派发(测试前置)', !!child3)
+    engine.transition(child3!.id, 'FAILED', lead.id)
+    check('任务已置 FAILED(测试前置)', engine.get(child3!.id)?.state === 'FAILED')
+    const retried = await h.manager.retryTask(ch.channelId, lead.id, child3!.id)
+    check('retryTask 重新指派(FAILED→ASSIGNED)', retried.state === 'ASSIGNED', `state=${retried.state} assignee=${retried.assigneeId === w1.id ? 'w1' : retried.assigneeId.slice(0, 8)}`)
+    const done = await waitUntil(() => engine.get(child3!.id)?.state === 'COMPLETED', 15_000)
+    check('重试后任务正常完成', done, `state=${engine.get(child3!.id)?.state}`)
+
+    // 4. 非 FAILED 重试拒绝
+    let rejected = false
+    try {
+      await h.manager.retryTask(ch.channelId, lead.id, child3!.id)
+    }
+    catch {
+      rejected = true
+    }
+    check('非 FAILED 任务重试被拒绝(400)', rejected)
+
+    // 5. 无可用 worker 时重试拒绝(移除全部 worker 后)
+    const t4 = await h.manager.submitChannelTask({ channelId: ch.channelId, title: '无人重试任务' })
+    const child4 = await waitChildOf(h, engine, ch.channelId, t4.id)
+    if (child4) engine.transition(child4.id, 'FAILED', lead.id)
+    else engine.transition(t4.id, 'FAILED', lead.id)
+    const allWorkers = (await h.manager.listChannelAgents(ch.channelId)).filter(m => m.role === 'worker')
+    for (const w of allWorkers) {
+      await h.manager.removeTeamMember(ch.channelId, lead.id, w.id, '移除全部 worker')
+    }
+    const failedId = child4?.id ?? t4.id
+    let noWorker = false
+    try {
+      await h.manager.retryTask(ch.channelId, lead.id, failedId)
+    }
+    catch {
+      noWorker = true
+    }
+    check('无可用 worker 时重试返回 NO_WORKER', noWorker)
+  }
+  finally {
+    await cleanup(h)
+  }
+}
+
+/** 等待根任务派发出子任务(返回子任务;超时返回 undefined) */
+async function waitChildOf(
+  h: Harness,
+  engine: ReturnType<typeof getEngine>,
+  channelId: string,
+  rootId: string,
+  timeoutMs = 8000,
+): Promise<WorkspaceTask | undefined> {
+  let child: WorkspaceTask | undefined
+  await waitUntil(() => {
+    child = engine.list(channelId).find(t => t.parentId === rootId && t.state !== 'COMPLETED' && t.state !== 'CANCELED')
+    return !!child
+  }, timeoutMs)
+  return child
+}
+
+async function main(): Promise<void> {
+  console.log('╔══════════════════════════════════════════════════════════════╗')
+  console.log('║  HITL 与成员生命周期验证(mock):建员装配/删员卸载/独立stop/任务控制  ║')
+  console.log('╚══════════════════════════════════════════════════════════════╝')
+
+  await testLeadSpawnWiresMember()
+  await testLeadRemoveUnloadsAndDeletes()
+  await testStopAgentRuntime()
+  await testTaskHITL()
+
+  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-koda-restyle.mjs

@@ -0,0 +1,105 @@
+/**
+ * koda 风格重塑视觉核验(puppeteer):
+ *  - 亮/暗双主题截图(仪表盘 + 工作台控制台)
+ *  - DOM 断言:body 纯 canvas(无网格背景)、侧栏浅暖底、菜单 light、
+ *              顶栏 56px hairline、航迹 chip active 黑底、antd 圆角 10
+ * 运行:node scripts/test-koda-restyle.mjs
+ */
+import puppeteer from 'puppeteer-core'
+import { mkdirSync } from 'node:fs'
+
+const BASE = process.env.AW_BASE ?? 'http://127.0.0.1:3101'
+const EDGE = process.env.EDGE_PATH ?? 'C:/Program Files (x86)/Microsoft/Edge/Application/msedge.exe'
+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
+}
+
+async function main() {
+  mkdirSync('data/shots', { recursive: true })
+  const browser = await puppeteer.launch({
+    executablePath: EDGE,
+    headless: 'new',
+    args: ['--no-sandbox', '--disable-gpu', '--window-size=1500,900'],
+    defaultViewport: { width: 1500, height: 900 },
+  })
+  const page = await browser.newPage()
+  await page.goto(`${BASE}/`, { waitUntil: 'domcontentloaded' })
+  await sleep(2500)
+
+  // ── 亮色主题断言 ──
+  const light = await page.evaluate(() => {
+    const body = getComputedStyle(document.body)
+    const sider = document.querySelector('.app-sider')
+    const header = document.querySelector('.app-header')
+    const menu = document.querySelector('.app-menu')
+    const btn = document.querySelector('.ant-btn')
+    return {
+      bodyBg: body.backgroundColor,
+      bodyImage: body.backgroundImage,
+      siderBg: sider ? getComputedStyle(sider).backgroundColor : '',
+      headerH: header ? getComputedStyle(header).height : '',
+      headerBorder: header ? getComputedStyle(header).borderBottomColor : '',
+      menuLight: menu ? !menu.className.includes('ant-menu-dark') : false,
+      btnRadius: btn ? getComputedStyle(btn).borderRadius : '',
+      link: document.querySelector('a') ? getComputedStyle(document.querySelector('a')).color : '',
+    }
+  })
+  check('L1 body 纯暖纸 canvas(#f9f7f3,无网格)', light.bodyBg === 'rgb(249, 247, 243)' && (light.bodyImage === 'none' || light.bodyImage.includes('gradient') === false), light.bodyBg)
+  check('L2 侧栏浅暖底(#f7f3ec)', light.siderBg === 'rgb(247, 243, 236)', light.siderBg)
+  check('L3 菜单 light 主题', light.menuLight, '')
+  check('L4 顶栏 56px', light.headerH === '56px', light.headerH)
+  check('L5 antd 圆角 10px', light.btnRadius === '10px', light.btnRadius)
+  await page.screenshot({ path: 'data/shots/koda-light-dashboard.png' })
+
+  // ── 工作台控制台(航迹 + 块)亮色 ──
+  await page.goto(`${BASE}/workshop`, { waitUntil: 'domcontentloaded' })
+  await sleep(2200)
+  // 登录门或工作区列表:导航至已有 ui-term?直接截图观察结构即可;检查航迹 chip 样式(在 /workshop 页已有 trail)
+  const trail = await page.evaluate(() => {
+    const node = document.querySelector('.trail-node')
+    const active = document.querySelector('.trail-node.active')
+    return {
+      nodeBg: node ? getComputedStyle(node).backgroundColor : '',
+      nodeRadius: node ? getComputedStyle(node).borderRadius : '',
+      activeBg: active ? getComputedStyle(active).backgroundColor : '',
+      activeColor: active ? getComputedStyle(active).color : '',
+    }
+  })
+  check('L6 航迹 chip:panel-soft 底 + 8px 圆角', trail.nodeBg === 'rgb(245, 243, 235)' && trail.nodeRadius === '8px', `${trail.nodeBg} ${trail.nodeRadius}`)
+  check('L7 航迹 active 黑底白字', trail.activeBg === 'rgb(0, 0, 0)' || trail.activeBg === 'rgb(16, 16, 16)', trail.activeBg)
+  await page.screenshot({ path: 'data/shots/koda-light-workshop.png' })
+
+  // ── 暗色主题 ──
+  await page.evaluate(() => {
+    window.localStorage.setItem('app', JSON.stringify({ isDark: true, sidebarCollapsed: false }))
+  })
+  await page.reload({ waitUntil: 'domcontentloaded' })
+  await sleep(2500)
+  const dark = await page.evaluate(() => {
+    const body = getComputedStyle(document.body)
+    const active = document.querySelector('.trail-node.active')
+    return {
+      bodyBg: body.backgroundColor,
+      activeBg: active ? getComputedStyle(active).backgroundColor : '',
+    }
+  })
+  check('D1 暗色真中性 canvas(#0c0c0c)', dark.bodyBg === 'rgb(12, 12, 12)', dark.bodyBg)
+  check('D2 暗色 active 白底', dark.activeBg === 'rgb(255, 255, 255)', dark.activeBg)
+  await page.screenshot({ path: 'data/shots/koda-dark-workshop.png' })
+
+  await page.evaluate(() => window.localStorage.removeItem('app'))
+  await browser.close()
+
+  console.log(`\n★ 结果: ${passed} passed, ${failures} failed`)
+  process.exit(failures === 0 ? 0 : 1)
+}
+
+main().catch((err) => {
+  console.error('异常:', err.message)
+  process.exit(1)
+})

package/scripts/test-lane-history-live.mjs

@@ -0,0 +1,103 @@
+/**
+ * Lane 历史加载端到端验证(针对 pnpm dev 起的 3000 服务):
+ *  1. 注册用户 → 建 channel(mock lead)→ goal 任务跑完(产生 agent.status/
+ *     agent.message/a2a.message/task.status 等真实事件,常驻录制器落库);
+ *  2. GET /channels/:id/events 全量历史:信封形状 + 消息在场;
+ *  3. ?agentId=&excludeTypes=agent.delta:lane 按需加载口径(仅该 agent、无过程帧);
+ *  4. beforeSeq 翻页 + total 同口径;
+ *  5. 清理测试 channel。
+ * 运行: node scripts/test-lane-history-live.mjs
+ */
+const BASE = process.env.AW_BASE ?? 'http://127.0.0.1:3000'
+
+let failures = 0
+const check = (name, ok, detail = '') => {
+  console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` — ${detail}` : ''}`)
+  if (!ok) failures += 1
+}
+
+async function api(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(() => ({}))) }
+}
+
+const waitUntil = async (name, probe, timeoutMs = 20_000) => {
+  const t0 = Date.now()
+  while (Date.now() - t0 < timeoutMs) {
+    const v = await probe()
+    if (v) return v
+    await new Promise(r => setTimeout(r, 300))
+  }
+  throw new Error(`等待超时: ${name}`)
+}
+
+const tag = Math.random().toString(36).slice(2, 8)
+const user = await api('POST', '/api/workshop/users/register', { body: { name: `lane-hist-${tag}` } })
+if (!user.data?.token) {
+  console.error('用户注册失败:', user)
+  process.exit(1)
+}
+const token = user.data.token
+console.log(`用户 lane-hist-${tag} 就绪`)
+
+const ch = await api('POST', '/api/workshop/channels', {
+  token,
+  body: {
+    name: `lane-history-${tag}`,
+    leadAgent: { name: 'lead-mock', harness: 'mock', config: { delayMs: 60 } },
+  },
+})
+check('创建 channel(含 mock lead)', ch.code === 0 && ch.data?.channelId, `channel=${ch.data?.channelId?.slice(0, 8)}`)
+const channelId = ch.data.channelId
+const leadId = ch.data.leadAgentId
+
+try {
+  await api('POST', `/api/workshop/channels/${channelId}/activate`, { token })
+  const task = await api('POST', `/api/workshop/channels/${channelId}/tasks`, {
+    token,
+    body: { title: `lane-history-${tag}`, description: '验证历史持久化与按 agent 加载', mode: 'goal', modeConfig: { goalCriteria: '全部完成' } },
+  })
+  check('提交 goal 任务', task.code === 0 && task.data?.state === 'SUBMITTED', `state=${task.data?.state}`)
+  // 任务执行到 WORKING 即已产生足够事件(录制器落库);不依赖终态(与历史加载验证正交)
+  const enough = await waitUntil('事件落库', async () => {
+    const e = await api('GET', `/api/workshop/channels/${channelId}/events?limit=500`, { token })
+    return (e.data?.items ?? []).length >= 4 ? e.data.items : null
+  })
+  check('事件已持久化(WORKING 阶段)', enough.length >= 4, `events=${enough.length}`)
+  const items = enough
+
+  // ── 1. 全量历史(items 已在上方取到)──
+  const shapeOk = items.every(e => e.v === 1 && typeof e.seq === 'number' && e.type && e.at && e.channelId === channelId)
+  check('AEP 信封同构形状', shapeOk)
+  check('事件类型覆盖(消息+状态+任务)', ['a2a.message', 'agent.status', 'task.status'].every(t => items.some(e => e.type === t)),
+    [...new Set(items.map(e => e.type))].join(','))
+
+  // ── 2. lane 口径:agentId + excludeTypes ──
+  const lane = await api('GET', `/api/workshop/channels/${channelId}/events?agentId=${leadId}&excludeTypes=agent.delta&limit=100`, { token })
+  const laneItems = lane.data?.items ?? []
+  check('agentId 过滤仅返回该 agent', laneItems.length > 0 && laneItems.every(e => e.agentId === leadId), `items=${laneItems.length}`)
+  check('excludeTypes 剔除过程帧', laneItems.every(e => e.type !== 'agent.delta'))
+  check('lane 历史含该 agent 事件', laneItems.some(e => e.type === 'agent.status' || e.type === 'task.status' || e.type === 'a2a.message'),
+    `types=${[...new Set(laneItems.map(e => e.type))].join(',')}`)
+  check('total 与过滤同口径', lane.data?.total === laneItems.length, `total=${lane.data?.total} items=${laneItems.length}`)
+
+  // ── 3. beforeSeq 翻页(lane 维度) ──
+  const midSeq = laneItems[Math.floor(laneItems.length / 2)]?.seq
+  const page = await api('GET', `/api/workshop/channels/${channelId}/events?agentId=${leadId}&excludeTypes=agent.delta&beforeSeq=${midSeq}&limit=100`, { token })
+  const pageItems = page.data?.items ?? []
+  check('beforeSeq 翻页全部早于游标', pageItems.length > 0 && pageItems.every(e => e.seq < midSeq && e.agentId === leadId),
+    `items=${pageItems.length} < seq${midSeq}`)
+
+  // ── 4. 鉴权:无 token 拒绝 ──
+  const noAuth = await api('GET', `/api/workshop/channels/${channelId}/events`)
+  check('无 token 401', noAuth.status === 401, `status=${noAuth.status}`)
+}
+finally {
+  const del = await api('DELETE', `/api/workshop/channels/${channelId}`, { token })
+  console.log(`清理测试 channel:${del.code === 0 ? '已删除' : `失败(${del.code})`}`)
+}
+
+console.log(failures === 0 ? '\n全部通过 ✔' : `\n${failures} 项失败 ✘`)
+process.exit(failures === 0 ? 0 : 1)

package/scripts/test-lane-raw.ts

@@ -0,0 +1,67 @@
+/**
+ * LaneBlocks raw 模式逻辑回归(Node 级):pinia + vue 直接驱动
+ * useClusteredBlocks(raw),断言 lane 聚类产块/隔离/实时更新/合并语义。
+ * 运行:pnpm exec tsx scripts/test-lane-raw.ts
+ */
+import { createPinia, setActivePinia } from 'pinia'
+import { nextTick } from 'vue'
+import { useEventsStore } from '../app/stores/workshop/events'
+// Nuxt auto-import 的 toValue 在纯 Node 环境手动注入(useClusteredBlocks 未显式 import)
+;
+
+(globalThis as { toValue?: unknown }).toValue = (v: unknown): unknown =>
+  typeof v === 'function' ? (v as () => unknown)() : v
+
+let failures = 0
+const check = (name: string, ok: boolean, detail = ''): void => {
+  console.log(`  [${ok ? 'PASS' : 'FAIL'}] ${name}${detail ? ` — ${detail}` : ''}`)
+  if (!ok) failures += 1
+}
+
+async function main(): Promise<void> {
+  setActivePinia(createPinia())
+  const events = useEventsStore()
+  const { useClusteredBlocks } = await import('../app/composables/workshop/useClusteredBlocks')
+
+  const { blocks, totalEvents } = useClusteredBlocks(
+    () => 'c1',
+    { predicate: (e: { agentId?: string | null }) => e.agentId === 'w1', resetKey: () => 'w1', raw: true },
+  )
+
+  const env = (seq: number, type: string, payload: Record<string, unknown>, agentId?: string) =>
+    ({ v: 1, type, seq, at: 't', channelId: 'c1', agentId, payload }) as never
+
+  events.ingest(env(1, 'channel.snapshot', {}))
+  events.ingest(env(2, 'agent.status', { state: 'busy' }, 'w1'))
+  await nextTick()
+  check('基础事件成块(life)', blocks.value.length === 1 && blocks.value[0]!.kind === 'life', `blocks=${blocks.value.length}`)
+
+  events.ingest(env(3, 'agent.delta', { delta: 'hello' }, 'w1'))
+  events.ingest(env(4, 'agent.delta', { delta: ' world' }, 'w1'))
+  await nextTick()
+  const stream = blocks.value.find(b => b.kind === 'stream')
+  check('delta 流成 stream 块', !!stream)
+  check('连续 delta 在 store 层合并为单 item(全文完整)', stream !== undefined
+  && stream.events.length === 1
+  && (stream.events[0] as { payload?: { delta?: string } }).payload?.delta === 'hello world', `events=${stream?.events.length}`)
+
+  events.ingest(env(5, 'agent.status', { state: 'idle' }, 'w2'))
+  await nextTick()
+  check('其他 agent 事件不进本 lane', blocks.value.length === 2, `blocks=${blocks.value.length}`)
+  check('totalEvents 只计谓词内事件(合并后 2 item)', totalEvents.value === 2, `total=${totalEvents.value}`)
+
+  // 历史回填(头部插入)→ 重建不重复
+  const history = [env(1, 'task.status', { state: 'SUBMITTED' })]
+  const ring = (events as unknown as { rings: Record<string, { items: unknown[] }> }).rings.c1!
+  for (const e of history) if (!ring.items.some(x => (x as { seq: number }).seq === (e as unknown as { seq: number }).seq)) ring.items.push(e)
+  ring.items.sort((a, b) => (a as { seq: number }).seq - (b as { seq: number }).seq)
+  await nextTick()
+  check('历史头部插入后重建(块仍只含本 lane 事件)', blocks.value.every(b => b.agentId === 'w1' || b.agentId === undefined), `blocks=${blocks.value.length}`)
+
+  console.log(failures === 0 ? '\n★ raw lane 聚类回归通过' : `\n${failures} 项失败`)
+  process.exit(failures === 0 ? 0 : 1)
+}
+main().catch((err) => {
+  console.error('回归异常:', err)
+  process.exit(1)
+})