Files
AgentLab/frontend/src/canvas/TeamMatrix.tsx
T
ThearchyHelios 03c18c4d78 界面文案整改:口语改书面、术语统一、不再露出实现细节;修掉几处说错的提示;新增文案检查防回潮
一、文案(前端约 1600 处,后端传到界面的约 880 处)
- 术语统一:工作流层面用「运行」(继续运行、重新运行、试运行),节点和工具层面用「执行」,不再用「跑」;
  总时长 / 执行时长 / 等待审批;服务端;助手;Agent;token;工作流;固定版本;模型接入;系统提示;批准 / 驳回;受管级别
- 口语改书面:取不到、没取回来、读不懂、连不上、多半、照样、兜底、揉成这类说法改成「无法 / 未能 / 失败 / 请」;去掉拟人写法
- 不再露出实现细节:界面上不写 checkpoint、同一拍、哈希(凭证处除外),不写改版历史(「以前…」「老数据」);
  报错、校验、门禁、自动修复里裸写的配置键名和枚举值换成界面上的中文标签,由新的 backend/app/engine/labels.py 统一提供;
  发布弹窗里结论句的选项不再是 off / require_citation
- 同一件事只留一种说法:生成阶段文案、出具档位说明、画布锁定提示各合成一份
- 去掉界面上的工业场景示例(MES、ERP、「张工」「王工」)和真实产品名,换成通用示例

二、说错的提示(都有测试证明)
- 数据库测连接失败时的专用提示以前从不出现(按报错文字全等比较,永远比不上):改为按错误类型判断,不再拼出重复的前缀
- 「设置 → 供应商」改指「设置 → 模型接入」;「在设置里建数据源」改指「数据」页
- 缺少 API Key、模型接入已停用的报错不再夹英文,写明去哪里填
- 两处原因说错(「这种引用在后续版本支持」「这一版还不支持」)改成真实原因
- 节点说明里不准确的说法改正:代码节点在 microVM 或系统沙箱中执行;报告撰写、口径卡的说明不再说过头
- 导出的证据 CSV 里两列同名,第三列改为「片段编号」

三、前后端对齐
- 前端按后端原文识别日志、报错的地方,新旧两种写法都认得(历史运行里存的是旧文字),逐条补了新旧原文的核对
- 后端交回模型的原指令放进单独的 for_model 字段,前端在解析响应时去掉,不会显示到界面上

四、检查
- 检查脚本里按原文匹配的断言改成新文案;改完会变成永远成立的反向断言逐条修正,并做了变异验证
- 新增 check-copy(静态扫描前端界面字符串和后端上界面的文案):再出现「跑」「后端」「多半」「令牌」、
  界面上的 Copilot、裸写的配置键名、半角标点等就报错;确需保留的写进 scripts/copy-allow.json 并注明理由
2026-09-30 08:05:15 +08:00

456 lines
23 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { memo } from 'react'
import clsx from 'clsx'
import { StatusBadge } from '../components/ui'
import { formatDuration, formatLapse, NONE } from '../lib/format'
import { statusMeta } from '../lib/status'
import type { TeamMemberEx } from '../run/decode'
import type { NodeTrace, Segment } from '../run/trace'
import { useRunClock } from '../run/useRunClock'
import type { TeamMember, TeamRound, TeamRun } from '../types'
/**
* 实时计时:「01:14.3」。只有它订阅时钟,所在的卡片、矩阵不跟着每 100ms 重画。
*
* from 是服务端时钟的毫秒时间戳,skewMs 是客户端减服务端的偏差(见 trace.liveAt)。
* coarse 只到秒:成员行、等待时长这些地方十分位只会让一排数字一直在抖。
* 十分位单独包一层,系统关了动效时由 CSS 藏掉(那时时钟也只 1 秒走一次)。
* 过了一小时按 formatLapse 换成「3 小时 05 分」,那时已经没有十分位了。
*/
export function LiveClock({ from, skewMs = 0, coarse = false }: {
from: number
skewMs?: number
coarse?: boolean
}) {
const now = useRunClock(true)
const text = formatLapse(Math.max(0, now - skewMs - from))
const dot = text.lastIndexOf('.')
if (dot < 0) return <span className="tnum">{text}</span>
return (
<span className="tnum">
{text.slice(0, dot)}
{!coarse && <span className="nc-tenth">{text.slice(dot)}</span>}
</span>
)
}
/** 回放时的定值计时:和 LiveClock 的 coarse 一样只到秒,拿不到就是「—」 */
export const stillClock = (ms: number | undefined): string =>
(ms == null ? NONE : formatLapse(Math.max(0, ms), false))
/**
* 协作矩阵:supervisor 节点在卡片内部摊开的那块东西。
*
* 多 agent 节点在画布上原本是个黑盒——卡片转 30 秒圈,然后吐一段文本。
* "它同时派了三个人"、"谁还在跑"、"并行到底省了多少"全都要点开右栏才知道,
* 而右栏是线性的时间线,看不出并发的形状。这块东西就是把它摊开:
*
* - 花名册固定在原地(不按派单顺序重排)——几轮下来眼睛知道谁在哪一行
* - 条形长度按**这一轮里最慢的那个人**归一化。三个人并排三条长短不一的条,
* 墙钟为什么等于最长那条、而不是三条之和,不用解释就看懂了
* - 本轮没被派到的人不显示成"待命",而是留着它上一轮的耗时(压暗)——
* 它已经交回来了,说它"待命"是错的,而且看的人会以为它还没干活
* - 最上面一行是调度者:一个 70 秒的协作节点里常有 60 秒是它在想下一步派谁,
* 以前这段在画布上什么都没有,看着像卡死了
*
* 行数从编辑态起就固定(花名册 + 调度者 + 头尾),跑起来只换内容不长个子:
* 矩阵一长高就会压住下方的邻居节点。在跑的人在干什么放在悬停提示里,
* 不再另起两行。
*
* 成员数据来自 decode.ts 的 reduceTeam(右栏泳道用的是同一份,两处不会打架);
* 调度段和成员的实时起点来自航迹。
*/
interface Roster {
name: string
description?: string
}
/**
* 轮数用完之后怎么收场。后端在最后一轮交回之后还会让调度者只判定、不派活地
* 看一次(agent.route.* 带 closing):它说完成了就正常交付;没说完成,节点按
* 「用完轮数时」的配置失败或降档交付。这一次判定不是新的一轮,矩阵不给它加列
*/
export interface TeamEnding {
/**
* 收尾判定。open = 调度者还在判;at 是开始判定的时刻(agent.route.start),
* 矩阵据此认出哪一段调度是这次判定。老后端没有这一步
*/
verdict?: { done: boolean; reason: string; open: boolean; at?: number }
/** 用完轮数仍未完成:fail 节点失败,degrade 降档交付(成果是成员最后的原话) */
exhausted?: 'fail' | 'degrade'
/** 调度者最后给的理由:收尾判定的,没有就取报错或产出里的 */
reason?: string
/** 后端点名的「一次都没被派到」的成员(报错原话、产出的 never_dispatched) */
never?: string[]
/** 报错、日志原话里的「用完 N 轮」:配置里的最多轮数可能在运行之后改过 */
rounds?: number
}
interface Props {
roster: Roster[]
/** 还没跑过就没有:这时矩阵就是花名册 */
team?: TeamRun
/** 这个节点的航迹:调度段、成员段的起止 */
trace?: NodeTrace
/** 节点正在执行。决定措辞是"进行中"还是"已收尾",以及要不要走时钟 */
live: boolean
/** 回放中:计时不走时钟 */
replay?: boolean
/** 回放游标(毫秒时间戳)。给了就按这一刻截取成员和调度段,见 teamAt */
at?: number | null
maxRounds?: number
maxParallel?: number
/** 服务端时钟偏差,实时计时要扣掉 */
skewMs?: number
ending?: TeamEnding
/** 成员失败的原因(agent.step.end 的 error),按名字 */
memberErrors?: Record<string, string>
}
/**
* 真正派过活的轮次。调度者的理由按轮记,收尾判定那一次(round = 上限)也会记下
* 一条只有理由、没有成员的「轮」——它不是一轮协作,不能让表头写成「第 5 轮 / 上限 4」
*/
function worked(team: TeamRun | undefined): TeamRun | undefined {
if (!team || team.rounds.every((r) => r.members.length)) return team
return { ...team, rounds: team.rounds.filter((r) => r.members.length) }
}
/** 当前该看哪一轮:有在跑的就看那一轮,否则看最后一轮 */
function currentRound(team: TeamRun | undefined) {
if (!team?.rounds.length) return undefined
const running = team.rounds.filter((r) => r.members.some((m) => m.status === 'running'))
return running.length ? running[running.length - 1] : team.rounds[team.rounds.length - 1]
}
/**
* 这一段调度是不是轮数用完后的收尾判定。认事件(agent.route.* 带 closing,卡片折成
* verdict):不拿轮次和配置里的「最多轮数」比——没配时后端按缺省值跑,运行之后还可能
* 改过(调大了再接着跑、回放历史运行),那样比出来的是错的。收尾判定是这一次执行里
* 最后一段调度,它开始之后的那段就是它
*/
const isClosing = (seg: Segment | undefined, verdict: TeamEnding['verdict']): boolean =>
!!seg && !!verdict && (verdict.at == null || seg.start >= verdict.at)
/** 收尾判定的一句话。reason 太长的放悬停,表头只放得下结论 */
export function verdictText(v: TeamEnding['verdict'], full = false): string {
if (!v) return ''
if (v.open) return '轮数用完 · 调度者正在判定'
if (v.done) return full ? '轮数用完 · 调度者判定:已完成' : '轮数用完 · 判定已完成'
const why = v.reason.trim()
return full ? `轮数用完 · 调度者判定:未完成${why ? `(${why})` : ''}` : '轮数用完 · 判定未完成'
}
/**
* 这一轮是几个人并行:按派出去的人数,不按此刻还有几个在跑。三人并行的一轮
* 交回两个之后仍是并行的一轮,说成「串行推进」就和底部的「并行省下」打架了。
* 老事件不带 parallel 时 reduceTeam 记成 1,按这一轮实际出现的人数兜底
*/
const widthOf = (round: TeamRound | undefined): number =>
Math.max(round?.parallel ?? 1, round?.members.length ?? 0)
/** 某类段里最后一段。给了游标就只看那一刻已经开始的,还没结束的当作仍开着 */
function lastSeg(trace: NodeTrace | undefined, kind: Segment['kind'], agent?: string, at?: number | null): Segment | undefined {
const segs = trace?.segments ?? []
for (let i = segs.length - 1; i >= 0; i -= 1) {
const s = segs[i]
if (s.kind !== kind || (agent != null && s.agent !== agent)) continue
if (at == null) return s
if (s.start > at) continue
return s.end != null && s.end > at ? { ...s, end: null } : s
}
return undefined
}
const SETTLED: TeamMember['status'][] = ['done', 'failed', 'cancelled', 'suspended']
/**
* 回放到某一刻时的矩阵数据。
*
* runtime 里的 team 是跑完之后的样子:拖回第 8 秒,卡片写着「运行中」,矩阵却是
* 「3 人并行完成 · 省下 11 s」。成员段记着每个人派出、交回的时刻,按游标截一刀
* 重建那一刻。没有成员段的老数据(事件不带 ts)截不了,原样给出去
*/
export function teamAt(team: TeamRun | undefined, trace: NodeTrace | undefined, at: number | null | undefined): TeamRun | undefined {
if (!team || at == null) return team
const segs = (trace?.segments ?? []).filter((x) => x.kind === 'member')
if (!segs.length) return team
const used = new Set<Segment>()
const rounds: TeamRound[] = []
for (const r of team.rounds) {
const members: TeamMember[] = []
for (const m of r.members) {
const seg = segs.find((x) => !used.has(x) && x.agent === m.agent
&& (x.iteration == null || x.iteration === r.round + 1))
if (!seg) { members.push(m); continue }
used.add(seg)
if (seg.start > at) continue
const ended = seg.end != null && seg.end <= at
const settled = SETTLED.find((st) => st === seg.status)
members.push({
...m,
status: ended ? settled ?? m.status : 'running',
ms: Math.max(0, (ended ? seg.end! : at) - seg.start),
})
}
if (!members.length) continue
const ms = members.map((m) => m.ms)
rounds.push({ ...r, members, wallMs: Math.max(...ms), sumMs: ms.reduce((a, b) => a + b, 0) })
}
// 和 reduceTeam 同一个口径:只算整轮都交回了的
const savedMs = rounds.reduce((acc, x) => acc
+ (x.members.every((m) => m.status === 'done') ? Math.max(0, x.sumMs - x.wallMs) : 0), 0)
const finished = team.finished && trace?.endedAt != null && trace.endedAt <= at
return { ...team, rounds, savedMs, finished }
}
/**
* 一行摘要:远景档矩阵收起来时,卡片上只剩这一句。
* 「2/3 在跑 · 第 2 轮」「调度中 · 第 2 轮」「共 3 轮 · 并行省下 28.4 s」
* 进行中的把此刻的读数放前面:精简档缩到 0.4 倍以下时这一句放不全,截掉的该是轮次
*/
export function teamBrief(team: TeamRun | undefined, trace: NodeTrace | undefined, live: boolean, at?: number | null,
verdict?: TeamEnding['verdict']): string {
team = worked(teamAt(team, trace, at))
const round = currentRound(team)
const dispatch = lastSeg(trace, 'dispatch', undefined, at)
const thinking = live && dispatch && dispatch.end == null
if (!team?.rounds.length) return thinking ? '调度中' : live ? '进行中' : NONE
const no = `第 ${(round?.round ?? 0) + 1} 轮`
if (live) {
if (thinking) return isClosing(dispatch, verdict) ? '轮数用完 · 收尾判定中' : `调度中 · ${no}`
const running = round?.members.filter((m) => m.status === 'running').length ?? 0
const size = round?.members.length ?? 0
if (running) return `${running}/${size} 执行中 · ${no}`
// 人都交回了、下一次调度还没开始(老后端没有 route 事件时这段能有十几秒)
return widthOf(round) > 1 ? `${size} 名成员已交回 · ${no}` : `等待调度者 · ${no}`
}
const total = `共 ${team.rounds.length} 轮`
if (team.savedMs > 0) return `${total} · 并行节省 ${formatDuration(team.savedMs)}`
return team.finished && !team.rounds.some((r) => widthOf(r) > 1) ? `${total} · 全程串行` : total
}
/** 这一轮没交齐时怎么说:有人失败、被取消、被服务重启打断 */
function unsettledNote(members: TeamMember[]): string {
const failed = members.filter((m) => m.status === 'failed').length
if (failed) return `${failed} 名成员失败`
const stuck = members.find((m) => m.status !== 'done' && m.status !== 'running')
return stuck ? statusMeta(stuck.status).label : ''
}
/** 成员这一格的文字:没测到的一律「—」,不写 0,也不写"待命" */
function memberText(m: TeamMember | undefined, status = m?.status): string {
if (!m || !status) return NONE
if (status === 'done') return formatDuration(m.ms)
if (status === 'failed' && m.ms) return `失败 ${formatDuration(m.ms)}`
return statusMeta(status).short
}
function TeamMatrixImpl({
roster, team: final, trace, live, replay, at, maxRounds, maxParallel, skewMs = 0, ending, memberErrors,
}: Props) {
const team = worked(teamAt(final, trace, at))
const round = currentRound(team)
// 事件里出现过、但花名册里没有的名字也要显示。配置被人改过、或者调度者报了
// 一个不存在的成员时,这里至少能看出"确实派过这么个人"
const extra = (team?.members ?? []).filter((n) => !roster.some((r) => r.name === n))
const names = [...roster.map((r) => r.name), ...extra]
if (!names.length) return null
/** 每个人这次要显示的那条记录:本轮优先,否则它在最近一轮里的成绩 */
const rows = names.map((name) => {
const inRound = round?.members.find((m) => m.agent === name)
let last: TeamMember | undefined
let lastRound = 0
for (const r of team?.rounds ?? []) {
const m = r.members.find((x) => x.agent === name)
if (m) { last = m; lastRound = r.round }
}
const member = inRound ?? last
const roundNo = inRound ? (round?.round ?? 0) : lastRound
// 成员报错时 reduceTeam 仍记成"交回了"(它只看有没有 end);航迹的成员段记着
// 这一段是失败收场的,以它为准,不然超时的那个人在矩阵里是一条绿条
const seg = member ? lastSeg(trace, 'member', name, at) : undefined
const status: TeamMember['status'] | undefined = member?.status === 'done'
&& seg?.status === 'failed' && seg.iteration === roundNo + 1 ? 'failed' : member?.status
return {
name,
active: !!inRound,
member,
status,
roundNo,
hint: roster.find((r) => r.name === name)?.description,
// 原因按轮记在 reduceTeam 给的那一格上;老数据没有就用事件里捞到的最后一次
error: status === 'failed' ? (member as TeamMemberEx | undefined)?.error || memberErrors?.[name] : undefined,
}
})
// 轮数用完还没完成时,一次都没被派到的人要点出来:负责定稿的那个常常就在里面,
// 写「—」看着像它还没轮到,其实是整次协作都没用上它
const undone = !!ending?.exhausted || (!!ending?.verdict && !ending.verdict.open && !ending.verdict.done)
const never = undone && !live ? new Set(rows.filter((r) => !r.member).map((r) => r.name)) : null
// 悬停里的名单再并上后端点的名:花名册在运行之后被改过时,矩阵里可能已经没有那一行
const neverNamed = never ? [...new Set([...never, ...(ending?.never ?? [])])] : []
// 条形按同一批数归一化,长短才可比
const busiest = Math.max(1, ...rows.map((r) => (r.active ? r.member?.ms ?? 0 : 0)))
const runningNow = round?.members.filter((m) => m.status === 'running').length ?? 0
const ticking = live && !replay
// 调度者:有 agent.route.* 就是精确值,老后端只有从日志推出来的估算(标 ≈)
const dispatch = lastSeg(trace, 'dispatch', undefined, at)
const thinking = live && !!dispatch && dispatch.end == null
const decided = dispatch?.end != null ? dispatch.end - dispatch.start : undefined
const verdict = ending?.verdict
const closing = isClosing(dispatch, verdict)
const dispatchRound = team?.rounds.find((r) => r.round === (dispatch?.iteration ?? 0) - 1)
const dispatchNote = dispatch && !thinking
? closing ? '收尾判定' : dispatchRound?.members.length ? `分派 ${dispatchRound.members.length} 名成员` : '收尾'
: ''
// 用完了几轮:以报错、日志原话为准,配置里的数可能在运行之后改过
const usedUp = ending?.rounds ?? (maxRounds || team?.rounds.length)
const width = widthOf(round)
let headRight = ''
/** 表头右边这句的语气:用完轮数没完成时失败是红、降档是琥珀,别的安静 */
let headTone: 'err' | 'warn' | '' = ''
// 一轮都还没派(第一次刚开始;接着跑时 reduceTeam 把上一次清空了,rounds 为空)就是还没有
// 数据:只写配置里的并发上限,别按有过几轮的样子说「等调度者」「已收尾」。调度者正在想的
// 照说;收场(用完轮数、收尾判定)以事件为准,回放到上一次的收场时照样说
const started = !!team?.rounds.length
const idle = maxParallel ? `并发上限 ${maxParallel}` : ''
if (live) {
headRight = thinking ? closing ? verdictText({ done: false, reason: '', open: true }) : '调度中'
: !started ? idle
: width > 1 ? runningNow ? `本轮 ${width} 名成员并行 · ${runningNow} 名执行中` : `本轮 ${width} 名成员已交回`
: runningNow ? '串行推进' : '等待调度者'
} else if (ending?.exhausted) {
headRight = `用完 ${usedUp} 轮 · 未完成`
headTone = ending.exhausted === 'fail' ? 'err' : 'warn'
} else if (verdict && !verdict.open) {
headRight = verdictText(verdict)
headTone = verdict.done ? '' : 'warn'
} else if (!started) {
headRight = idle
} else {
headRight = unsettledNote(rows.filter((r) => r.active && r.member)
.map((r) => ({ ...r.member!, status: r.status! })))
|| (width > 1 ? `${width} 名成员并行完成` : team.finished ? '已收尾' : '')
}
const reason = ending?.reason || verdict?.reason || ''
const headTitle = ending?.exhausted || verdict
? [
verdict ? verdictText(verdict, true) : `协作团队用完 ${usedUp} 轮仍未完成`,
ending?.exhausted === 'degrade' ? '降档交付:成果为成员最后的输出,并非调度者认可的结论' : '',
ending?.exhausted === 'fail' ? '节点判为失败。可调大「最多轮数」,或将「用完轮数时」改为「降档交付」' : '',
reason && !(verdict && !verdict.done && !verdict.open) ? `理由:${reason}` : '',
neverNamed.length ? `从未被分派任务的成员:${neverNamed.join('、')}` : '',
].filter(Boolean).join('\n')
: undefined
// 省下多少只算整轮交齐的;有并行过但没交齐(失败、取消)的不能说成"全程串行"
const serialOnly = !!team?.finished && !team.rounds.some((r) => widthOf(r) > 1)
return (
<div className={clsx('team-matrix', live && 'is-live')}>
<div className="team-head" title={headTitle}>
<span className="tnum">
{team?.rounds.length
? `第 ${(round?.round ?? 0) + 1} 轮${maxRounds ? ` / 上限 ${maxRounds}` : ''}`
: `成员列表${maxRounds ? ` · 上限 ${maxRounds} 轮` : ''}`}
</span>
<span className="team-head-rule" />
<span className={clsx('team-head-right', headTone && `is-${headTone}`)}>{headRight}</span>
</div>
<div
className={clsx('team-row team-row-dispatch', thinking && 'team-row-running', !dispatch && 'team-row-idle')}
title={[
'调度者:决定下一轮分派哪些成员以及同时执行的人数',
closing && verdict ? verdictText(verdict, true)
: round?.reason ? `理由:${round.reason}` : '',
dispatch?.estimated ? '估算:根据事件间隔推算,非实测值' : '',
].filter(Boolean).join('\n')}
>
<StatusBadge status={thinking ? 'running' : dispatch ? 'done' : 'idle'} size={9} decorative />
<span className="team-name">调度者</span>
<span className="team-bar">
{thinking && <span className="team-bar-running" />}
</span>
<span className="team-ms tnum">
{thinking ? (
ticking ? <>{closing ? '判定' : '思考'} <LiveClock from={dispatch!.start} skewMs={skewMs} coarse /></>
: at != null ? `${closing ? '判定' : '思考'} ${stillClock(at - dispatch!.start)}` : '思考中'
) : decided != null ? (
`${dispatch?.estimated ? '≈' : ''}${formatDuration(decided)}${dispatchNote ? ` · ${dispatchNote}` : ''}`
) : NONE}
</span>
</div>
{rows.map(({ name, active, member, status, roundNo, hint, error }) => {
const running = status === 'running'
const done = status === 'done'
const failed = status === 'failed'
const open = running ? lastSeg(trace, 'member', name, at) : undefined
const unused = !!never?.has(name)
return (
<div
key={name}
className={clsx(
'team-row',
running && 'team-row-running',
done && 'team-row-done',
failed && 'team-row-failed',
active && 'team-row-active',
!member && !unused && 'team-row-idle',
unused && 'team-row-never',
member && !active && 'team-row-past',
)}
data-member-status={unused ? 'never' : status ?? 'idle'}
title={[
hint,
running && member?.instruction ? `当前任务:${member.instruction}` : '',
member ? `第 ${roundNo + 1} 轮 · ${memberText(member, status)}` : '',
failed && error ? `原因:${error}` : '',
unused ? `用完 ${usedUp} 轮,该成员从未被分派任务` : '',
].filter(Boolean).join('\n') || name}
>
<StatusBadge status={status ?? 'idle'} size={9} decorative />
<span className="team-name">{name}</span>
<span className="team-bar">
{running ? (
<span className="team-bar-running" />
) : (done || failed) && member && active ? (
<span
className="team-bar-fill"
data-ratio={Math.max(0.08, member.ms / busiest).toFixed(3)}
style={{ transform: `scaleX(${Math.max(0.08, member.ms / busiest)})` }}
/>
) : null}
</span>
<span className="team-ms tnum">
{running && open && open.end == null && ticking
? <LiveClock from={open.start} skewMs={skewMs} coarse />
: running && open && at != null ? stillClock(at - open.start)
: unused ? '未分派' : memberText(member, status)}
</span>
</div>
)
})}
<div className="team-foot">
<span className="tnum">{team?.rounds.length ? `${team.rounds.length} 轮` : NONE}</span>
<span className="flex-1" />
{/* 名册就在上面几行里,再数一遍人数是废话。这里只留一个真正要算的数:
并行到底省了多少。一轮都还没整轮交回时写「—」——"省下 0 ms"是在报
一个还没发生的收益;跑完了一次都没并发过就直说串行 */}
<span className={clsx('tnum', team && team.savedMs > 0 && 'team-saved')}>
{team && team.savedMs > 0 ? `并行节省 ${formatDuration(team.savedMs)}`
: serialOnly && !live ? '全程串行' : NONE}
</span>
</div>
</div>
)
}
export const TeamMatrix = memo(TeamMatrixImpl)