agentworkshop 0.7.34 → 0.7.38

package/scripts/i18n-merge.mjs

@@ -1,191 +0,0 @@
-/**
- * 合并器:把 i18n/dicts/<ns>.json(zh)+ i18n/dicts/_en.json(zh→en)
- * 注入 i18n/locales/zh-CN.ts 与 en.ts。
- * - dict 中的点号键('src.user'、'runtime.daq.x')展开为嵌套对象输出,
- *   与 vue-i18n 的路径解析语义一致(resolveValue 按 '.' 分段逐层下钻)
- * - ns 已存在 → 解析块内叶子路径,补插缺失键(整块重建,保持既有条目)
- * - vue-i18n 特殊字符({}@$|)转义为字面量插值;{pN} 占位符保持原样
- * - en 缺失 → 回退 zh(报告计数)
- * - 键风格:合法标识符用裸键,其余用单引号(项目 eslint singlequote 风格)
- */
-import fs from 'node:fs'
-import path from 'node:path'
-
-const esc = v => v
-  .replace(/\{(?!p\d+\})/g, `{'{'}`)
-  .replace(/([@$|])/g, `{'$1'}`)
-const enMap = JSON.parse(fs.readFileSync('i18n/dicts/_en.json', 'utf-8'))
-let miss = 0
-const norm = s => s.replace(/\s+/g, ' ').trim()
-
-function valueFor(zh, isEn) {
-  if (!isEn) return zh
-  const hit = enMap[norm(zh)] ?? enMap[zh]
-  if (hit == null) {
-    miss++
-    return zh
-  }
-  return hit
-}
-
-function quoteKey(k) {
-  return /^[A-Za-z0-9_$]+$/.test(k) ? k : `'${k.replace(/\\/g, '\\\\').replace(/'/g, '\\\'')}'`
-}
-function quoteVal(v) {
-  return `'${esc(v).replace(/\\/g, '\\\\').replace(/'/g, '\\\'').replace(/\r?\n/g, '\\n')}'`
-}
-
-// dict → 树:点号键展开为嵌套分组
-function toTree(dict, isEn) {
-  const root = { entries: [], groups: new Map() }
-  for (const [k, zh] of Object.entries(dict)) {
-    const v = valueFor(zh, isEn)
-    const segs = k.split('.')
-    let node = root
-    for (let i = 0; i < segs.length - 1; i++) {
-      let g = node.groups.get(segs[i])
-      if (!g) {
-        g = { entries: [], groups: new Map() }
-        node.groups.set(segs[i], g)
-      }
-      node = g
-    }
-    // 同名键不重复插入;值在建树时统一引用化,emit 阶段只写原始字面量
-    if (!node.entries.some(e => e[0] === segs[segs.length - 1])) {
-      node.entries.push([segs[segs.length - 1], quoteVal(v)])
-    }
-  }
-  return root
-}
-
-function emitTree(tree, indent) {
-  const pad = ' '.repeat(indent)
-  const lines = []
-  for (const [k, v] of tree.entries) lines.push(`${pad}${quoteKey(k)}: ${v},`)
-  for (const [k, g] of tree.groups) {
-    lines.push(`${pad}${quoteKey(k)}: {`)
-    lines.push(...emitTree(g, indent + 2))
-    lines.push(`${pad}},`)
-  }
-  return lines
-}
-
-// 解析既有 ns 块 → 有序树(值为已引用的原始字面量,保持原样)
-// 返回 { tree, hadDottedEntry }:块内还存在扁平点号键时标记需重建
-function parseBlockTree(lines) {
-  const mk = () => ({ entries: [], groups: new Map() })
-  const root = mk()
-  const stack = [{ indent: 0, node: root }]
-  let hadDottedEntry = false
-  for (const raw of lines) {
-    const indent = (raw.match(/^ */) || [''])[0].length - 4
-    const ln = raw.trim()
-    const closeM = ln.match(/^\},?$/)
-    if (closeM) {
-      while (stack.length > 1 && indent <= stack[stack.length - 1].indent) stack.pop()
-      continue
-    }
-    const openM = ln.match(/^(?:"([^"]+)"|'([^']+)'|([\w$]+)): \{$/)
-    const entryM = ln.match(/^(?:"([^"]+)"|'([^']+)'|([\w$]+)): (.*)$/)
-    if (openM) {
-      const name = openM[1] ?? openM[2] ?? openM[3]
-      let g = stack[stack.length - 1].node.groups.get(name)
-      if (!g) {
-        g = mk()
-        stack[stack.length - 1].node.groups.set(name, g)
-      }
-      stack.push({ indent, node: g })
-    }
-    else if (entryM) {
-      const name = entryM[1] ?? entryM[2] ?? entryM[3]
-      // 去掉行尾逗号,保留已引用的字面量原样
-      const val = entryM[4].replace(/,\s*$/, '')
-      const node = stack[stack.length - 1].node
-      if (name.includes('.')) {
-        // 旧版扁平点号键:展开为嵌套,记为重建信号
-        hadDottedEntry = true
-        const segs = name.split('.')
-        let cur = node
-        for (let i = 0; i < segs.length - 1; i++) {
-          let g = cur.groups.get(segs[i])
-          if (!g) {
-            g = mk()
-            cur.groups.set(segs[i], g)
-          }
-          cur = g
-        }
-        if (!cur.entries.some(e => e[0] === segs[segs.length - 1])) cur.entries.push([segs[segs.length - 1], val])
-      }
-      else {
-        if (!node.entries.some(e => e[0] === name)) node.entries.push([name, val])
-      }
-    }
-  }
-  return { tree: root, hadDottedEntry }
-}
-
-// 树的全部叶子路径
-function treeLeaves(tree, prefix = '') {
-  const out = new Set()
-  for (const [k] of tree.entries) out.add(prefix ? `${prefix}.${k}` : k)
-  for (const [k, g] of tree.groups) for (const p of treeLeaves(g, prefix ? `${prefix}.${k}` : k)) out.add(p)
-  return out
-}
-
-// 合并 dict 树缺失叶子到既有树(两侧值均为已引用化字面量)
-function mergeTree(existing, dictTree) {
-  let added = 0
-  for (const [k, v] of dictTree.entries) {
-    if (!existing.entries.some(e => e[0] === k)) {
-      existing.entries.push([k, v])
-      added++
-    }
-  }
-  for (const [k, g] of dictTree.groups) {
-    let sub = existing.groups.get(k)
-    if (!sub) {
-      sub = { entries: [], groups: new Map() }
-      existing.groups.set(k, sub)
-    }
-    added += mergeTree(sub, g)
-  }
-  return added
-}
-
-for (const [localeFile, isEn] of [['i18n/locales/zh-CN.ts', false], ['i18n/locales/en.ts', true]]) {
-  let src = fs.readFileSync(localeFile, 'utf-8')
-  let insertedTotal = 0
-  for (const f of fs.readdirSync('i18n/dicts').filter(x => x.endsWith('.json') && !x.startsWith('_'))) {
-    const ns = f.replace('.json', '')
-    const dict = JSON.parse(fs.readFileSync(path.join('i18n/dicts', f), 'utf-8'))
-    if (Object.keys(dict).length === 0) continue
-    const dictTree = toTree(dict, isEn)
-    const nsRe = new RegExp(`^  (?:${JSON.stringify(ns)}|'${ns}'|${ns}): \\{`, 'm')
-    const m = src.match(nsRe)
-    if (m) {
-      // 已有 ns:解析块 → 检查叶子 → 有缺失或存在旧扁平点号键时整块重建
-      const start = m.index + m[0].length
-      const end = src.indexOf('\n  },', start)
-      const blockLines = src.slice(start, end).split('\n').filter(l => l.trim() !== '')
-      const { tree: existingTree, hadDottedEntry } = parseBlockTree(blockLines)
-      const existingLeaves = treeLeaves(existingTree)
-      const wantLeaves = treeLeaves(dictTree)
-      const missing = [...wantLeaves].filter(l => !existingLeaves.has(l)).length
-      if (missing > 0 || hadDottedEntry) {
-        const added = mergeTree(existingTree, dictTree, isEn)
-        const rebuilt = [''].concat(emitTree(existingTree, 4))
-        src = src.slice(0, start) + rebuilt.join('\n') + src.slice(end)
-        insertedTotal += added
-      }
-    }
-    else {
-      // 新 ns:插到文件末尾闭合前(ns 名非合法标识符时加引号,如 team-plugins)
-      const tail = src.lastIndexOf('}')
-      const block = `  ${quoteKey(ns)}: {\n${emitTree(dictTree, 4).join('\n')}\n  },\n`
-      src = src.slice(0, tail) + block + src.slice(tail)
-      insertedTotal += treeLeaves(dictTree).size
-    }
-  }
-  fs.writeFileSync(localeFile, src)
-  console.log(`${localeFile}: +${insertedTotal} entries (en missing fallback: ${isEn ? miss : 'n/a'})`)
-}

package/scripts/migrate-local-time.mjs

@@ -1,123 +0,0 @@
-/**
- * 存量时间迁移:把数据库/JSON 仓库中的 UTC ISO 字符串(`Z` 后缀)改写为本地偏移形式
- * (`+08:00` 等,值=同一绝对时刻)。目的:与 00-local-time 补丁后的新数据排序一致。
- *
- *   NO_PROXY='*' node scripts/migrate-local-time.mjs [--home <dir>] [--dry]
- *
- * 范围:
- *  - workshop.sqlite / users.sqlite:全表全 TEXT 列中形如 `...Z` 的 ISO 时间戳
- *  - <configRoot>/data/*.json:递归遍历对象树中的 `...Z` 字符串字段
- * 不动:Timescale(timestamptz 绝对时刻)、daq-timeseries.sqlite(ts_ms 整数)、历史日志文件。
- */
-import { DatabaseSync } from 'node:sqlite'
-import { readdirSync, readFileSync, writeFileSync, renameSync, statSync } from 'node:fs'
-import { join, resolve } from 'node:path'
-import { installLocalIso } from '../shared/local-time.mjs'
-
-installLocalIso() // 迁移脚本自身用补丁后的 toISOString 产出本地偏移串
-
-const DRY = process.argv.includes('--dry')
-const homeIdx = process.argv.indexOf('--home')
-const configRoot = homeIdx > 0 ? resolve(process.argv[homeIdx + 1] ?? '') : resolve(process.cwd(), '.AgentWorkShop')
-const ISO_UTC = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/
-
-let converted = 0
-const toLocal = (s) => {
-  const ms = Date.parse(s)
-  if (Number.isNaN(ms)) return s
-  return new Date(ms).toISOString() // 补丁后 = 本地偏移
-}
-
-// ---- sqlite ----
-function migrateSqlite(path) {
-  let db
-  try {
-    db = new DatabaseSync(path)
-  }
-  catch (err) {
-    console.log(`[skip] ${path}: ${err.message}`)
-    return
-  }
-  const tables = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`).all()
-  for (const { name: table } of tables) {
-    const cols = db.prepare(`PRAGMA table_info(${JSON.stringify(table).slice(1, -1)})`).all()
-    for (const col of cols) {
-      if ((col.type ?? '').toUpperCase() !== 'TEXT') continue
-      let rows
-      try {
-        rows = db.prepare(`SELECT rowid AS rid, ${JSON.stringify(col.name).slice(1, -1)} AS v FROM ${JSON.stringify(table).slice(1, -1)}`).all()
-      }
-      catch { continue }
-      const hits = rows.filter(r => typeof r.v === 'string' && ISO_UTC.test(r.v))
-      if (hits.length === 0) continue
-      console.log(`[sqlite] ${table}.${col.name}: ${hits.length} rows`)
-      if (DRY) {
-        converted += hits.length
-        continue
-      }
-      const upd = db.prepare(`UPDATE ${JSON.stringify(table).slice(1, -1)} SET ${JSON.stringify(col.name).slice(1, -1)} = ? WHERE rowid = ?`)
-      for (const r of hits) {
-        upd.run(toLocal(r.v), r.rid)
-        converted++
-      }
-    }
-  }
-  db.close()
-}
-
-// ---- json 仓库 ----
-function walkJson(node) {
-  if (typeof node === 'string') return ISO_UTC.test(node) ? toLocal(node) : node
-  if (Array.isArray(node)) return node.map(walkJson)
-  if (node && typeof node === 'object') {
-    for (const k of Object.keys(node)) node[k] = walkJson(node[k])
-    return node
-  }
-  return node
-}
-
-function migrateJsonDir(dir) {
-  let entries
-  try {
-    entries = readdirSync(dir)
-  }
-  catch { return }
-  for (const name of entries) {
-    const p = join(dir, name)
-    let st
-    try {
-      st = statSync(p)
-    }
-    catch { continue }
-    if (st.isDirectory()) {
-      if (name === 'plugins' || name === 'daq-objects' || name.startsWith('backup')) continue
-      migrateJsonDir(p)
-      continue
-    }
-    if (!name.endsWith('.json') || name === 'runtime-settings.json') continue
-    try {
-      const raw = readFileSync(p, 'utf-8')
-      const parsed = JSON.parse(raw)
-      const before = (raw.match(/Z"/g) ?? []).length
-      const next = walkJson(parsed)
-      const out = JSON.stringify(next, null, 2)
-      const after = (out.match(/Z"/g) ?? []).length
-      if (before === after) continue
-      console.log(`[json] ${p}: ${before - after} timestamps`)
-      if (DRY) {
-        converted += before - after
-        continue
-      }
-      writeFileSync(p + '.tmp', out)
-      renameSync(p + '.tmp', p)
-      converted += before - after
-    }
-    catch { /* 非 JSON 内容/读失败跳过 */ }
-  }
-}
-
-console.log(`[migrate] configRoot=${configRoot} dry=${DRY}`)
-migrateSqlite(join(configRoot, 'data', 'workshop.sqlite'))
-migrateSqlite(join(configRoot, 'data', 'users.sqlite'))
-migrateJsonDir(join(configRoot, 'data'))
-console.log(`[migrate] done: ${converted} timestamps converted${DRY ? ' (dry-run,未写盘)' : ''}`)

package/scripts/omp-real-test.py

@@ -1,328 +0,0 @@
-# -*- coding: utf-8 -*-
-"""真实 OMP 多 Agent 验收测试(python -u 运行,需已启动服务端 3001 + omp CLI)。
-
-三个真实场景(全部走真实 omp 子进程 + 真实 LLM):
-  场景 A —— 简单任务执行:lead 自动分解 → worker 执行 → 父任务 COMPLETED
-  场景 B —— A2A 通信:worker1 ↔ worker2 经 send_message_to_agent / poll_messages 往返一问一答
-  场景 C —— 多任务队列:FIFO 队列 + 单 WORKING 不变量(每个 worker 串行消费,顺序完成)
-
-用法:
-  python -u scripts/omp-real-test.py            # 全部场景
-  python -u scripts/omp-real-test.py simple     # 仅场景 A
-  python -u scripts/omp-real-test.py a2a        # 仅场景 B
-  python -u scripts/omp-real-test.py queue      # 仅场景 C
-环境变量: AW_BASE / AW_MODEL_PROVIDER / AW_MODEL(缺省 zhipu-coding-plan/glm-5-turbo)
-"""
-import json
-import os
-import sys
-import time
-import urllib.request
-from datetime import datetime, timezone
-
-sys.stdout.reconfigure(encoding='utf-8', errors='replace')
-
-BASE = os.environ.get('AW_BASE', 'http://127.0.0.1:3001')
-PROVIDER = os.environ.get('AW_MODEL_PROVIDER', 'zhipu-coding-plan')
-MODEL = os.environ.get('AW_MODEL', 'glm-5-turbo')
-
-PASS = 0
-FAIL = 0
-CHANNEL_IDS = []
-
-
-def check(name, ok, detail=''):
-    global PASS, FAIL
-    tag = 'PASS' if ok else 'FAIL'
-    if ok:
-        PASS += 1
-    else:
-        FAIL += 1
-    print(f'  [{tag}]  {name}{f" — {detail}" if detail else ""}', flush=True)
-
-
-def log(msg):
-    print(f'[{time.strftime("%H:%M:%S")}] {msg}', flush=True)
-
-
-def api(method, path, body=None, token=None, timeout=30):
-    headers = {'Content-Type': 'application/json'}
-    if token:
-        headers['Authorization'] = 'Bearer ' + token
-    req = urllib.request.Request(
-        BASE + path,
-        data=json.dumps(body).encode() if body is not None else None,
-        method=method,
-        headers=headers,
-    )
-    with urllib.request.urlopen(req, timeout=timeout) as resp:
-        d = json.loads(resp.read().decode())
-    if isinstance(d, dict) and d.get('code') not in (None, 0, 'ok', 'success'):
-        raise RuntimeError(f'{method} {path} -> {str(d)[:240]}')
-    return d.get('data', d) if isinstance(d, dict) else d
-
-
-def ptext(parts):
-    if not isinstance(parts, list):
-        return ''
-    return ' '.join(p.get('text', '') for p in parts if isinstance(p, dict) and p.get('text'))
-
-
-def wait_until(name, cond, timeout_s, interval_s=3):
-    deadline = time.monotonic() + timeout_s
-    last = None
-    while time.monotonic() < deadline:
-        try:
-            last = cond()
-            if last:
-                return last
-        except Exception as e:  # noqa: BLE001
-            last = e
-        time.sleep(interval_s)
-    raise TimeoutError(f'wait_until 超时: {name} (last={str(last)[:200]})')
-
-
-def all_events(token, channel_id):
-    data = api('GET', f'/api/workshop/channels/{channel_id}/events?limit=1000', token=token)
-    return data.get('items', [])
-
-
-def all_tasks(token, channel_id):
-    return api('GET', f'/api/workshop/channels/{channel_id}/tasks', token=token)
-
-
-def all_messages(token, channel_id, limit=500):
-    msgs = api('GET', f'/api/workshop/channels/{channel_id}/messages?limit={limit}', token=token)
-    return sorted(msgs, key=lambda m: m['createdAt'])
-
-
-# ═══════════════════════════════════════════════════════════════
-
-def make_team(token, name, n_workers=2, worker_prefix='w'):
-    """新建 channel:1 lead + n_workers 个 OMP worker,全部真实 omp 子进程。"""
-    ch = api('POST', '/api/workshop/channels', body={
-        'name': name,
-        'description': '真实 OMP 验收测试',
-        'leadAgent': {'name': f'{name}-lead', 'harness': 'omp',
-                      'config': {'provider': PROVIDER, 'model': MODEL}},
-    }, token=token)
-    channel_id = ch['channelId']
-    CHANNEL_IDS.append(channel_id)
-    lead_id = ch.get('leadAgentId')
-    workers = []
-    for i in range(n_workers):
-        w = api('POST', f'/api/workshop/channels/{channel_id}/agents', body={
-            'name': f'{worker_prefix}{i + 1}-{name}',
-            'harness': 'omp',
-            'role': 'worker',
-            'config': {'provider': PROVIDER, 'model': MODEL,
-                       'systemPromptPrefix': f'你是 worker{i + 1},本场景测试中的执行者。'},
-        }, token=token)
-        workers.append(w['id'])
-    log(f'团队就绪 channel={channel_id[:8]} lead={lead_id[:8]} workers={[w[:8] for w in workers]} '
-        f'(模型 {PROVIDER}/{MODEL})')
-    return {'channelId': channel_id, 'leadId': lead_id, 'workers': workers}
-
-
-def submit(token, channel_id, title, description, assignee=None):
-    body = {'title': title, 'description': description}
-    if assignee:
-        body['assigneeId'] = assignee
-    t = api('POST', f'/api/workshop/channels/{channel_id}/tasks', body=body, token=token)
-    return t['id']
-
-
-def terminal_state(tasks, tid):
-    t = next((x for x in tasks if x['id'] == tid), None)
-    return t['state'] if t else None
-
-
-TERMINAL = ('COMPLETED', 'FAILED', 'CANCELED')
-
-
-def wait_terminal(token, channel_id, tid, timeout_s):
-    """仅当任务进入终态时返回状态字符串,否则返回 None(供 wait_until 轮询)。"""
-    st = terminal_state(all_tasks(token, channel_id), tid)
-    return st if st in TERMINAL else None
-
-
-# ═══════════ 场景 A:简单任务执行 ═══════════
-
-def scenario_simple(token, channel_id):
-    log('── 场景 A:简单任务执行(lead 自动分解 → worker 执行 → 父任务收口) ──')
-    t0 = time.monotonic()
-    pid = submit(token, channel_id,
-                 '简单任务:法国首都',
-                 '请完成这个小任务:写出句子「巴黎是法国的首都」,然后用 complete_task 工具提交交付物(summary=该句子),不要做其他多余操作。')
-    final = wait_until('A 父任务终态', lambda: wait_terminal(token, channel_id, pid, 900),
-                       timeout_s=900, interval_s=5)
-    elapsed = int(time.monotonic() - t0)
-    check('父任务 COMPLETED', final == 'COMPLETED', f'state={final} 耗时={elapsed}s')
-    tasks = all_tasks(token, channel_id)
-    children = [t for t in tasks if t.get('parentId') == pid]
-    check('lead 已分解出子任务', len(children) >= 1, f'children={len(children)}')
-    done_child = next((c for c in children if c['state'] == 'COMPLETED'), None)
-    check('子任务完成且带交付', done_child is not None and len(done_child.get('artifacts', [])) > 0,
-          f"child={done_child['id'][:8] if done_child else '-'} artifacts={len(done_child.get('artifacts', [])) if done_child else 0}")
-    parent = next(t for t in tasks if t['id'] == pid)
-    parent_text = json.dumps(parent.get('artifacts', ''), ensure_ascii=False)
-    check('父任务含最终交付(含关键词)', '巴黎' in parent_text, parent_text[:100])
-    return children, parent
-
-
-# ═══════════ 场景 B:A2A 通信(worker ↔ worker) ═══════════
-
-def scenario_a2a(token, channel_id, workers):
-    w1, w2 = workers[0], workers[1]
-    log('── 场景 B:A2A 通信(w1 向空闲 w2 发起 require_reply 提问,w2 回执,验证 in_reply_to 关联) ──')
-    base_msgs = {m['id'] for m in all_messages(token, channel_id)}
-    t0 = time.monotonic()
-
-    # 仅给 w1 派任务;w2 保持空闲(idle 时收到消息 → 独立 peer 回合 → 自动回执关联)
-    t1 = submit(token, channel_id, 'A2A-发送方:向同事提问并回报',
-                f'你是 A2A 通信测试的发起方。步骤:\n'
-                f'1. 用 send_message_to_agent 发消息给同事 <{w2}>,参数 message="请只回复:RED-77",'
-                f'require_reply=true(要求对方回执)。\n'
-                f'2. 调用 poll_messages(wait_seconds=90) 阻塞等待对方回复。\n'
-                f'3. 收到回复后调用 complete_task,summary 参数填你收到的回复全文。\n'
-                f'只与同事 [{w2}] 通信,不要联系 lead。',
-                assignee=w1)
-
-    # w1 完成即结束(同步检查 reply 链路证据)
-    wait_until('A2A 发送方任务终态', lambda: wait_terminal(token, channel_id, t1, 900),
-               timeout_s=900, interval_s=5)
-    elapsed = int(time.monotonic() - t0)
-    st = terminal_state(all_tasks(token, channel_id), t1)
-    check('发送方任务 COMPLETED(拿到回执后收口)', st == 'COMPLETED', f'state={st} 耗时={elapsed}s')
-
-    # 通信链路证据:w1 → w2 提问(带 require_reply)+ w2 → w1 回复(带 in_reply_to 关联)
-    msgs = [m for m in all_messages(token, channel_id) if m['id'] not in base_msgs]
-    asked = [m for m in msgs if m.get('fromAgentId') == w1 and m.get('toAgentId') == w2]
-    replies = [m for m in msgs if m.get('fromAgentId') == w2 and m.get('toAgentId') == w1
-               and m.get('metadata', {}).get('x-aw-in-reply-to')]
-    check('w1→w2 提问已投递(带 require_reply)',
-          len(asked) >= 1 and any(m.get('metadata', {}).get('x-aw-require-reply') == 'true' for m in asked),
-          f'asked={len(asked)}')
-    check('w2→w1 回执已投递(带 in_reply_to 关联)', len(replies) >= 1, f'replies={len(replies)}')
-    if asked and replies:
-        check('回执内容含 RED-77', 'RED-77' in ptext(replies[-1].get('parts', [])),
-              ptext(replies[-1].get('parts', []))[:60])
-        check('in_reply_to 精确关联提问消息',
-              replies[-1].get('metadata', {}).get('x-aw-in-reply-to') == asked[-1]['id'],
-              f"reply→{str(replies[-1].get('metadata', {}).get('x-aw-in-reply-to'))[:8]} ask={asked[-1]['id'][:8]}")
-    # 信箱排空:新消息最终全部消费(轮询直到无 pending)
-    wait_until('A2A 信箱排空', lambda: not [m for m in all_messages(token, channel_id, 500)
-                                            if m['id'] not in base_msgs and m.get('state') in ('pending', 'consuming')],
-               timeout_s=120, interval_s=3)
-    msgs_final = [m for m in all_messages(token, channel_id, 500) if m['id'] not in base_msgs]
-    check('全部新消息已消费(无残留 pending)', all(m.get('state') == 'consumed' for m in msgs_final),
-          f'consumed={sum(1 for m in msgs_final if m.get("state") == "consumed")}/{len(msgs_final)}')
-    return msgs_final
-
-
-# ═══════════ 场景 C:多任务队列 ═══════════
-
-def scenario_queue(token, channel_id, workers):
-    log('── 场景 C:多任务队列(直发 worker 信箱,验证 FIFO + 单 WORKING 不变量) ──')
-    w1, w2 = workers[0], workers[1]
-    # 直发:任务绕过 lead,直接进 worker 自己的信箱队列 —— 队列 FIFO 的确定性测试
-    assigns = [w1, w2, w1, w2]
-    titles = [f'队列任务-{i + 1}(回复 Q{i + 1}-DONE)' for i in range(len(assigns))]
-    descs = [f'请只用一句话回复:{f"Q{i + 1}-DONE"}(不要多余文字),然后 complete_task。' for i in range(len(assigns))]
-    ids = [submit(token, channel_id, titles[i], descs[i], assignee=assigns[i])
-           for i in range(len(assigns))]
-    log(f'已直发 {len(ids)} 个任务: w1←[{",".join(str(i + 1) for i, a in enumerate(assigns) if a == w1)}] '
-        f'w2←[{",".join(str(i + 1) for i, a in enumerate(assigns) if a == w2)}]')
-
-    t0 = time.monotonic()
-    final_states = {}
-    deadline = time.monotonic() + 900
-    while time.monotonic() < deadline:
-        tasks = all_tasks(token, channel_id)
-        final_states = {tid: terminal_state(tasks, tid) for tid in ids}
-        if all(v == 'COMPLETED' for v in final_states.values()):
-            break
-        time.sleep(4)
-    elapsed = int(time.monotonic() - t0)
-
-    check('全部任务 COMPLETED', all(v == 'COMPLETED' for v in final_states.values()),
-          f'states={list(final_states.values())} 耗时={elapsed}s')
-
-    # 单 WORKING 不变量:任一时刻每个 assignee 至多 1 个 WORKING(事件重放)
-    evs = all_events(token, channel_id)
-    tasks_final = all_tasks(token, channel_id)
-    assignee_of = {t['id']: t['assigneeId'] for t in tasks_final}
-    sim = {}
-    max_concurrent = 0
-    for e in evs:
-        if e['type'] != 'task.status':
-            continue
-        payload = e.get('payload') or {}
-        state = payload.get('state')
-        tid = e.get('taskId')
-        ag = e.get('agentId') or ''
-        if not tid or not ag or assignee_of.get(tid) != ag:
-            continue
-        if state == 'WORKING':
-            sim[ag] = sim.get(ag, 0) + 1
-            max_concurrent = max(max_concurrent, sim[ag])
-        elif state in ('COMPLETED', 'FAILED', 'CANCELED', 'WAITING', 'ASSIGNED'):
-            sim[ag] = max(0, sim.get(ag, 0) - 1)
-    check('单 WORKING 不变量(每 assignee 并发 WORKING≤1)', max_concurrent <= 1,
-          f'max_concurrent={max_concurrent}')
-
-    # FIFO 顺序:每个 worker 直发队列按提交序完成(信箱 FIFO)
-    tasks = all_tasks(token, channel_id)
-    by_assignee = {}
-    for t in tasks:
-        if t['id'] in ids and t['state'] == 'COMPLETED':
-            by_assignee.setdefault(t['assigneeId'], []).append(t)
-    fifo_ok = True
-    orders = []
-    for ag, lst in by_assignee.items():
-        order = [int(t['title'].split('-')[1].split('(')[0]) for t in lst]
-        orders.append(f"{ag[:8]}:{order}")
-        fifo_ok = fifo_ok and order == sorted(order)
-    check('每 worker 直发队列 FIFO 顺序完成', fifo_ok, '; '.join(orders) or '无')
-    return ids, by_assignee
-
-
-# ═══════════════════════════════════════════════════════════════
-
-def main():
-    which = sys.argv[1] if len(sys.argv) > 1 else 'all'
-    log(f'目标: {BASE} | 模型 {PROVIDER}/{MODEL} | 场景: {which}')
-    user = api('POST', '/api/workshop/users/register', body={
-        'name': f'omp-real-{datetime.now(timezone.utc).strftime("%H%M%S")}',
-        'email': f'ompreal{int(time.time() * 1000) % 10**8}@test.local',
-        'password': 'Test1234!',
-    })
-    token = user['token']
-
-    if which in ('all', 'simple'):
-        team = make_team(token, 'simple', n_workers=1)
-        try:
-            scenario_simple(token, team['channelId'])
-        finally:
-            pass  # 汇聚终局一起清理
-
-    if which in ('all', 'a2a'):
-        team = make_team(token, 'a2a', n_workers=2, worker_prefix='w')
-        try:
-            scenario_a2a(token, team['channelId'], team['workers'])
-        finally:
-            pass
-
-    if which in ('all', 'queue'):
-        team = make_team(token, 'queue', n_workers=2)
-        try:
-            scenario_queue(token, team['channelId'], team['workers'])
-        finally:
-            pass
-
-    log(f'★ 结果: {PASS} passed, {FAIL} failed')
-    sys.exit(1 if FAIL else 0)
-
-
-if __name__ == '__main__':
-    main()