Files
AgentLab/frontend/src/run/ChallengeSummary.tsx
T
ThearchyHelios 12dc47b976 期 3 反方审稿(前端)复核修正:要审的报告按服务端的认法定,校验报过的不再重复,补齐降档提示的反例检查和运行类别取不到时的说明,修好显示全部的焦点与去重,处理审稿记录没存上的情况
检查器
- 「要审的报告」留空时,照服务端 schema.challenge_report 的认法:先看直接连着的报告撰写节点,恰好一个就审它;不是一个时,整个上游只有一个才取那一个。以前只认第二步,「初稿 → 终稿 → 反方审稿」这种接法下会误报「上游有 2 个,请选择」,同模型提醒也不出。现在留空项写出实际会审的那份(「未选择:审上游的「终稿」」),同模型提醒也按同一套认法判断。
- 认法写成 nodePickField / upstreamModel 的 rule 选项。缺省是 'upstream'(只看整个上游),和 F1a 的 dual_check_card 一致,双盲复算以后也能直接用。
- 选中的节点在上游、类型却不对(例如输入节点),以前写成「不在上游」,现在照实写「不是报告撰写节点」,提示里说清它是哪类节点。判断顺序和服务端一致:先看存不存在,再看类型,最后看在不在上游。
- 画布校验已经在 report / model 字段上报过问题时,不再画本地那句提示,避免同一件事一琥珀一红说两遍。判断哪些问题属于本字段,用和 Inspector 挂字段时相同的 fieldOfIssue;下拉里照实标出的那一项保留。
- 文案里的设置入口统一写成「设置 → 偏好设置 → 核查」,和设置页的真实标签、双盲复算、证据裁判的写法一致。

审批卡
- 降档的原因改为常显在概况下面,不再只放在悬停提示和读屏文字里。
- 运行类别取不到时,不再悄悄不写降档:照实写「暂时无法确认运行类别;如为正式运行,被推翻的结论会使出具降档」,并给出重试按钮;窗口重新拿到焦点时也会再取一次。
- 「显示全部」补句时按 unit 去重:两边都有 unit 时只比 unit,有一边缺 unit 才比原文。以前原文相同、unit 不同的一句会被吞掉,被吞的可能正是被推翻的那句。条目缺 unit 时不再补假的 #i。
- 键盘按「显示全部」、补句那一行的重试、一句详情里的重试、运行类别的重试之后,焦点都会接到新出现的内容上,不再掉到 body。焦点已经被用户移到别处时不抢。
- 审稿记录没存上(artifact 为 null)时,每句只列判断,不能点开,整块说一句「反方审稿记录未保存,无法查看理由和查询」;「另有 N 句未列出」照常显示,只是不给「显示全部」。

检查(check-challenge 共 153 项)
- 新增预览用例:正式运行且没有被推翻的结论(降档 / 只标注)、探索运行配只标注、运行类别取不到、原文相同而 unit 不同、审稿记录没存上、链式接法的检查器。
- 「只标注、探索运行、没有反方审稿」拆成各自独立的段,一段出错不会遮住其余几段。
- 新增的检查项包括:降档原因常显、取不到运行类别时的说明和重试(含窗口重新拿到焦点后再取)、显示全部和各处重试后的焦点、按 unit 去重、审稿记录没存上、链式接法、类型不对的节点、校验报过就不重复说,以及窄屏和深浅色下新增几行说明的对比度。
- 复核时用来证明检查不够的两个变异,M1(正式运行一律写降档)和 M10(探索运行也写只标注说明),连同本次各项修正的变异,都已逐一确认会被检查发现。
2026-10-05 15:35:01 +08:00

659 lines
34 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 { Fragment, useCallback, useEffect, useId, useMemo, useRef, useState, type CSSProperties, type ReactNode } from 'react'
import { AlertTriangle, ChevronRight, ShieldAlert } from 'lucide-react'
import { api } from '../api/client'
import { EVIDENCE_STATE, segmentLabel, segmentState, sourceOf, unitText, type EvidenceStateCode } from '../lib/evidence'
import { CHALLENGE_TEXT, EVIDENCE_STATE_LABEL, EVIDENCE_TEXT } from '../lib/terms'
import { asDoc, useEvidence } from '../store/evidence'
import type {
ApprovalChallenge, ApprovalReport, ChallengeArtifact, ChallengeClaim, ChallengeCounts, ChallengeItem, ChallengeQuery,
ChallengeVerdict, EvidenceBlock, EvidenceDocData, EvidenceSegment, EvidenceUnit,
} from '../types'
import { BlockView, CopyChip, Markdown, StyledSlice, inlineStyles, numericColumns } from './Markdown'
export interface ChallengeSummaryProps {
/** 这张审批卡审的报告(payload.reports,和 ApprovalReports 拿到的是同一份) */
reports: ApprovalReport[]
runId: string
}
/**
* 审批卡里反方审稿的摘要,紧跟在报告核对概况(ApprovalReports)后面:一行概况(四种判断各几句),逐句列出结论原文和判断,
* 点开一句再按 challenge_artifact 取完整内容,看反方的理由和它执行过的查询。审稿记录没存上(没有工件)时只列判断、
* 不能点开,整块说一次。
*
* 判断是反方模型给的,不是系统核对:颜色照结论句裁判的那一套,「经受住」也不用确定性的绿。
* 「出具会降档」只在正式运行、有被推翻的结论、按降档处理时才写——只标注的不写降档,探索运行不出具,和出具有关的话一句不说。
* 运行类别不由审批卡传进来,按运行 id 从证据 store 取(loadRunClass),取到之前不说;取不到时照实说取不到,可重试。
*
* 审的报告都没有经过反方审稿时什么都不画,也不发任何请求,卡片和以前一样。
*/
export function ChallengeSummary({ reports, runId }: ChallengeSummaryProps) {
const reviewed = useMemo(() => reports.flatMap((r) => {
const challenge = challengeOf(r)
return challenge ? [{ report: r, challenge }] : []
}), [reports])
if (!reviewed.length) return null
return <ChallengeList reviewed={reviewed} runId={runId} />
}
function ChallengeList({ reviewed, runId }: {
reviewed: { report: ApprovalReport; challenge: ApprovalChallenge }[]; runId: string
}) {
const run = useRunClass(runId)
return (
<>
{reviewed.map(({ report, challenge }) => (
<ChallengeBlock key={report.node_id} report={report} challenge={challenge} run={run} />
))}
</>
)
}
// ---------------------------------------------------------------- 认 payload
const VERDICTS: readonly ChallengeVerdict[] = ['stands', 'weakened', 'refuted', 'inconclusive']
const isVerdict = (v: unknown): v is ChallengeVerdict => typeof v === 'string' && (VERDICTS as readonly string[]).includes(v)
/** 颜色同结论句裁判(lib/evidence 的 EVIDENCE_STATE):经受住同「有依据」,被削弱同「部分有依据」,被推翻同「证据相矛盾」 */
const VERDICT_COLOR: Record<ChallengeVerdict, string> = {
stands: 'var(--st-running)',
weakened: 'var(--st-waiting)',
refuted: 'var(--st-failed)',
inconclusive: 'var(--st-cancelled)',
}
const verdictLabel = (v: string) => (isVerdict(v) ? CHALLENGE_TEXT.verdict[v] : CHALLENGE_TEXT.verdictUnknown(v))
function isItem(x: unknown): x is ChallengeItem {
return !!x && typeof x === 'object' && typeof (x as ChallengeItem).text === 'string' && typeof (x as ChallengeItem).verdict === 'string'
}
const count = (v: unknown) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? Math.floor(v) : 0)
/**
* payload.reports[i].challenge 认不认得:要么有计数、要么有条目。计数缺了按条目数(条目最多 10 条,计数才是全部);
* 条目缺了 unit 的留空(行的键带序号,区分得开),不补假的:补出来的键会被当成真的 unit 去和工件里的句子比
*/
function challengeOf(report: ApprovalReport): ApprovalChallenge | null {
const raw = report.challenge as unknown
if (!raw || typeof raw !== 'object') return null
const c = raw as Record<string, unknown>
const items = (Array.isArray(c.items) ? c.items.filter(isItem) : [])
.map((it) => ({ unit: typeof it.unit === 'string' ? it.unit : '', text: it.text, verdict: it.verdict }))
// 计数里一个数都没有(格式不对)也按条目数,免得概况写四个 0、下面却列着几句
const given = c.counts && typeof c.counts === 'object' && VERDICTS.some((v) => typeof (c.counts as any)[v] === 'number')
? c.counts as Record<string, unknown> : null
const counts = Object.fromEntries(VERDICTS.map((v) => [v, given
? count(given[v]) : items.filter((it) => it.verdict === v).length])) as ChallengeCounts
if (!given && !items.length) return null
return {
counts, items, artifact: typeof c.artifact === 'string' && c.artifact ? c.artifact : null,
on_refuted: typeof c.on_refuted === 'string' ? c.on_refuted : undefined,
}
}
interface RunClass {
runClass: 'formal' | 'exploratory' | null
/** 取失败了、还没取到(重取期间也算:那一行和焦点所在的重试按钮不跟着闪掉) */
failed: boolean
retry: () => void
}
function useRunClass(runId: string): RunClass {
const slot = useEvidence((s) => (runId ? s.runClasses[runId] : undefined))
const load = useEvidence((s) => s.loadRunClass)
useEffect(() => { if (runId) void load(runId) }, [runId, load])
const status = slot?.status
const [hadError, setHadError] = useState(false)
useEffect(() => {
if (status === 'error') setHadError(true)
else if (status === 'ok') setHadError(false)
}, [status])
const failed = status === 'error' || (hadError && status === 'loading')
// 取失败了不就此作罢:窗口重新拿到焦点时再取一次(store 对出错的槽会重发)。只取一次就放弃的话,一次网络抖动
// 会让「出具会降档」一直不出现,而卡顶按审批自带的运行类别照样写着正式运行
useEffect(() => {
if (status !== 'error' || !runId) return
const again = () => { void load(runId) }
window.addEventListener('focus', again)
return () => window.removeEventListener('focus', again)
}, [status, runId, load])
const retry = useCallback(() => { if (runId) void load(runId) }, [runId, load])
const runClass = status === 'ok' && (slot?.data === 'formal' || slot?.data === 'exploratory') ? slot.data : null
return { runClass, failed, retry }
}
// ---------------------------------------------------------------- 取工件
/** 工件 id → 取回的内容。工件内容寻址、不可变,取到的永久缓存;出错的不缓存成定论,下次点开再取 */
const fetched = new Map<string, Promise<ChallengeArtifact>>()
function loadChallenge(id: string): Promise<ChallengeArtifact> {
let pending = fetched.get(id)
if (!pending) {
pending = api.artifact(id).then((res) => {
const content = asChallenge(res?.content)
if (!content) throw new Error(CHALLENGE_TEXT.failed)
return content
})
pending.catch(() => { fetched.delete(id) })
fetched.set(id, pending)
}
return pending
}
const text = (v: unknown) => (typeof v === 'string' ? v : '')
function asQuery(x: unknown): ChallengeQuery | null {
if (!x || typeof x !== 'object') return null
const q = x as Record<string, unknown>
return {
alias: text(q.alias), artifact: text(q.artifact), sql: text(q.sql),
row_count: typeof q.row_count === 'number' && Number.isFinite(q.row_count) ? q.row_count : null,
truncated: q.truncated === true, source: typeof q.source === 'string' && q.source ? q.source : null,
}
}
/** 工件内容认不认得:至少得有 claims 列表;每一句缺的字段按空的补,界面照实少显示 */
function asChallenge(content: unknown): ChallengeArtifact | null {
if (!content || typeof content !== 'object' || !Array.isArray((content as ChallengeArtifact).claims)) return null
const c = content as Record<string, any>
const claims: ChallengeClaim[] = (c.claims as unknown[]).filter(isItem).map((it) => {
const raw = it as unknown as Record<string, unknown>
const doc = raw.rationale_doc
return {
unit: text(raw.unit), text: it.text, verdict: it.verdict, rationale: text(raw.rationale),
rationale_doc: typeof doc === 'string' || (doc && typeof doc === 'object') ? doc as ChallengeClaim['rationale_doc'] : null,
queries: (Array.isArray(raw.queries) ? raw.queries : []).map(asQuery).filter((q): q is ChallengeQuery => !!q),
}
})
return { report: text(c.report), doc_artifact: text(c.doc_artifact), claims, model: typeof c.model === 'string' && c.model ? c.model : null }
}
type Fetch = { status: 'idle' | 'loading' | 'ok' | 'error'; data?: ChallengeArtifact }
/** retry 没有时不给重试:审批里根本没带工件 id,再取也是一样 */
type Detail = Fetch & { retry?: () => void }
/** 整份反方审稿:want 为真(点开过一句、要看全部)之后才取,一张卡里各句共用这一次 */
function useChallengeArtifact(id: string, want: boolean): Detail {
const [state, setState] = useState<Fetch>({ status: 'idle' })
const [attempt, setAttempt] = useState(0)
useEffect(() => {
if (!want || !id) return
let alive = true
setState((s) => (s.status === 'ok' ? s : { status: 'loading' }))
loadChallenge(id).then(
(data) => { if (alive) setState({ status: 'ok', data }) },
() => { if (alive) setState({ status: 'error' }) },
)
return () => { alive = false }
}, [id, want, attempt])
const retry = useCallback(() => setAttempt((n) => n + 1), [])
return id ? { ...state, retry } : { status: 'error' }
}
/**
* 工件里的一句和审批条目里的一句是不是同一句:两边都有 unit 时只按 unit 认——同一句话在摘要和正文各出现一次、各自被挑来审,
* 原文一样、unit 不同,是两句(按原文认会把其中一句吞掉,被吞的可能正是被推翻的那句);有一边没给 unit(老服务端)才按原文认
*/
const sameClaim = (a: ChallengeItem, b: ChallengeItem) => (a.unit && b.unit ? a.unit === b.unit : a.text === b.text)
/** 这一句在工件里的完整内容 */
function claimOf(artifact: ChallengeArtifact | undefined, item: ChallengeItem): ChallengeClaim | undefined {
return artifact?.claims.find((c) => sameClaim(c, item))
}
/** 补齐、重试之后接住焦点的几处:本身不在 Tab 顺序里(tabIndex -1),键盘用户得看得见焦点落在哪 */
const FOCUS_RING = 'rounded-sm focus:outline-none focus-visible:outline focus-visible:outline-solid focus-visible:outline-2 '
+ 'focus-visible:outline-offset-1 focus-visible:outline-[color:var(--accent)]'
/** 焦点丢了(按过的按钮被拿掉,落回 body)才替它接住;取的这一会儿用户已经去了别处的,不抢 */
const focusLost = () => !document.activeElement || document.activeElement === document.body
// ---------------------------------------------------------------- 卡片
function ChallengeBlock({ report, challenge, run }: {
report: ApprovalReport; challenge: ApprovalChallenge; run: RunClass
}) {
const [open, setOpen] = useState<Set<string>>(() => new Set())
const [all, setAll] = useState(false)
const detail = useChallengeArtifact(challenge.artifact ?? '', all || open.size > 0)
const { counts, items } = challenge
const total = VERDICTS.reduce((n, v) => n + counts[v], 0)
// 审批里没带工件:服务端保存审稿记录失败了。每句都看不了理由和查询,不画成能点开的样子,整块说一次
const noRecord = !challenge.artifact
const refuted = counts.refuted > 0 && run.runClass === 'formal'
// 没给 on_refuted(老服务端)按降档;报错的节点到不了审批,不会是 fail
const flagged = challenge.on_refuted === 'flag'
// 条目之外的几句(条目最多 10 条):要看全部时从工件里补上,排在后面,顺序照工件
const extra = all && detail.data ? detail.data.claims.filter((c) => !items.some((it) => sameClaim(c, it))) : []
const rows: ChallengeItem[] = [...items, ...extra]
const hidden = Math.max(0, total - items.length)
const toggle = (key: string) => setOpen((cur) => {
const next = new Set(cur)
if (next.has(key)) next.delete(key)
else next.add(key)
return next
})
// 「显示全部」那一行补齐后整行拿掉、取的时候按钮也停用,焦点会掉到页面上,下一个 Tab 就跳过了新补出来的几句:
// 按过「显示全部」或那一行的「重试」之后,取到了落到补出来的第一句上(计数和工件对不上、什么也没补到时落到最后一句),
// 又没取到落到那一行新出现的「重试」上
const blockRef = useRef<HTMLDivElement>(null)
const moreRef = useRef<HTMLDivElement>(null)
const focusMore = useRef(false)
useEffect(() => {
if (!focusMore.current || !all || (detail.status !== 'ok' && detail.status !== 'error')) return
focusMore.current = false
if (!focusLost()) return
if (detail.status === 'error') {
moreRef.current?.querySelector<HTMLElement>('button')?.focus()
return
}
const toggles = blockRef.current?.querySelectorAll<HTMLElement>('[data-challenge-toggle]')
;(toggles?.[items.length] ?? toggles?.[toggles.length - 1])?.focus()
}, [all, detail.status, items.length])
const showAll = () => { focusMore.current = true; setAll(true) }
const retryAll = () => { focusMore.current = true; detail.retry?.() }
// 运行类别重取成功后,「暂时无法确认」那一行(连同焦点所在的重试按钮)换成降档说明:焦点接到概况那一行上
const countsRef = useRef<HTMLDivElement>(null)
const runRetried = useRef(false)
useEffect(() => {
if (run.failed || !runRetried.current) return
runRetried.current = false
if (focusLost()) countsRef.current?.focus()
}, [run.failed])
const retryRun = () => { runRetried.current = true; run.retry() }
return (
<div ref={blockRef} className="mb-2 rounded border bg-bg p-2" data-challenge={report.node_id}>
<div className="mb-1 flex items-center gap-1 text-2xs font-medium text-faint">
<ShieldAlert size={11} aria-hidden /> {CHALLENGE_TEXT.head(report.label || report.node_id)}
</div>
{total > 0 || items.length ? (
<div ref={countsRef} tabIndex={-1} className={`tnum flex flex-wrap items-center gap-x-1.5 gap-y-1 text-2xs ${FOCUS_RING}`}
data-challenge-counts="">
{VERDICTS.map((v, i) => (
<Fragment key={v}>
{i > 0 && <span className="text-faint" aria-hidden>·</span>}
<span data-challenge-count={v} style={{ color: counts[v] ? VERDICT_COLOR[v] : 'var(--text-faint)' }}>
{CHALLENGE_TEXT.count(CHALLENGE_TEXT.verdict[v], counts[v])}
</span>
</Fragment>
))}
{refuted && !flagged && (
<span className="chip shrink-0 font-semibold" data-challenge-degrade=""
style={{ color: 'var(--st-failed)', borderColor: 'var(--st-failed)' }}>
<AlertTriangle size={11} aria-hidden /> {CHALLENGE_TEXT.degrade}
</span>
)}
</div>
) : (
<div className="text-2xs text-dim" data-challenge-empty="">{CHALLENGE_TEXT.none}</div>
)}
{/* 降档的原因常显,不放在悬停提示里:触屏、键盘用户也得看得到为什么、会怎样(只标注那一档同样常显一行) */}
{refuted && !flagged && (
<div className="mt-0.5 text-2xs leading-relaxed text-dim" data-challenge-degrade-note="">{CHALLENGE_TEXT.degradeHint}</div>
)}
{refuted && flagged && (
<div className="mt-0.5 text-2xs leading-relaxed text-dim" data-challenge-flag="">{CHALLENGE_TEXT.flagNote}</div>
)}
{/* 运行类别取不到:不知道是不是正式运行,不能装作没事(卡顶按审批自带的运行类别照样写着正式运行),照实说并可重试 */}
{counts.refuted > 0 && !flagged && run.failed && (
<div className="mt-0.5 flex flex-wrap items-center gap-x-2 gap-y-1 text-2xs leading-relaxed" data-challenge-runclass="failed">
<span style={{ color: 'var(--st-waiting)' }}>{CHALLENGE_TEXT.runClassFailed}</span>
<button type="button" className="btn btn-xs" onClick={retryRun}>{CHALLENGE_TEXT.retry}</button>
</div>
)}
{rows.length > 0 && (
<ul className="mt-1.5 space-y-0.5" data-challenge-items="">
{rows.map((item, i) => {
const key = `${item.unit}\u0000${i}`
if (noRecord) {
return (
<li key={key} data-challenge-item={item.unit} data-challenge-verdict={item.verdict}
className="flex min-w-0 items-start gap-1.5 px-1 py-0.5 text-2xs leading-relaxed">
<ClaimLine item={item} />
</li>
)
}
return (
<ClaimRow key={key} item={item} open={open.has(key)} onToggle={() => toggle(key)}>
<ClaimDetail item={item} detail={detail} />
</ClaimRow>
)
})}
</ul>
)}
{/* 工件取回来了、却没有条目之外的句子(计数和工件对不上):没什么可补的,这一行也不留。没有工件时照样交代
还有几句没列出,只是补不了 */}
{hidden > 0 && !extra.length && !(all && detail.status === 'ok') && (
<div ref={moreRef} className="mt-1 flex flex-wrap items-center gap-x-2 gap-y-1 text-2xs text-dim" data-challenge-more={hidden}>
<span>{CHALLENGE_TEXT.more(hidden)}</span>
{noRecord ? null : detail.status === 'error' && all ? (
<>
<span style={{ color: 'var(--st-waiting)' }} role="alert">{CHALLENGE_TEXT.failed}</span>
{detail.retry && <button type="button" className="btn btn-xs" onClick={retryAll}>{CHALLENGE_TEXT.retry}</button>}
</>
) : (
<button type="button" className="btn btn-xs" disabled={all && detail.status === 'loading'}
data-challenge-show-all="" onClick={showAll}>
{all && detail.status === 'loading' ? CHALLENGE_TEXT.loading : CHALLENGE_TEXT.showAll}
</button>
)}
</div>
)}
{noRecord && (total > 0 || items.length > 0) && (
<div className="mt-1 text-2xs leading-relaxed" style={{ color: 'var(--st-waiting)' }} data-challenge-norecord="">
{CHALLENGE_TEXT.noRecord}
</div>
)}
{/* 判断标签看着像结论,得说清是谁判的:整块说一次,工件取回来之后带上模型名 */}
{(total > 0 || items.length > 0) && (
<p className="mt-1 text-2xs leading-relaxed text-faint" data-challenge-judged="">
{CHALLENGE_TEXT.judgedBy(detail.data?.model ?? null)}
</p>
)}
</div>
)
}
/** 判断标签:文字加颜色(去掉颜色也读得出),不铺底色——浅色主题下底色会把小字的对比度压到 4.5 以下 */
function VerdictTag({ verdict }: { verdict: string }) {
const color = isVerdict(verdict) ? VERDICT_COLOR[verdict] : 'var(--text-dim)'
return (
<span className="chip shrink-0 font-medium" data-challenge-tag={verdict}
style={{ color, borderColor: `color-mix(in srgb, ${color} 45%, transparent)` }}>
{verdictLabel(verdict)}
</span>
)
}
/** 一句的判断标签和结论原文 */
function ClaimLine({ item }: { item: ChallengeItem }) {
return (
<>
<VerdictTag verdict={item.verdict} />
{/* 原文取自报告文档,是 Markdown:粗体、行内代码照样画出来;链接不画成链接,按钮里不能再套一个可点的东西 */}
<span className="min-w-0 flex-1 [overflow-wrap:anywhere]" data-challenge-text="">
<StyledSlice text={item.text} styles={inlineStyles(item.text)} from={0} to={item.text.length} links={false} />
</span>
</>
)
}
function ClaimRow({ item, open, onToggle, children }: {
item: ChallengeItem; open: boolean; onToggle: () => void; children: ReactNode
}) {
const detailId = useId()
return (
<li data-challenge-item={item.unit} data-challenge-verdict={item.verdict}>
<button type="button" aria-expanded={open} aria-controls={open ? detailId : undefined} onClick={onToggle} data-challenge-toggle=""
className="flex w-full min-w-0 items-start gap-1.5 rounded px-1 py-0.5 text-left text-2xs leading-relaxed hover:bg-hover focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-1 focus-visible:outline-[color:var(--accent)]">
<ChevronRight size={11} aria-hidden className="mt-[3px] shrink-0 text-faint"
style={{ transform: open ? 'rotate(90deg)' : 'none', transition: 'transform .15s' }} />
<ClaimLine item={item} />
</button>
{open && (
<div id={detailId} className="mb-1 ml-4 mt-1 min-w-0 space-y-2 rounded border p-2" data-challenge-detail={item.unit}>
{children}
</div>
)}
</li>
)
}
/** 点开的一句:工件取回来之前说正在加载;取不到给重试;取到了画理由和查询 */
function ClaimDetail({ item, detail }: { item: ChallengeItem; detail: Detail }) {
const baseId = useId()
const claim = claimOf(detail.data, item)
// 理由里的数字点一下:焦点落到那次查询上,描一下边(减少动效时也看得见)
const jump = useCallback((alias: string) => {
const part = document.getElementById(`${baseId}-q-${alias}`)
const head = part?.querySelector<HTMLElement>('[data-challenge-query-head]')
if (!part || !head) return
head.focus({ preventScroll: true })
head.scrollIntoView({ block: 'nearest' })
part.dataset.flash = 'focus'
setTimeout(() => { if (part.dataset.flash === 'focus') delete part.dataset.flash }, 1600)
}, [baseId])
// 点了「重试」,按钮在加载时就拿掉了:取到了焦点落到理由上,又没取到落到新的「重试」上,不掉到页面上
const retried = useRef(false)
const landing = useRef<HTMLElement | null>(null)
const land = useCallback((el: HTMLElement | null) => { landing.current = el }, [])
useEffect(() => {
if (!retried.current || (detail.status !== 'ok' && detail.status !== 'error')) return
retried.current = false
if (focusLost()) landing.current?.focus()
}, [detail.status])
if (detail.status === 'error') {
return (
<div className="flex flex-wrap items-center gap-2 text-2xs" data-challenge-detail-state="error">
<span role="alert" style={{ color: 'var(--st-waiting)' }}>{CHALLENGE_TEXT.failed}</span>
{detail.retry && (
<button ref={land} type="button" className="btn btn-xs"
onClick={() => { retried.current = true; detail.retry?.() }}>
{CHALLENGE_TEXT.retry}
</button>
)}
</div>
)
}
if (detail.status !== 'ok') {
return <div className="text-2xs text-faint" data-challenge-detail-state="loading">{CHALLENGE_TEXT.loading}</div>
}
if (!claim) {
return (
<div ref={land} tabIndex={-1} className={`text-2xs text-dim ${FOCUS_RING}`}
data-challenge-detail-state="missing">
{CHALLENGE_TEXT.claimMissing}
</div>
)
}
const aliases = new Set(claim.queries.map((q) => q.alias))
return (
<>
<section ref={land} tabIndex={-1} className={FOCUS_RING} data-challenge-detail-state="ok" data-challenge-rationale="">
<div className="mb-0.5 text-2xs font-medium text-faint">{CHALLENGE_TEXT.rationale}</div>
<Rationale claim={claim} onJump={(alias) => (aliases.has(alias) ? jump(alias) : undefined)} />
</section>
<section data-challenge-queries={claim.queries.length}>
<div className="mb-1 text-2xs font-medium text-faint">
{claim.queries.length ? CHALLENGE_TEXT.queries(claim.queries.length) : CHALLENGE_TEXT.noQueries}
</div>
<div className="space-y-1.5">
{claim.queries.map((q, i) => <QueryCard key={`${q.alias}-${i}`} id={`${baseId}-q-${q.alias}`} query={q} />)}
</div>
</section>
</>
)
}
function QueryCard({ id, query }: { id: string; query: ChallengeQuery }) {
return (
<div id={id} data-challenge-query={query.alias}
className="min-w-0 rounded data-[flash]:outline data-[flash]:outline-solid data-[flash]:outline-2 data-[flash]:outline-offset-2 data-[flash=focus]:outline-[color:var(--accent)]">
<div className="mb-1 flex min-w-0 items-center gap-2">
{/* 从理由里的数字跳过来时焦点落在这里:得看得见落在哪 */}
<span tabIndex={-1} data-challenge-query-head=""
className="min-w-0 flex-1 truncate rounded-sm text-2xs font-medium text-faint focus:outline-none focus-visible:outline focus-visible:outline-solid focus-visible:outline-2 focus-visible:outline-offset-1 focus-visible:outline-[color:var(--accent)]">
{EVIDENCE_TEXT.query(query.alias)}
{query.source && <span className="mono ml-1.5 font-normal">{query.source}</span>}
</span>
{query.sql && <CopyChip label={EVIDENCE_TEXT.copySql} text={() => query.sql} />}
</div>
{query.sql && (
<pre className="mono mb-1 max-h-28 overflow-auto whitespace-pre-wrap rounded bg-panel px-1.5 py-1 text-2xs leading-relaxed text-dim [overflow-wrap:anywhere]"
data-challenge-sql="">
{query.sql}
</pre>
)}
<div className="tnum flex flex-wrap gap-x-2 text-2xs text-faint">
{query.row_count != null && <span data-challenge-rows={query.row_count}>{CHALLENGE_TEXT.rows(query.row_count)}</span>}
{query.truncated && (
<span data-challenge-truncated="" style={{ color: 'var(--st-waiting)' }}>{CHALLENGE_TEXT.truncated}</span>
)}
</div>
</div>
)
}
// ---------------------------------------------------------------- 理由
/**
* 理由正文。有理由文档时按文档画:数字的出处照报告里的样子(有出处的实线、裸数字点状线加「无证据」),有出处的数字后面
* 挂查询编号,点一下跳到那次查询。文档可能直接放在工件里,也可能是另一个工件的 id(约定没定死,两种都认);
* 都没有、或者取不到时按渲染后的正文显示,数字照写,只是不标出处
*/
function Rationale({ claim, onJump }: { claim: ChallengeClaim; onJump: (alias: string) => void }) {
const ref = claim.rationale_doc
const inline = ref && typeof ref === 'object' ? asDoc(ref) : null
const artifact = typeof ref === 'string' ? ref : ''
const slot = useEvidence((s) => (artifact ? s.docs[artifact] : undefined))
const loadDoc = useEvidence((s) => s.loadDoc)
useEffect(() => { if (artifact) void loadDoc(artifact) }, [artifact, loadDoc])
const doc = inline ?? (slot?.status === 'ok' ? slot.data ?? null : null)
if (doc && (doc.blocks ?? []).length) return <RationaleDoc doc={doc} onJump={onJump} />
if (artifact && slot?.status !== 'error' && !doc) {
return <div className="text-2xs text-faint" data-challenge-doc-loading="">{CHALLENGE_TEXT.docLoading}</div>
}
if (!claim.rationale.trim()) return <div className="text-2xs text-faint">{CHALLENGE_TEXT.rationaleEmpty}</div>
return <div data-challenge-rationale-text=""><Markdown text={claim.rationale} dense /></div>
}
/** 列表项从哪一个片段开始:同 EvidenceDoc(行首的「- 」「1. 」是结构片段) */
const ITEM_START = /(^|\n)[ \t]*([-*+]|\d+[.)])[ \t]+$/
function RationaleDoc({ doc, onJump }: { doc: EvidenceDocData; onJump: (alias: string) => void }) {
return (
<div className="min-w-0 space-y-1.5 text-[11.5px] leading-relaxed" data-challenge-doc="">
{doc.blocks.map((block, b) => <RationaleBlock key={block.id ?? b} block={block} doc={doc} onJump={onJump} />)}
</div>
)
}
/** 一块:外观借 Markdown 的 BlockView,和报告文档、普通答案长得一样(块的分法同 EvidenceDoc 的 DocBlock) */
function RationaleBlock({ block, doc, onJump }: { block: EvidenceBlock; doc: EvidenceDocData; onJump: (alias: string) => void }) {
const units = block.units ?? []
const unit = (u: EvidenceUnit, code = false) => <RationaleUnit key={u.id} unit={u} doc={doc} code={code} onJump={onJump} />
switch (block.type) {
case 'heading':
return <BlockView dense shape={{ kind: 'h', level: block.level ?? 3, body: units.map((u) => unit(u)) }} />
case 'hr':
return <BlockView dense shape={{ kind: 'hr' }} />
case 'quote':
return <BlockView dense shape={{ kind: 'quote', body: units.map((u) => unit(u)) }} />
case 'code':
return <BlockView dense shape={{ kind: 'code', lang: block.lang ?? '', code: units.map(unitText).join(''), body: units.map((u) => unit(u, true)) }} />
case 'list': {
const items: { key: string; depth: number; units: EvidenceUnit[] }[] = []
for (const u of units) {
const lead = u.segments?.[0]
if (!items.length || (lead?.kind === 'structural' && ITEM_START.test(lead.text))) {
items.push({ key: u.id, depth: u.depth ?? 0, units: [u] })
} else items[items.length - 1].units.push(u)
}
return (
<BlockView dense shape={{
kind: 'list', ordered: !!block.ordered, start: block.start, fitMarkers: true,
items: items.map((it) => ({ key: it.key, depth: it.depth, body: it.units.map((u) => unit(u)) })),
}} />
)
}
case 'table': {
const cells = new Map<string, EvidenceUnit[]>()
let cols = 0
const rowIds: number[] = []
for (const u of units) {
const loc = u.loc ?? { row: 0, col: 0 }
cells.set(`${loc.row}:${loc.col}`, [...(cells.get(`${loc.row}:${loc.col}`) ?? []), u])
cols = Math.max(cols, loc.col + 1)
if (loc.row >= 0 && !rowIds.includes(loc.row)) rowIds.push(loc.row)
}
rowIds.sort((a, b) => a - b)
const plain = (r: number, c: number) => (cells.get(`${r}:${c}`) ?? []).map(unitText).join('')
const node = (r: number, c: number) => (cells.get(`${r}:${c}`) ?? []).map((u) => unit(u))
const head = Array.from({ length: cols }, (_, c) => plain(-1, c))
const body = rowIds.map((r) => Array.from({ length: cols }, (_, c) => plain(r, c)))
return (
<BlockView dense shape={{
kind: 'table',
head: Array.from({ length: cols }, (_, c) => node(-1, c)),
rows: rowIds.map((r) => Array.from({ length: cols }, (_, c) => node(r, c))),
numeric: numericColumns(head, body),
csv: () => [head, ...body].map((r) => r.join(',')).join('\n'),
}} />
)
}
default:
return <BlockView dense shape={{ kind: 'p', body: units.map((u) => unit(u)) }} />
}
}
/** 片段的颜色写成变量交给 index.css 的 .ev-seg / .ev-mark(同 EvidenceDoc) */
const evStyle = (state: EvidenceStateCode) => ({
'--ev-line': EVIDENCE_STATE[state].decoration, '--ev-soft': EVIDENCE_STATE[state].soft,
}) as CSSProperties
/** 引用的是查询结果里的一格:返回查询编号 */
function cellAlias(seg: EvidenceSegment, doc: EvidenceDocData): string | null {
const cite = seg.cite
if (!cite?.alias || segmentState(seg) !== 'deterministic') return null
const entry = doc.catalog?.[cite.alias]
return cite.kind === 'cell' || (cite.kind !== 'metric' && cite.kind !== 'input' && entry?.kind === 'query') ? cite.alias : null
}
/**
* 一句话:文字按行内 Markdown 渲染(整句算一次样式,同 EvidenceDoc 的 UnitView)。有出处的数字是按钮,后面挂查询编号;
* 裸数字、疑似不存在的名称画点状线,句末挂「无证据」「疑似不存在的名称」。别的片段(表名、字段名的链接)照普通文字
*/
function RationaleUnit({ unit, doc, code, onJump }: {
unit: EvidenceUnit; doc: EvidenceDocData; code: boolean; onJump: (alias: string) => void
}) {
const segs = (unit.segments ?? []).filter((s) => s.kind !== 'structural')
const whole = segs.map((s) => s.text).join('')
const styles = useMemo(() => (code ? null : inlineStyles(whole)), [whole, code])
const alerts = new Set<EvidenceStateCode>()
let pos = 0
const nodes = segs.map((s) => {
const from = pos
pos += s.text.length
const state = segmentState(s)
const alias = cellAlias(s, doc)
const body = styles ? <StyledSlice text={whole} styles={styles} from={from} to={pos} links={!state} /> : s.text
if (alias) {
const source = sourceOf(s, doc)
return (
<button key={s.id} type="button" className="ev-seg" data-ev-state="deterministic" data-ev-line="solid"
data-challenge-cite={alias} style={evStyle('deterministic')} title={source}
aria-label={CHALLENGE_TEXT.cited(s.text, source)} onClick={() => onJump(alias)}>
{body}
{/* inline-block:不吃上面那条下划线 */}
<sup className="mono ml-px inline-block select-none text-[9px] font-semibold text-faint" aria-hidden>{alias}</sup>
</button>
)
}
if (state === 'none' || state === 'suspect') {
alerts.add(state)
return (
<span key={s.id} className="ev-mark" data-ev-state={state} data-ev-line="dotted" style={evStyle(state)}
title={segmentLabel(s, doc)}>
{body}<span className="sr-only">({EVIDENCE_STATE_LABEL[state]})</span>
</span>
)
}
return <span key={s.id}>{s.strong ? <strong className="font-semibold">{body}</strong> : body}</span>
})
return (
<>
{nodes}
{!code && [...alerts].map((state) => (
<span key={state} className="ev-tag" aria-hidden="true" title={EVIDENCE_STATE[state].hint} data-ev-tag={state}>
{EVIDENCE_STATE[state].glyph}{EVIDENCE_STATE_LABEL[state]}
</span>
))}
</>
)
}