agentworkshop 0.2.1

package/scripts/e2e-resume-crash.mjs

@@ -0,0 +1,254 @@
+/**
+ * 断线重连 + 状态持久化 端到端真实测试(对运行中的 dev server)。
+ *
+ * 场景 A(常规执行监控):用已有 channel 的 lead 配置一个新的慢速 channel
+ *  (mock delayMs=4000),提交任务 → 轮询观察 WORKING → COMPLETED → 全员 idle。
+ * 场景 B(断线重连):提交慢任务 → 等到 WORKING → 硬杀服务器(taskkill /F,模拟崩溃)
+ *  → 验证 DB 中任务停留 WORKING(状态持久化)→ 重启服务器 → 验证任务被自动
+ *  重新装配执行至 COMPLETED(断线重连),且 agent 回 idle。
+ * 场景 C(消费缺口重投):直接 sqlite 把 WORKING 任务的 assign 消息改为 consumed
+ *  (模拟"消息已消费但任务未完成"缺口)→ 重启 → restore 重投 → COMPLETED。
+ *
+ * 用法:
+ *   node scripts/e2e-resume-crash.mjs watch        # 场景 A
+ *   node scripts/e2e-resume-crash.mjs crash        # 场景 B(杀服务器→输出状态→退出)
+ *   node scripts/e2e-resume-crash.mjs verify       # 场景 B(重启后验证自动恢复)
+ *   node scripts/e2e-resume-crash.mjs gap          # 场景 C(制造缺口→杀→退出)
+ *   node scripts/e2e-resume-crash.mjs verify-gap   # 场景 C(重启后验证重投恢复)
+ */
+import { DatabaseSync } from 'node:sqlite'
+
+const BASE = 'http://127.0.0.1:3000/api/workshop'
+const DB_PATH = 'data/workshop.sqlite'
+const DELAY_MS = 6000
+
+let pass = 0
+let fail = 0
+function check(name, ok, detail = '') {
+  console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` — ${detail}` : ''}`)
+  if (ok) pass++
+  else fail++
+}
+const sleep = ms => new Promise(r => setTimeout(r, ms))
+
+// 用户级隔离:注册测试用户;管理面 API 全程携带用户 token。
+// 跨阶段复用(crash→重启→verify):AW_RESUME_TOKEN 环境变量优先 —— verify 阶段的 channel
+// 属于 crash 阶段注册的用户,新注册用户看不该 channel(403),必须沿用同一 token。
+let __user
+if (process.env.AW_RESUME_TOKEN) {
+  __user = { data: { token: process.env.AW_RESUME_TOKEN } }
+}
+else {
+  __user = await fetch(BASE + '/users/register', {
+    method: 'POST', headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ name: 'e2e-' + Math.random().toString(36).slice(2, 10) }),
+  }).then(r => r.json()).catch(() => null)
+}
+const __userToken = __user?.data?.token
+if (!__userToken) {
+  console.error('用户注册失败')
+  process.exit(1)
+}
+
+async function req(method, path, body) {
+  const res = await fetch(`${BASE}${path}`, {
+    method,
+    headers: {
+      authorization: `Bearer ${__userToken}`,
+      ...(body ? { 'content-type': 'application/json' } : {}),
+    },
+    body: body ? JSON.stringify(body) : undefined,
+  })
+  return { status: res.status, json: await res.json().catch(() => null) }
+}
+
+/** 直接查 sqlite(WAL 只读;镜像进程外视角验证持久化) */
+function dbQuery(sql, ...params) {
+  const db = new DatabaseSync(DB_PATH, { readOnly: true })
+  try {
+    return db.prepare(sql).all(...params)
+  }
+  finally {
+    db.close()
+  }
+}
+
+async function makeSlowChannel(name) {
+  // 独立慢速 channel:lead + 1 worker,全部 mock delayMs=DELAY_MS
+  const leadTpl = await req('POST', '/agents', { name: `${name}-lead`, harness: 'mock', config: { delayMs: DELAY_MS } })
+  const workerTpl = await req('POST', '/agents', { name: `${name}-worker`, harness: 'mock', config: { delayMs: DELAY_MS } })
+  const ch = await req('POST', '/channels', { name, description: `resume e2e ${name}` })
+  const channelId = ch.json.data.channelId
+  await req('POST', `/channels/${channelId}/agents`, { agentId: leadTpl.json.data.id, role: 'lead' })
+  await req('POST', `/channels/${channelId}/agents`, { agentId: workerTpl.json.data.id, role: 'worker' })
+  return channelId
+}
+
+async function submitTask(channelId, title) {
+  const r = await req('POST', `/channels/${channelId}/tasks`, { title, description: `${title} — resume e2e` })
+  return r.json.data.id
+}
+
+async function waitState(taskId, states, timeoutMs) {
+  const start = Date.now()
+  let last = ''
+  while (Date.now() - start < timeoutMs) {
+    const { json } = await req('GET', `/tasks/${taskId}`)
+    last = json?.data?.state ?? '(none)'
+    if (states.includes(last)) return last
+    await sleep(400)
+  }
+  return last
+}
+
+// ───────── 场景 A:常规执行监控 ─────────
+async function watch() {
+  console.log('━━━ 场景 A:提交任务 → 监控 WORKING → COMPLETED → idle ━━━')
+  const channelId = await makeSlowChannel('watch')
+  const taskId = await submitTask(channelId, 'watch-task')
+  check('提交任务', !!taskId, `task=${taskId.slice(0, 8)}…`)
+
+  // 观察到 WORKING(子任务执行中)
+  const sawWorking = await waitState(taskId, ['WORKING'], 8000) === 'WORKING'
+  // 注:父任务 WAITING、子任务 WORKING;查 channel 任务列表确认有 WORKING
+  const chTasks = await req('GET', `/channels/${channelId}/tasks`)
+  const anyWorking = (chTasks.json.data ?? []).some(t => t.state === 'WORKING')
+  check('执行中出现 WORKING(真实执行)', sawWorking || anyWorking, `sawWorking=${sawWorking} anyWorking=${anyWorking}`)
+
+  const finalState = await waitState(taskId, ['COMPLETED', 'FAILED', 'CANCELED'], 30_000)
+  check('任务执行至 COMPLETED', finalState === 'COMPLETED', `state=${finalState}`)
+
+  // 全员 idle(执行完成的 agent 状态必须回空闲)
+  await sleep(1500)
+  const queue = await req('GET', `/channels/${channelId}/queue`)
+  const states = (queue.json.data ?? []).map(a => `${a.name}:${a.state}`)
+  check('执行完成后全员 idle', (queue.json.data ?? []).every(a => a.state === 'idle'), JSON.stringify(states))
+
+  await req('DELETE', `/channels/${channelId}`)
+  console.log(`\n结果: PASS=${pass} FAIL=${fail}`)
+  process.exit(fail === 0 ? 0 : 1)
+}
+
+// ───────── 场景 B:崩溃 → 持久化 → 重启自动恢复 ─────────
+async function crash() {
+  console.log('━━━ 场景 B:WORKING 中硬杀服务器 → 验证 DB 持久化 ━━━')
+  const channelId = await makeSlowChannel('crash')
+  const taskId = await submitTask(channelId, 'crash-task')
+  await waitState(taskId, ['WORKING', 'WAITING'], 8000)
+  const chTasks = await req('GET', `/channels/${channelId}/tasks`)
+  const working = (chTasks.json.data ?? []).find(t => t.state === 'WORKING')
+  check('杀前存在 WORKING 任务', !!working, working ? `task=${working.id.slice(0, 8)}…` : '')
+  if (!working) process.exit(1)
+
+  // 硬杀(taskkill /F 不走 graceful close,模拟崩溃断电)
+  const { execSync } = await import('node:child_process')
+  const pid = execSync('netstat -ano | findstr :3000 | findstr LISTENING').toString().match(/(\d+)\s*$/)?.[1]
+  execSync(`taskkill /PID ${pid} /F`)
+  console.log(`  服务器已硬杀(pid=${pid})`)
+  await sleep(1200)
+
+  // 进程外视角直接查 sqlite:WORKING 必须持久化在盘上
+  const rows = dbQuery('SELECT id, state FROM tasks WHERE id = ?', working.id)
+  check('崩溃后 DB 中任务仍 WORKING(持久化)', rows[0]?.state === 'WORKING', `db.state=${rows[0]?.state}`)
+  // 写入标记文件供 verify 阶段使用
+  const { writeFileSync } = await import('node:fs')
+  writeFileSync('.resume-test.json', JSON.stringify({ channelId, taskId, workerTaskId: working.id, token: __userToken }))
+  console.log(`  标记写入 .resume-test.json (channel=${channelId.slice(0, 8)}… task=${taskId.slice(0, 8)}…)`)
+  console.log(`\n结果: PASS=${pass} FAIL=${fail}`)
+  process.exit(fail === 0 ? 0 : 1)
+}
+
+async function verify() {
+  console.log('━━━ 场景 B:重启 → 断线重连自动恢复执行 ━━━')
+  const { readFileSync, unlinkSync } = await import('node:fs')
+  const mark = JSON.parse(readFileSync('.resume-test.json', 'utf8'))
+  console.log(`  恢复目标: task=${mark.taskId.slice(0, 8)}… (workerTask=${mark.workerTaskId.slice(0, 8)}…)`)
+
+  // 重启后立即查 DB:消息应已重投(resetConsuming/redeliverAssign 落库)。
+  // dev server 首次请求才懒编译路由,restore 在 HTTP 可达前已跑完 —— 慢 worker 可能
+  // 已被快速接走甚至完成(consumed),故按"存在重投轨迹"断言(pending/consuming/consumed)。
+  const pending = dbQuery(
+    `SELECT COUNT(*) AS n FROM messages WHERE task_id = ? AND state IN ('pending', 'consuming', 'consumed')`,
+    mark.workerTaskId,
+  )
+  check('重启后 assign 重投轨迹存在(pending/consuming/consumed)', pending[0].n > 0, `trail=${pending[0].n}`)
+
+  // 等待自动恢复执行至 COMPLETED(restore 唤醒 → worker 重放)
+  const finalState = await waitState(mark.taskId, ['COMPLETED', 'FAILED', 'CANCELED'], 40_000)
+  check('断线重连:任务自动恢复至 COMPLETED', finalState === 'COMPLETED', `state=${finalState}`)
+
+  const wState = await req('GET', `/tasks/${mark.workerTaskId}`)
+  check('子任务 COMPLETED(lead 完成一项标记一项)', wState.json.data.state === 'COMPLETED', `state=${wState.json.data.state}`)
+
+  await sleep(1500)
+  const queue = await req('GET', `/channels/${mark.channelId}/queue`)
+  const states = (queue.json.data ?? []).map(a => `${a.name}:${a.state}`)
+  check('恢复执行后全员 idle', (queue.json.data ?? []).every(a => a.state === 'idle'), JSON.stringify(states))
+
+  await req('DELETE', `/channels/${mark.channelId}`)
+  unlinkSync('.resume-test.json')
+  console.log(`\n结果: PASS=${pass} FAIL=${fail}`)
+  process.exit(fail === 0 ? 0 : 1)
+}
+
+// ───────── 场景 C:消费缺口重投(消息已 consumed 但任务未完成) ─────────
+async function gap() {
+  console.log('━━━ 场景 C:assign 已 consumed + 任务 WORKING → 重启必须重投 ━━━')
+  const channelId = await makeSlowChannel('gap')
+  const taskId = await submitTask(channelId, 'gap-task')
+  await waitState(taskId, ['WORKING', 'WAITING'], 8000)
+  const chTasks = await req('GET', `/channels/${channelId}/tasks`)
+  const working = (chTasks.json.data ?? []).find(t => t.state === 'WORKING')
+  check('制造 WORKING 任务', !!working)
+  if (!working) process.exit(1)
+
+  // 硬杀服务器
+  const { execSync } = await import('node:child_process')
+  const pid = execSync('netstat -ano | findstr :3000 | findstr LISTENING').toString().match(/(\d+)\s*$/)?.[1]
+  execSync(`taskkill /PID ${pid} /F`)
+  await sleep(1200)
+
+  // 进程外直接把该任务全部消息标为 consumed(模拟极端缺口:消息已消费但任务未完成)
+  const db = new DatabaseSync(DB_PATH)
+  db.exec(`UPDATE messages SET state = 'consumed', consumed_at = datetime('now') WHERE task_id = '${working.id}'`)
+  const left = db.prepare(`SELECT COUNT(*) AS n FROM messages WHERE task_id = ? AND state != 'consumed'`).get(working.id)
+  db.close()
+  check('缺口已制造(无任何待消费消息)', left.n === 0, `remaining=${left.n}`)
+
+  const { writeFileSync } = await import('node:fs')
+  writeFileSync('.resume-test.json', JSON.stringify({ channelId, taskId, workerTaskId: working.id, token: __userToken }))
+  console.log(`\n结果: PASS=${pass} FAIL=${fail}`)
+  process.exit(fail === 0 ? 0 : 1)
+}
+
+async function verifyGap() {
+  console.log('━━━ 场景 C:重启 → restore 重投缺口 assign → 自动恢复 ━━━')
+  const { readFileSync, unlinkSync } = await import('node:fs')
+  const mark = JSON.parse(readFileSync('.resume-test.json', 'utf8'))
+
+  const pending = dbQuery(
+    `SELECT COUNT(*) AS n FROM messages WHERE task_id = ? AND state IN ('pending','consuming','consumed') AND metadata_json LIKE '%"x-aw-task-kind":"assign"%'`,
+    mark.workerTaskId,
+  )
+  check('restore 重投缺口 assign(轨迹存在)', pending[0].n > 0, `assign-trail=${pending[0].n}`)
+
+  const finalState = await waitState(mark.taskId, ['COMPLETED', 'FAILED', 'CANCELED'], 40_000)
+  check('缺口任务自动恢复至 COMPLETED', finalState === 'COMPLETED', `state=${finalState}`)
+
+  await sleep(1500)
+  const queue = await req('GET', `/channels/${mark.channelId}/queue`)
+  check('恢复后全员 idle', (queue.json.data ?? []).every(a => a.state === 'idle'))
+
+  await req('DELETE', `/channels/${mark.channelId}`)
+  unlinkSync('.resume-test.json')
+  console.log(`\n结果: PASS=${pass} FAIL=${fail}`)
+  process.exit(fail === 0 ? 0 : 1)
+}
+
+const mode = process.argv[2] ?? 'watch'
+const modes = { watch, crash, verify, gap, 'verify-gap': verifyGap }
+if (!modes[mode]) {
+  console.error(`未知模式: ${mode}`)
+  process.exit(2)
+}
+await modes[mode]()

package/scripts/e2e-tab-close.mjs

@@ -0,0 +1,136 @@
+/**
+ * Header 航迹标签页关闭功能验证:
+ *  1. 访问多个页面 → 标签按序累积
+ *  2. 悬停标签 → 关闭钮展开显示
+ *  3. 关闭非当前页 → 标签移除、路由不变
+ *  4. 关闭当前页 → 标签移除 + 跳转至左侧相邻航点(兜底仪表盘)
+ *  5. 刷新后移除状态保持(localStorage 持久化)
+ */
+import puppeteer from 'puppeteer-core'
+import { mkdirSync } from 'node:fs'
+
+const BASE = process.env.BASE_URL ?? 'http://localhost:3001'
+const EDGE = 'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe'
+const SHOT_DIR = '.design-verify'
+const sleep = ms => new Promise(r => setTimeout(r, ms))
+
+const api = async (method, path, { body } = {}) => {
+  const res = await fetch(`${BASE}${path}`, {
+    method,
+    headers: { 'content-type': 'application/json' },
+    body: body ? JSON.stringify(body) : undefined,
+  })
+  return res.json()
+}
+
+let pass = 0
+let fail = 0
+function check(name, ok, detail = '') {
+  console.log(`${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` — ${detail}` : ''}`)
+  if (ok) {
+    pass++
+  }
+  else {
+    fail++
+  }
+}
+
+async function main() {
+  mkdirSync(SHOT_DIR, { recursive: true })
+  const stamp = Date.now().toString(36)
+  const email = `tab-ui-${stamp}@test.local`
+  await api('POST', '/api/users/register', { body: { name: `tabui-${stamp}`, email, password: 'Passw0rd!123' } })
+
+  const browser = await puppeteer.launch({
+    executablePath: EDGE,
+    headless: 'new',
+    args: ['--no-sandbox', '--disable-gpu'],
+    defaultViewport: { width: 1440, height: 900 },
+  })
+  const page = await browser.newPage()
+  page.on('pageerror', e => console.log('  [pageerror]', e.message.slice(0, 160)))
+
+  // 登录(冷编译时等待登录表单就绪,最多 30s)
+  await page.goto(`${BASE}/workshop`, { waitUntil: 'domcontentloaded' })
+  for (let i = 0; i < 30; i++) {
+    if (await page.$('input[type="email"]')) break
+    await sleep(1000)
+  }
+  await page.$eval('input[type="email"]', (el, v) => {
+    const set = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value').set
+    set.call(el, v)
+    el.dispatchEvent(new Event('input', { bubbles: true }))
+  }, email)
+  await page.$eval('input[type="password"]', (el, v) => {
+    const set = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value').set
+    set.call(el, v)
+    el.dispatchEvent(new Event('input', { bubbles: true }))
+  }, 'Passw0rd!123')
+  await sleep(200)
+  for (const b of await page.$$('button')) {
+    const txt = (await b.evaluate(el => el.textContent) || '').trim()
+    if (txt.replace(/\s/g, '') === '登录') {
+      await b.click()
+      break
+    }
+  }
+  await sleep(3200)
+
+  // 累积标签:仪表盘(/) → /tokens → /users → /monitor
+  for (const path of ['/tokens', '/users', '/monitor']) {
+    await page.goto(`${BASE}${path}`, { waitUntil: 'domcontentloaded' })
+    await sleep(1400)
+  }
+  const tabs1 = await page.$$eval('.trail-node', nodes => nodes.map(n => n.textContent))
+  check('T1 多页访问后标签累积(≥4)', tabs1.length >= 4, `tabs=${tabs1.length}`)
+  await page.screenshot({ path: `${SHOT_DIR}/tab-01-trail.png` })
+
+  // 悬停展开关闭钮
+  await page.hover('.trail-node:nth-child(3)')
+  await sleep(500)
+  const closeVisible = await page.$eval('.trail-node:nth-child(3) .node-close', (el) => {
+    const cs = getComputedStyle(el)
+    return cs.opacity === '1' && cs.width !== '0px'
+  })
+  check('T2 悬停标签 → 关闭钮展开', closeVisible)
+  await page.screenshot({ path: `${SHOT_DIR}/tab-02-hover-close.png` })
+
+  // 关闭非当前页(当前是 /monitor;关第 3 个 = /users)
+  const beforePath = await page.evaluate(() => location.pathname)
+  const beforeCount = tabs1.length
+  await page.click('.trail-node:nth-child(3) .node-close')
+  await sleep(900)
+  const tabs2 = await page.$$eval('.trail-node', nodes => nodes.map(n => n.textContent))
+  check('T3 关闭非当前页 → 标签移除且路由不变',
+    tabs2.length === beforeCount - 1 && await page.evaluate(() => location.pathname) === beforePath,
+    `tabs=${tabs2.length} path=${await page.evaluate(() => location.pathname)}`)
+
+  // 关闭当前页(当前 /monitor 是最后一项)
+  await page.hover('.trail-node:last-child')
+  await sleep(400)
+  await page.click('.trail-node:last-child .node-close')
+  await sleep(1200)
+  const afterPath = await page.evaluate(() => location.pathname)
+  const tabs3 = await page.$$eval('.trail-node', nodes => nodes.length)
+  check('T4 关闭当前页 → 移除并跳转相邻航点',
+    tabs3 === beforeCount - 2 && afterPath !== '/monitor' && afterPath !== '/',
+    `tabs=${tabs3} → ${afterPath}`)
+  await page.screenshot({ path: `${SHOT_DIR}/tab-03-after-close-active.png` })
+
+  // 刷新保持
+  await page.reload({ waitUntil: 'domcontentloaded' })
+  await sleep(2000)
+  const tabs4 = await page.$$eval('.trail-node', nodes => nodes.length)
+  check('T5 刷新后移除状态保持', tabs4 === tabs3, `tabs=${tabs4}`)
+  const monitorBack = await page.$$eval('.trail-node', nodes => nodes.some(n => n.textContent.includes('运行时监控')))
+  check('T6 被关页签不因刷新回补', !monitorBack)
+
+  await browser.close()
+  console.log(`\n${pass} pass / ${fail} fail`)
+  process.exit(fail > 0 ? 1 : 0)
+}
+
+main().catch((e) => {
+  console.error('UI 验证崩溃:', e)
+  process.exit(1)
+})

package/scripts/e2e-task-queue.ts

@@ -0,0 +1,277 @@
+/**
+ * 端到端验证:每个 AgentRuntime 的任务队列管理 + 实时状态追踪 + lead 统一调度分发。
+ *
+ * 场景 A(用户要求的实际测试):
+ *  1. 模拟用户向 channel 连发两个任务需求(submitChannelTask ×2)
+ *  2. 观察 lead FIFO 处理外部队列:先提交的任务先分解(dispatch 子任务 createdAt 严格递增)
+ *  3. 一轮内两个任务分给两个不同 worker(池化分配,不重复占同一个空闲 worker)
+ *  4. worker 接任务 → busy(带 currentTaskId)→ 执行 → 完成后查队列取下一个 → 队列空 → idle
+ *  5. 执行中再补两个任务 → 排队等待 → 逐个消化 → 全部完成后 worker idle
+ *
+ * 场景 B(lead 对 worker 队列的增删改查与调配,走 omp host tool 同款 manager 通道):
+ *  - 查:queueViewOf 看 worker 待执行/执行中/已完成
+ *  - 改:updateTask 修改排队任务内容,队列投递自动刷新
+ *  - 调配:reassignTask 把排队任务迁移到另一 worker,旧 assignee 队列自动清退
+ *  - 删:cancelTask 取消排队任务,过期投递作废,worker 永不执行
+ *
+ * 场景 C(omp rpc 原生集成冒烟):
+ *  - 真实 omp 子进程(--mode rpc)注册全部 host tools(含 5 个新增队列管理工具)
+ *
+ * 运行: npx tsx scripts/e2e-task-queue.ts
+ */
+import type { DatabaseSync } from 'node:sqlite'
+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 { monitorChannel } from '../server/services/workshop/runtime/monitor'
+import { HOST_TOOLS } from '../server/services/workshop/agents/omp-agent'
+import { OmpRpcClient } from '../server/services/workshop/agents/adapters/omp-rpc-client'
+import type { AgentTaskQueueView } from '../server/services/workshop/types/task'
+
+let failures = 0
+const sleep = (ms: number) => new Promise<void>(r => setTimeout(r, ms))
+
+function check(name: string, ok: boolean, detail = ''): void {
+  console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` — ${detail}` : ''}`)
+  if (!ok) failures += 1
+}
+
+function makeManager(db: DatabaseSync): AgentChannelManager {
+  return createAgentChannelManager({
+    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),
+    },
+    implFactory: createAgentImpl,
+    db,
+  })
+}
+
+/** manager 内部 TaskEngine 访问(与运行时同一实例;ws.ts 同风格类型收窄) */
+function engineOf(manager: AgentChannelManager) {
+  return (manager as unknown as {
+    getTaskEngine(): {
+      get(id: string): { id: string, title: string, state: string, assigneeId: string, createdAt: string, parentId?: string } | undefined
+      list(channelId: string): Array<{ id: string, title: string, state: string, assigneeId: string, createdAt: string, parentId?: string }>
+      queueViewOf(channelId: string, agentId: string): AgentTaskQueueView
+    }
+  }).getTaskEngine()
+}
+
+async function waitUntil(pred: () => boolean, timeoutMs: number): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    if (pred()) return true
+    await sleep(20)
+  }
+  return pred()
+}
+
+/** 场景 A + A2:两任务 FIFO 分发 → 双 worker 执行 → 追加任务排队消化 → 全部完成转空闲 */
+async function scenarioDispatchAndDrain(manager: AgentChannelManager): Promise<void> {
+  console.log('\n━━━ 场景 A:外部两任务 FIFO 分发 + worker 执行 + 追加排队消化 ━━━')
+  const ch = await manager.createChannel({
+    name: 'queue-e2e-A',
+    leadAgent: { name: 'lead-甲', harness: 'mock', config: { delayMs: 0 } },
+  })
+  const wTplA = await manager.createAgent({ name: 'worker-A', harness: 'mock', config: { delayMs: 200 } })
+  const wTplB = await manager.createAgent({ name: 'worker-B', harness: 'mock', config: { delayMs: 200 } })
+  await manager.addAgentToChannel({ channelId: ch.channelId, agentId: wTplA.id, role: 'worker' })
+  await manager.addAgentToChannel({ channelId: ch.channelId, agentId: wTplB.id, role: 'worker' })
+
+  const members = await manager.listChannelAgents(ch.channelId)
+  const workers = members.filter(m => m.role === 'worker')
+  const engine = engineOf(manager)
+
+  // 先激活 channel(装配 bus + 调度循环),monitor 才能订阅到实时事件流
+  manager.ensureChannelActive(ch.channelId, { tickMs: 50 })
+  const mon = monitorChannel(manager, ch.channelId)
+  const p1 = await manager.submitChannelTask({ channelId: ch.channelId, title: '任务一:统计苹果数', description: '读取 input 文件统计水果' })
+  const p2 = await manager.submitChannelTask({ channelId: ch.channelId, title: '任务二:汇总会议纪要', description: '汇总 note 文件' })
+  console.log(`  用户提交:P1=${p1.id.slice(0, 8)} P2=${p2.id.slice(0, 8)}`)
+
+  // 2. lead FIFO:两个父任务都被分解出子任务
+  const childOf = (parentId: string) => engine.list(ch.channelId).find(t => t.parentId === parentId)
+  const bothDispatched = await waitUntil(() => !!childOf(p1.id) && !!childOf(p2.id), 10_000)
+  check('lead FIFO 处理外部队列:两个任务都被分解分发', bothDispatched)
+  const c1 = childOf(p1.id)!
+  const c2 = childOf(p2.id)!
+  check('FIFO 顺序:先提交的任务子任务先创建', c1.createdAt <= c2.createdAt, `c1@${c1.createdAt.slice(11, 23)} c2@${c2.createdAt.slice(11, 23)}`)
+
+  // 3. 一轮内两个任务去了两个不同 worker(池化分配;若都给同一 worker 则说明分配退化)
+  check('一轮内两任务分给不同 worker(最优分配)', c1.assigneeId !== c2.assigneeId, `w=${c1.assigneeId.slice(0, 8)}/${c2.assigneeId.slice(0, 8)}`)
+
+  // 4. 执行中追加两个任务 → 排队,worker 完成当前任务后按 FIFO 消化
+  const p3 = await manager.submitChannelTask({ channelId: ch.channelId, title: '任务三:整理清单', description: '第三需求' })
+  const p4 = await manager.submitChannelTask({ channelId: ch.channelId, title: '任务四:输出报告', description: '第四需求' })
+  const allDone = await waitUntil(
+    () => [p1, p2, p3, p4].every(p => engine.get(p.id)?.state === 'COMPLETED'),
+    30_000,
+  )
+  check('4 个外部任务全部完成(排队任务被逐个消化)', allDone,
+    [p1, p2, p3, p4].map(p => `${p.id.slice(0, 8)}=${engine.get(p.id)?.state}`).join(' '))
+
+  // 5. 每个 worker 内部执行顺序 = 其名下子任务(按 assignee 归属)创建顺序 = FIFO。
+  //    过滤按 assignee 而非 transition by:父任务 WAITING→WORKING 的迁移 by=子任务 assignee,
+  //    但那是 lead 汇总相位,不是该 worker 的执行相位。
+  const workingTasks = mon.events
+    .filter((e): e is Extract<typeof e, { taskId: string }> => e.kind === 'task.status' && e.state === 'WORKING')
+    .map(e => engine.get(e.taskId))
+    .filter((t): t is NonNullable<typeof t> => t !== undefined)
+  for (const w of workers) {
+    const seq = workingTasks.filter(t => t.assigneeId === w.id)
+    const fifo = seq.every((t, i) => i === 0 || seq[i - 1]!.createdAt <= t.createdAt)
+    check(`worker ${w.name} 执行顺序 FIFO(${seq.length} 个)`, seq.length >= 2 && fifo,
+      seq.map(t => t.title.slice(0, 12)).join(' → '))
+  }
+
+  // 6. 状态实时追踪:busy 事件带 currentTaskId;全部完成后 worker 空闲且队列空
+  const busyWithContext = mon.events.some(e =>
+    e.kind === 'agent.status' && e.state === 'busy' && e.currentTaskId != null)
+  check('agent.status busy 事件携带 currentTaskId(实时状态追踪)', busyWithContext)
+
+  const workersIdle = await waitUntil(() =>
+    workers.every(w => manager.getChannelAgent(w.id)?.runtimeState === 'idle'), 10_000)
+  check('队列清空后全部 worker 标记 idle', workersIdle)
+  for (const w of workers) {
+    const q = engine.queueViewOf(ch.channelId, w.id)
+    check(`worker ${w.name} 队列空 + 已完成 ${q.completed.length} 个`, q.queued.length === 0 && !q.current && q.completed.length >= 2)
+  }
+  mon.stop()
+}
+
+/** 场景 B:lead 对 worker 队列的查/改/调配/删(omp host tool 同款 manager 通道) */
+async function scenarioQueueCrud(manager: AgentChannelManager): Promise<void> {
+  console.log('\n━━━ 场景 B:lead 对 worker 队列的增删改查与调配 ━━━')
+  const ch = await manager.createChannel({
+    name: 'queue-e2e-B',
+    leadAgent: { name: 'lead-乙', harness: 'mock', config: { delayMs: 0 } },
+  })
+  const wTpl1 = await manager.createAgent({ name: 'worker-甲', harness: 'mock', config: { delayMs: 500 } })
+  const wTpl2 = await manager.createAgent({ name: 'worker-乙', harness: 'mock', config: { delayMs: 500 } })
+  await manager.addAgentToChannel({ channelId: ch.channelId, agentId: wTpl1.id, role: 'worker' })
+  await manager.addAgentToChannel({ channelId: ch.channelId, agentId: wTpl2.id, role: 'worker' })
+
+  const members = await manager.listChannelAgents(ch.channelId)
+  const lead = members.find(m => m.role === 'lead')!
+  const [w1, w2] = members.filter(m => m.role === 'worker')
+  const engine = engineOf(manager)
+
+  // 激活 channel 装配 bus(不经 submitChannelTask,避免占位任务污染 worker 队列)
+  manager.ensureChannelActive(ch.channelId, { tickMs: 50 })
+  const mon = monitorChannel(manager, ch.channelId)
+
+  // lead 直接分发(= omp host tool dispatch_task 同款通道):
+  // C_a → w1(立即执行),C_b → w1(排队),C_c → w2(立即执行)
+  const ca = await manager.dispatchTask(ch.channelId, lead.id, { assigneeId: w1.id, title: 'C_a-首批' })
+  const cb = await manager.dispatchTask(ch.channelId, lead.id, { assigneeId: w1.id, title: 'C_b-次批' })
+  const cc = await manager.dispatchTask(ch.channelId, lead.id, { assigneeId: w2.id, title: 'C_c-并行' })
+
+  // 查:w1 执行中 C_a、队列 [C_b];w2 执行中 C_c
+  await waitUntil(() => engine.get(ca.id)?.state === 'WORKING' && engine.get(cc.id)?.state === 'WORKING', 10_000)
+  const q1 = engine.queueViewOf(ch.channelId, w1.id)
+  check('查:w1 执行中 C_a + 队列 [C_b]', q1.current?.id === ca.id && q1.queued.map(t => t.id).join() === cb.id)
+
+  // 改:更新排队任务 C_b 内容
+  const updated = await manager.updateTask(ch.channelId, lead.id, cb.id, { title: 'C_b-改后内容', description: '改描述' })
+  check('改:排队任务标题已更新', updated.title === 'C_b-改后内容' && engine.queueViewOf(ch.channelId, w1.id).queued[0]?.title === 'C_b-改后内容')
+
+  // 调配:C_b 从 w1 迁到 w2;w1 队列清退,w2 队列接收
+  const reassigned = await manager.reassignTask(ch.channelId, lead.id, cb.id, w2.id)
+  const q1b = engine.queueViewOf(ch.channelId, w1.id)
+  const q2b = engine.queueViewOf(ch.channelId, w2.id)
+  check('调配:assignee 已换到 w2', reassigned.assigneeId === w2.id && engine.get(cb.id)?.assigneeId === w2.id)
+  check('调配:w1 队列已清退', q1b.queued.length === 0 && !q1b.queued.some(t => t.id === cb.id))
+  check('调配:w2 队列接收(FIFO 排在当前任务后)', q2b.queued.some(t => t.id === cb.id))
+
+  // 删:向 w2 追加 C_d 后立即取消;过期投递作废
+  const cd = await manager.dispatchTask(ch.channelId, lead.id, { assigneeId: w2.id, title: 'C_d-待删' })
+  const canceled = await manager.cancelTask(ch.channelId, lead.id, { taskId: cd.id })
+  check('删:任务已 CANCELED', canceled.state === 'CANCELED')
+
+  // 终态:C_a/C_c/C_b 完成(调配后 C_b 由 w2 执行),C_d 永不执行
+  const settled = await waitUntil(
+    () => ['COMPLETED', 'FAILED', 'CANCELED'].includes(engine.get(ca.id)?.state ?? '')
+      && ['COMPLETED', 'FAILED', 'CANCELED'].includes(engine.get(cb.id)?.state ?? '')
+      && ['COMPLETED', 'FAILED', 'CANCELED'].includes(engine.get(cc.id)?.state ?? ''),
+    30_000,
+  )
+  check('C_a/C_b/C_c 全部完成', settled,
+    `C_a=${engine.get(ca.id)?.state} C_b=${engine.get(cb.id)?.state} C_c=${engine.get(cc.id)?.state}`)
+  check('调配后的 C_b 由 w2 执行完成', engine.get(cb.id)?.state === 'COMPLETED' && engine.get(cb.id)?.assigneeId === w2.id)
+  check('取消的 C_d 未被执行(仍 CANCELED)', engine.get(cd.id)?.state === 'CANCELED')
+
+  // w1 从未执行 C_b(调配后无 WORKING 事件);w2 从未执行 C_d
+  const worked = mon.events.filter(e => e.kind === 'task.status' && e.state === 'WORKING')
+  check('w1 从未执行已调配走的 C_b', !worked.some(e => (e as { taskId: string }).taskId === cb.id && (e as { agentId?: string }).agentId === w1.id))
+  check('w2 从未执行已取消的 C_d', !worked.some(e => (e as { taskId: string }).taskId === cd.id))
+
+  // 过期投递作废:w2 邮箱无 C_d 的 pending 消息
+  const msgs = (manager as unknown as {
+    deps: { repos: { messages: { listPendingByChannelAgent(chId: string, aId: string): Array<{ taskId: string | null }> } } }
+  }).deps.repos.messages.listPendingByChannelAgent(ch.channelId, w2.id)
+  check('取消任务的过期投递已作废(无 pending)', !msgs.some(m => m.taskId === cd.id))
+
+  // lead 队列总览(host tool get_queue_overview 同款通道)
+  const overview = await manager.queueOverview(ch.channelId, lead.id)
+  check('queueOverview 返回全员实时状态', overview.length === 3 && overview.every(s => s.state === 'idle' || s.state === 'busy' || s.state === 'stopped'))
+  mon.stop()
+}
+
+/** 场景 C:真实 omp rpc 子进程注册全部 host tools(原生集成冒烟,无 LLM 调用) */
+async function scenarioOmpRpc(): Promise<void> {
+  console.log('\n━━━ 场景 C:omp rpc 原生集成(host tools 注册冒烟)━━━')
+  const client = new OmpRpcClient({ command: 'omp' })
+  try {
+    await client.start()
+    const resp = await client.send({ type: 'set_host_tools', tools: HOST_TOOLS })
+    check(`omp rpc 就绪 + 注册 ${HOST_TOOLS.length} 个 host tools(含 5 个队列管理工具)`, resp.success === true)
+    const names = HOST_TOOLS.map(t => t.name)
+    check('新增队列工具均在注册列表', ['get_my_task_queue', 'get_queue_overview', 'reassign_task', 'update_task', 'cancel_task'].every(n => names.includes(n)))
+  }
+  finally {
+    await client.dispose()
+  }
+}
+
+async function main(): Promise<void> {
+  console.log('━━━ AgentRuntime 任务队列管理 + 状态追踪 + lead 调度 端到端 ━━━')
+  const db = openWorkshopDb(':memory:')
+  const manager = makeManager(db)
+  try {
+    await scenarioDispatchAndDrain(manager)
+    await scenarioQueueCrud(manager)
+    await scenarioOmpRpc()
+  }
+  finally {
+    await manager.shutdown()
+  }
+
+  console.log(`\n${failures === 0 ? 'ALL PASS' : `${failures} FAILED`}`)
+  process.exit(failures === 0 ? 0 : 1)
+}
+
+main().catch((e) => {
+  console.error('测试异常:', e)
+  process.exit(1)
+})