J3 复核修正(第 1 轮):过期的证据图重取一次,只有反方标记的句子在面板里先写判断,没反查成的不说成反方模型的判断

证据图缓存会过期:正文有运行就取证据图,之后一直用缓存。审批卡里展开过报告的话,缓存的是运行停在审批上那一刻的图:报告
改写后(第二次审批、同一张卡换稿)新稿在那份图里找不到,一个标记都挂不上;审批之后才审完的反方审稿,成果区也看不到;证据页
挂上时只管「运行已结束、图没封存」,停在第二次审批上的运行、别处正在取的那份都不管,画的是旧稿、审计表却是新取的。改成:
- EvidenceDoc(useRunGraph)挂上、换稿那一刻手里已有的那份,找不到正文这一稿,或者正文是运行的成果(EvidenceField 给
  settled)而那份没封存,就按(运行、报告、工件)重取一次;重取回来还是这样就作罢,挂上时还没有、正在取的那份不算过期;
- 证据页挂上时手里那份不是「封存了、封存的就是这一版(manifest_seq)」就重取,不看运行停在哪;别处正在取的取回来再看一眼;
  重取回来之前占位,第一次渲染就按挂上那一刻手里的那份定,不先画一帧旧稿。

整句面板的反方审稿:只有反方标记的句子(没有可点片段、也没有裁判判定)只能从标记点进来,面板却只认片段接口的
unit.challenge,还在取时这一节空着,答 500 时整节消失、也不说为什么。EvidencePanel 收下正文的标记(marks),片段接口还没答、
答不了、答了却没有可用内容时先按标记写出判断(ChallengeSummary 导出的 ClaimVerdictPending),说正在获取、未能获取(带重试,
重试后焦点落到「反方的理由与查询」或新的「重试」上)、无法查看;拿到 unit.challenge 换成完整的单句展示。

没反查成的句子:单句展示里一定没反查成的那一句不再写「判断由反方模型给出」(那是服务端按规则记的无法判断,反方模型没看过);
无法判断的句末标记悬停说明、先行版的落款写「可能是反方模型的判断,也可能是未能反查时记下的」,说不准的仍写判断出自反方模型。

其余几处:
- 挂上时一个键盘目标都没有、反方标记随证据图后来才到:Tab 位交给第一枚标记(以前三枚都是 tabindex=-1,Tab 跳过整份报告);
- 只有反方标记的句子,读屏不再把「反方审稿」念两遍;
- 带字的醒目标记悬停、展开时不铺浅底(10px 的失败色、提醒色字叠在 14% 的浅底上,浅色主题只有 4.0 左右),改描 1px 内边,
  和裁判徽标并在一起的同样;无法判断换成省略号盾牌,不再和裁判的「?」、质询的问号挤成三个问号,也和经受住的勾分得开。

检查:check-evidence 新增 mark-panel(片段接口压着、答 500、重试,390px 不溢出)、mark-tab(标记晚到进 Tab 顺序)、stale(审批卡
换稿、同一张卡换稿、成果区、证据页停在审批上和别处正在取,各重取一次、对上了不再取、旧稿一帧都不画)三节,marks 一节补读屏原文
逐字比、展开和悬停时的对比度、图标形状、无法判断的说法,verify 一节改等单句展示(原来等的选择器单句模式里没有,每遍白等 4 秒);
新预览用例 evidence-marks-text、evidence-marks-stale(dev/fixtures/evidence_marks.tsx)。check-challenge 新增 challenge-claim-quiet:
单句、不谈出具,给齐正式运行、运行 id、degrades 也不写降档、不取运行类别(以前这个开关在哪个用例里都观察不到)。
This commit is contained in:
ThearchyHelios
2026-10-06 14:36:21 +08:00
parent 4b5b3ecbf7
commit 6a54ab06c2
10 changed files with 775 additions and 74 deletions
+10
View File
@@ -37,6 +37,10 @@ import fx from './challenge.json'
* - ?syn=challenge-approval-dup:同 many,工件里补出来的一句和条目里的一句原文相同、unit 不同(工件由检查脚本合成)
* - ?syn=challenge-approval-norecord:同 many,审稿记录没存上(artifact 为 null)
*
* 证据面板的单句展示(scope="claim"):
* - ?syn=challenge-claim-quiet:被推翻的那一句,「不谈出具」(issuance={false})。给了正式运行、运行 id,服务端也说被推翻的
* 会降档(degrades)——审批卡上这几样凑齐就写「出具会降档」;这里一句和出具有关的话都不说,也不为此取运行类别
*
* 运行类别(GET /api/runs/{id})、工件(GET /api/artifacts/{id})都由检查脚本用 page.route 伪造;直接打开时取不到,
* 卡上照实不说降档、点开一句说无法获取。
*
@@ -253,6 +257,12 @@ export const cases: Record<string, () => JSX.Element> = {
<Card name="challenge-approval-offpath"
approval={approvalOf('ap-chal-15', RUNS.offpath, 'formal', withChallenge({ on_refuted: 'degrade', degrades: false, unreviewed: 0 }))} />
),
'challenge-claim-quiet': () => (
<div className="mx-auto max-w-md p-4" data-fixture="challenge-claim-quiet">
<ChallengeSummary reports={[withChallenge({ degrades: true, items: challenge.items.filter((it) => it.verdict === 'refuted') })]}
runId={RUNS.formal} runClass="formal" scope="claim" issuance={false} />
</div>
),
'challenge-inspector': () => <InspectorCase name="challenge-inspector" workflow={WORKFLOW} />,
'challenge-inspector-chain': () => <InspectorCase name="challenge-inspector-chain" workflow={CHAIN} />,
}
@@ -0,0 +1,143 @@
import { useState, type JSX } from 'react'
import { EvidencePane } from '../../pages/runs/EvidencePane'
import { EvidenceDoc, EvidenceField } from '../../run/EvidenceDoc'
import { useEvidence } from '../../store/evidence'
import type { EvidenceDocData, Run } from '../../types'
import judge from '../../run/__tests__/evidence-judge.json'
/**
* 正文里被反方审过的句子(期 4,run/EvidenceDoc 的句末标记)的预览用例,scripts/check-evidence.mjs 按它们检查。报告文档
* 取自 run/__tests__/evidence-judge.json 的 plain(后端 compose_doc 真跑出来的周报,内容虚构);证据图、片段接口、审计
* 接口都由检查脚本伪造,这里不发任何写请求。
*
* - ?syn=evidence-marks-text:同一份周报,数字、取值都改成纯文字:整份报告一个可点的片段都没有,也没开裁判,挂上时键盘
* 顺序是空的。证据图(检查脚本晚一点答)带着被审过的句子,标记到了以后得进 Tab 顺序。前面摆一个按钮,从它按 Tab 进报告
* - ?syn=evidence-marks-stale:同一次运行先后在几个地方挂这份报告,看手里那份证据图过期了重不重取。按钮换场景(每按一次
* 都重新挂):审批卡里的初稿(old);报告改写后第二次审批的新稿(new);同一个实例从初稿换到新稿(switch,同画布的审批
* 浮层换审批);运行结束后成果区的新稿(output,EvidenceField);运行详情的证据页(pane-interrupted:运行停在第二次审批
* 上;pane-succeeded:运行已经结束、封存过)。两份文档预先放进证据 store:文档按工件 id 永久缓存,取文档不是这里要看的
*/
/** 同一次运行:初稿是夹具里那一份,新稿改了一句话和一个数(文档的 run_id 改成这次运行,成果区按它认是不是同一次运行) */
const RUN = 'run-evidence-marks-stale'
const OLD_ART = judge.plain.doc_artifact
const NEW_ART = 'b7'.repeat(32)
const BASE = judge.plain.doc as unknown as EvidenceDocData
const OLD: EvidenceDocData = { ...BASE, run_id: RUN }
const NEW: EvidenceDocData = {
...BASE,
run_id: RUN,
markdown: (BASE.markdown ?? '').replace('增长主要来自新客首单,老客复购持平。', '增长主要来自老客复购,新客首单持平。')
.replace('退款 29 单', '退款 31 单'),
blocks: BASE.blocks.map((b) => ({
...b,
units: b.units?.map((u) => ({
...u,
segments: u.segments?.map((s) => (s.id === 's11' ? { ...s, text: '增长主要来自老客复购,新客首单持平。' }
: s.id === 's14' && s.cite ? { ...s, text: '31', cite: { ...s.cite, value: 31, rendered: '31' } } : s)),
})),
})),
}
/** 一个可点的片段都没有的那一份:非结构片段一律改成普通文字,去掉出处 */
const TEXT_ONLY: EvidenceDocData = {
...BASE,
blocks: BASE.blocks.map((b) => ({
...b,
units: b.units?.map((u) => ({
...u,
segments: u.segments?.map((s) => (s.kind === 'structural' ? s : { id: s.id, kind: 'text', text: s.text, state: 'neutral' })),
})),
})),
}
function TextOnly() {
return (
<div className="mx-auto flex max-w-3xl flex-col gap-3 p-4" data-fixture="evidence-marks-text">
<button type="button" className="btn btn-xs self-start" data-marks-before="">报告前面的按钮</button>
<div className="rounded-lg border bg-panel p-3" data-marks-doc="">
<EvidenceDoc doc={TEXT_ONLY} artifact={judge.plain.doc_artifact} runId="run-evidence-marks-text" label="周报" />
</div>
</div>
)
}
type Stage = 'old' | 'new' | 'switch' | 'output' | 'pane-interrupted' | 'pane-succeeded'
const STAGES: [Stage, string][] = [
['old', '审批卡 · 初稿'], ['new', '第二次审批 · 新稿'], ['switch', '同一张卡换稿'], ['output', '成果区 · 新稿'],
['pane-interrupted', '证据页 · 停在审批上'], ['pane-succeeded', '证据页 · 运行已结束'],
]
function runOf(status: 'interrupted' | 'succeeded'): Run {
const done = status === 'succeeded'
return {
id: RUN, workflow_id: null, workflow_name: '周报', status, input: {}, output: {}, error: null,
usage: { input_tokens: 0, output_tokens: 0, cost_usd: 0 } as Run['usage'], run_class: 'formal', version: 2,
manifest_hash: done ? 'c'.repeat(64) : null, manifest_seq: done ? 64 : null,
created_at: '2026-10-05T06:00:00', started_at: '2026-10-05T06:00:00',
}
}
/** 审批卡里展开的报告(同 run/ApprovalReport 的 ReportDoc:限高、窄栏、自带证据条) */
function Card({ doc, artifact }: { doc: EvidenceDocData; artifact: string }) {
return (
<div className="max-h-96 w-[380px] max-w-full overflow-y-auto rounded border bg-bg p-2" data-marks-card={artifact}>
<EvidenceDoc doc={doc} artifact={artifact} runId={RUN} label="周报" dense tally runClass="formal" />
</div>
)
}
/** 同一个 EvidenceDoc 实例从初稿换到新稿 */
function Switch() {
const [fresh, setFresh] = useState(false)
return (
<div className="flex flex-col gap-2">
<button type="button" className="btn btn-xs self-start" data-marks-switch="" onClick={() => setFresh(true)}>换成新稿</button>
<div className="max-h-96 w-[380px] max-w-full overflow-y-auto rounded border bg-bg p-2" data-marks-card={fresh ? NEW_ART : OLD_ART}>
<EvidenceDoc doc={fresh ? NEW : OLD} artifact={fresh ? NEW_ART : OLD_ART} runId={RUN} label="周报" dense tally runClass="formal" />
</div>
</div>
)
}
function Stale() {
// 首次渲染前把两份文档放进 store:文档按工件 id 永久缓存,证据页、成果区按工件 id 取的就是它们
useState(() => {
useEvidence.setState((s) => ({
docs: { ...s.docs, [OLD_ART]: { status: 'ok', data: OLD }, [NEW_ART]: { status: 'ok', data: NEW } },
}))
return true
})
const [at, setAt] = useState<{ stage: Stage; n: number }>({ stage: 'old', n: 0 })
const go = (stage: Stage) => setAt((cur) => ({ stage, n: cur.n + 1 }))
return (
<div className="flex h-screen min-w-0 flex-col gap-2 p-3" data-fixture="evidence-marks-stale">
<div className="flex flex-wrap gap-1.5">
{STAGES.map(([stage, label]) => (
<button key={stage} type="button" className="btn btn-xs" data-marks-stage={stage} onClick={() => go(stage)}>{label}</button>
))}
</div>
{/* 每按一次都按新的 key 重新挂:同一场景按两次,看手里那份图对上了还会不会重取 */}
<div key={at.n} className="min-h-0 min-w-0 flex-1" data-marks-at={at.stage}>
{at.stage === 'old' && <Card doc={OLD} artifact={OLD_ART} />}
{at.stage === 'new' && <Card doc={NEW} artifact={NEW_ART} />}
{at.stage === 'switch' && <Switch />}
{at.stage === 'output' && (
<div className="max-w-3xl rounded-lg border bg-panel p-3">
<EvidenceField artifact={NEW_ART} text={NEW.markdown ?? ''} runId={RUN} label="answer" tally runClass="formal" />
</div>
)}
{(at.stage === 'pane-interrupted' || at.stage === 'pane-succeeded') && (
<EvidencePane run={runOf(at.stage === 'pane-succeeded' ? 'succeeded' : 'interrupted')} output={null}
labelOf={(id) => (id === 'write' ? '写周报' : undefined)} refreshKey="0" />
)}
</div>
</div>
)
}
export const cases: Record<string, () => JSX.Element> = {
'evidence-marks-text': () => <TextOnly />,
'evidence-marks-stale': () => <Stale />,
}
+14
View File
@@ -3963,8 +3963,22 @@ export const CHALLENGE_TEXT = {
claimUnreviewed: '这一句未能反查,已记为无法判断',
/** 同上,但无法判断的句子里还有查过了、数据不够的:说不准是不是这一句 */
claimMaybeUnreviewed: (n: number) => `这份报告有 ${formatNumber(n)} 句未能反查,已记为无法判断,这一句可能在其中`,
/**
* 单句展示的先行版:只知道判断(正文标记用的证据图),这一句的理由、查询和整份报告的计数要等片段接口答回来。
* 还在取、取不到(给重试)、答了却没有可用的内容
*/
claimPending: '正在获取反方的理由与查询…',
claimFailed: '未能获取反方的理由与查询',
claimNoDetail: '无法查看反方的理由与查询',
/**
* 无法判断的落款:未能反查的句子也记为无法判断(服务端按规则记的,反方模型没看过这一句),说不准是哪一种时不说成反方
* 模型的判断。证据面板先行版的落款、正文句末标记的悬停说明都用这一句
*/
judgedUnsure: '可能是反方模型的判断,也可能是未能反查时记下的,并非系统核对',
/** 正文句末标记的悬停说明:判断是反方模型给的 */
markTitle: (verdict: string) => `反方审稿:${verdict}(反方模型的判断,并非系统核对)`,
/** 同上,无法判断的那一种(括号里同 judgedUnsure) */
markTitleUnsure: (verdict: string) => `反方审稿:${verdict}(可能是反方模型的判断,也可能是未能反查时记下的,并非系统核对)`,
/** 句末标记读屏念的那一段:跟在句子后面(只有反方审稿时),或接在裁判的判定后面(两样都有时,并在一个标记里) */
markLabel: (verdict: string) => `反方审稿:${verdict}`,
+38 -7
View File
@@ -48,20 +48,40 @@ export function EvidencePane({ run, output, labelOf, refreshKey }: {
const loadGraph = useEvidence((s) => s.loadGraph)
const reloadGraph = useEvidence((s) => s.reloadGraph)
const first = useRef(true)
// 报告正文(审批卡里展开的、成果区的)有运行就先取过证据图,取的时候运行可能还停在审批上(之后报告又改写过)、刚收尾还没
// 封存,也可能是接着跑之前封存的那一版。挂上时手里那份不是「封存了、封存的就是这一版」就重取一次,不看运行停在哪:之后
// 没有新事件,refreshKey 不再变,过期的那份会一直留着。别处正在取的那份取回来再看一眼(recheck)。
// 重取回来之前先占位(renewing),不画手里那份:画出来的是旧稿,审计表却是挂上时新取的,点一行会按片段 id 打开旧稿里同号
// 的片段。第一次渲染就按挂上那一刻手里的那份定,不先画一帧旧稿再收起来;换下来的判据是 store 里那一格不再是它
const [held] = useState(() => useEvidence.getState().graphs[run.id])
const [renewing, setRenewing] = useState(() => staleHeld(held, run.manifest_seq))
const recheck = useRef(false)
useEffect(() => {
if (first.current) {
first.current = false
// 报告正文(成果区、审批卡里展开的那份)有运行就先取过证据图,取的时候运行可能还停在审批上、刚收尾还没封存:
// 运行已经结束、手里那份却说没封存时重取一次,不然这一页顶上一直写着尚未封存(之后没有新事件,refreshKey 不再变)
const held = useEvidence.getState().graphs[run.id]
if (held?.status === 'ok' && SETTLED.has(run.status) && !held.data?.seal?.sealed) void reloadGraph(run.id)
else void loadGraph(run.id)
if (!staleHeld(held, run.manifest_seq)) void loadGraph(run.id)
else if (held?.status === 'loading') recheck.current = true
else void reloadGraph(run.id)
return
}
void reloadGraph(run.id)
}, [run.id, run.status, refreshKey, loadGraph, reloadGraph])
// held 是挂上那一刻的,之后不变
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [run.id, run.status, run.manifest_seq, refreshKey, loadGraph, reloadGraph])
useEffect(() => {
// 挂上时那一份还没换下来(重取还没发出、还没回来),或者正在取:接着等
if (!renewing || graphSlot === held || graphSlot?.status === 'loading') return
if (recheck.current) {
recheck.current = false
if (graphSlot?.status === 'ok' && !sealedNow(graphSlot.data, run.manifest_seq)) {
void reloadGraph(run.id)
return
}
}
setRenewing(false)
}, [renewing, graphSlot, held, run.id, run.manifest_seq, reloadGraph])
const audit = useAudit(run.id, refreshKey)
const graph = graphSlot?.data
const graph = renewing ? undefined : graphSlot?.data
const [root, setRoot] = useState<HTMLDivElement | null>(null)
const wide = useWide(root, 880)
@@ -232,6 +252,17 @@ const openKey = (row: AuditRow): string | undefined =>
/** 已经收尾的运行:还在跑、停在审批上的,报告可能还没写,说「这次的报告没有逐段证据」太早 */
const SETTLED = new Set(['succeeded', 'failed', 'cancelled'])
/**
* 手里这份证据图能不能直接用:封存了,而且封存的就是运行现在这一版(失败后接着跑的运行会重新封存,manifest_seq 跟着变)。
* 运行记录上没有 manifest_seq(老运行)、老服务端的证据图没给时只看封没封存
*/
const sealedNow = (graph: EvidenceGraph | undefined, seq: number | null | undefined) =>
!!graph?.seal?.sealed && (seq == null || graph.seal.manifest_seq == null || graph.seal.manifest_seq === seq)
/** 证据页挂上时手里那份(别处取的)要不要重取:正在取的取回来再看;取到了的不是封存的这一版就重取。没有、取失败的照常取 */
const staleHeld = (held: { status: string; data?: EvidenceGraph } | undefined, seq: number | null | undefined) =>
held?.status === 'loading' || (held?.status === 'ok' && !sealedNow(held.data, seq))
/**
* 工作流现在的图能不能一键升级:拿它去校验,看有没有 evidence.upgrade_available 这条建议。老后端不给
* 这条建议,横幅也就不出现(它也没有升级接口)。按工作流 id 和版本记住答案:同一张图的几条运行不重复问;
+41 -3
View File
@@ -42,7 +42,8 @@ export interface ChallengeSummaryProps {
* - 审批卡(scope 为 report),紧跟在报告核对概况(ApprovalReports)后面:一行概况(四种判断各几句),出具相关的那一句,
* 有句子反查没完成时再说一行「N 句未能反查」,逐句列出结论原文和判断,点开一句再按 challenge_artifact 取完整内容,看
* 反方的理由和它执行过的查询。审稿记录没存上(没有工件)时只列判断、不能点开,整块说一次。
* - 证据面板(scope 为 claim、issuance 为 false):一句话的判断,展开同样按 challenge_artifact 取这一句的理由和查询。
* - 证据面板(scope 为 claim、issuance 为 false):一句话的判断,展开同样按 challenge_artifact 取这一句的理由和查询。片段
* 接口还没答回来、答不了时,由 ClaimVerdictPending 先按正文标记(证据图)写出判断,说清在等什么、给重试。
*
* 判断是反方模型给的,不是系统核对:颜色照结论句裁判的那一套,「经受住」也不用确定性的绿。
* 「出具会降档」只在谈出具(issuance)、正式运行、有被推翻的结论、被推翻的真会让出具降档时才写:服务端给了 degrades 就照它
@@ -443,8 +444,45 @@ function ClaimBlock({ report, challenge, run }: {
</div>
)}
{noRecord && <p style={{ color: 'var(--st-waiting)' }} data-challenge-norecord="">{CHALLENGE_TEXT.noRecord}</p>}
{/* 判断标签看着像结论,得说清是谁判的:展开取到审稿记录之后带上模型名 */}
<p className="text-faint" data-challenge-judged="">{CHALLENGE_TEXT.judgedBy(detail.data?.model ?? null)}</p>
{/* 判断标签看着像结论,得说清是谁判的:展开取到审稿记录之后带上模型名。这一句一定没反查成(surely)的不写:那是
服务端按规则记的无法判断,反方模型没看过这一句,上面一行已经说了。说不准的(maybe)照旧写 */}
{!surely && <p className="text-faint" data-challenge-judged="">{CHALLENGE_TEXT.judgedBy(detail.data?.model ?? null)}</p>}
</div>
)
}
/** 证据面板先行版在等什么:片段接口还在取、取不到、答了却没有可用的 unit.challenge */
export type ClaimWait = 'loading' | 'error' | 'missing'
/**
* 单句展示的先行版(证据面板):只知道这一句的判断(正文标记用的证据图 challenge_verdicts),审稿记录、整份报告的计数要等
* 片段接口的 unit.challenge。判断标签先画出来——用户是点着句末醒目的「被推翻」进来的,这一节不能空着;还在取时说正在获取,
* 取不到给重试(onRetry),答了却没有可用的内容时照实说看不了。拿到 unit.challenge 之后调用方换成完整的单句展示
* (ChallengeSummary 的 scope="claim")。无法判断的说不准是不是根本没反查成(要整份报告的计数才分得出),落款不说成反方模型
* 的判断。不谈出具,同证据面板里的完整展示
*/
export function ClaimVerdictPending({ verdict, wait, onRetry }: { verdict: string; wait: ClaimWait; onRetry?: () => void }) {
return (
<div className="min-w-0 space-y-1 text-2xs leading-relaxed" data-challenge-scope="claim" data-challenge-verdict={verdict}
data-challenge-pending={wait}>
<div className="flex flex-wrap items-center gap-x-1.5 gap-y-1">
<VerdictTag verdict={verdict} />
</div>
{wait === 'loading' ? (
<p className="text-faint" data-challenge-detail-state="loading">{CHALLENGE_TEXT.claimPending}</p>
) : (
<div className="flex flex-wrap items-center gap-x-2 gap-y-1" data-challenge-detail-state={wait}>
<span role={wait === 'error' ? 'alert' : undefined} style={{ color: 'var(--st-waiting)' }}>
{wait === 'error' ? CHALLENGE_TEXT.claimFailed : CHALLENGE_TEXT.claimNoDetail}
</span>
{wait === 'error' && onRetry && (
<button type="button" className="btn btn-xs" data-challenge-retry="" onClick={onRetry}>{CHALLENGE_TEXT.retry}</button>
)}
</div>
)}
<p className="text-faint" data-challenge-judged="">
{verdict === 'inconclusive' ? CHALLENGE_TEXT.judgedUnsure : CHALLENGE_TEXT.judgedBy(null)}
</p>
</div>
)
}
+101 -38
View File
@@ -5,7 +5,7 @@ import {
} from 'react'
import { createPortal } from 'react-dom'
import {
ListChecks, MessageCircleQuestion, ShieldAlert, ShieldCheck, ShieldMinus, ShieldQuestion, ShieldX, type LucideIcon,
ListChecks, MessageCircleQuestion, ShieldAlert, ShieldCheck, ShieldEllipsis, ShieldMinus, ShieldX, type LucideIcon,
} from 'lucide-react'
import clsx from 'clsx'
import { rovingTarget } from '../components/ui'
@@ -19,8 +19,11 @@ import {
CHALLENGE_TEXT, EVIDENCE_STATE_LABEL, EVIDENCE_TEXT, INQUIRY_TEXT, JUDGE_TEXT, claimTally, evidenceTally,
type ClaimTallyCounts,
} from '../lib/terms'
import { useEvidence, useVerdicts } from '../store/evidence'
import type { ChallengeVerdict, EvidenceBlock, EvidenceDocData, EvidenceSegment, EvidenceUnit, EvidenceVerdict } from '../types'
import { useEvidence, useVerdicts, type Slot } from '../store/evidence'
import type {
ChallengeVerdict, EvidenceBlock, EvidenceChallengeVerdicts, EvidenceDocData, EvidenceGraph, EvidenceSegment, EvidenceUnit,
EvidenceVerdict,
} from '../types'
import { EvidencePanel, type PanelMode, type PanelView } from './EvidencePanel'
import { askAbout, type InquiryAccess } from './Inquiry'
import { BlockView, Markdown, StyledSlice, inlineStyles, numericColumns, type InlineStyles } from './Markdown'
@@ -36,7 +39,8 @@ import { BlockView, Markdown, StyledSlice, inlineStyles, numericColumns, type In
* 结论句的判定(四期)只在句末挂一枚小徽标(◆ ◇ ! ○ ?),整句不画线;证据相矛盾(和旧的证据不支持)的整句
* 铺一层浅底。徽标也是按钮:点开是这一句的「模型的解释」。判定是模型给的,颜色一律不用确定性的绿。
* 被反方审过的句子(期 4,证据图的 reports[].challenge_verdicts)同样在句末挂标记:被推翻、被削弱带字、醒目,经受住、
* 无法判断只有淡色图标;有判定的句子并在同一枚徽标里。点开都是整句面板,没有可点片段的句子也打得开。
* 无法判断只有淡色图标;有判定的句子并在同一枚徽标里。点开都是整句面板,没有可点片段的句子也打得开。证据图有运行就取
* 一次;手里那份是别处早先取的、已经过期(报告改写过、运行收尾之前取的)时重取一次,见 useRunGraph。
*
* 键盘:整份报告只占一个 Tab 位(roving tabindex)。←/→ 在有状态的片段、句末徽标间走,↑/↓ 按
* 句子走(表格里按列走到上一行 / 下一行,出了表格接着按句子走),n / N 跳到下一处 /
@@ -217,23 +221,61 @@ function verticalTarget(model: Model, id: string, down: boolean): string | null
return model.unitFirst[(u + (down ? 1 : -1) + n) % n] ?? null
}
type GraphReport = NonNullable<EvidenceGraph['reports']>[number]
/**
* 这份报告里被反方审过的句子 → 判断(证据图 reports[].challenge_verdicts)。只认证据图里这份报告、而且封存的就是正文
* 这一份(工件 id 对得上)的那一项:证据图说的是这个报告节点最后写的那一稿,正文是另一稿时同一个句子编号说的可能是别的话。
* 证据图里的这一项说的是不是正文这一份:同一个报告节点,封存的就是这一稿(工件 id 对得上)。证据图说的是这个报告节点最后
* 写的那一稿,正文是另一稿时同一个句子编号说的可能是别的话。正文没记报告节点、没给工件 id 的(预览、老文档)不按它比
*/
const sameReport = (r: GraphReport | undefined, report: string | undefined, artifact: string | undefined) =>
(!report || !r?.node_id || r.node_id === report) && (!artifact || r?.doc_artifact === artifact)
/**
* 这次运行的证据图(正文的反方标记、按需判过的句子都从这里来):有运行就取一次,同一次运行只取一回,不逐句请求。
*
* 挂上(或换了一稿)那一刻手里已经有的那一份是别处早先取的,可能过期了。审批卡里展开过报告,取的就是运行停在审批上那一刻
* 的图:之后报告改写了(第二次审批、同一张卡换稿),正文这一稿在那份图里找不到,一个标记都挂不上;正文是运行的成果
* (settled)而那份图没封存,审批之后才审完的反方审稿不在里面。这两种按(运行、报告、工件)重取一次,重取回来还是这样
* 就作罢(正文是改写前的原件时本来就对不上),不反复请求。挂上时还没有、正在取的那一份是这时候取的,不算过期。证据页自己
* 管重取(pages/runs/EvidencePane)
*/
function useRunGraph(runId: string | undefined, report: string | undefined, artifact: string | undefined, settled: boolean):
EvidenceGraph | undefined {
const slot = useEvidence((s) => (runId ? s.graphs[runId] : undefined))
const loadGraph = useEvidence((s) => s.loadGraph)
const reloadGraph = useEvidence((s) => s.reloadGraph)
const key = runId ? `${runId}\u0000${report ?? ''}\u0000${artifact ?? ''}` : ''
// 挂上、换了一稿那一刻手里已经取到的那一份:只有它可能过期,看过一次就放下
const held = useRef<{ key: string; slot: Slot<EvidenceGraph> | null }>({ key: '', slot: null })
useEffect(() => {
if (!runId || held.current.key === key) return
const cur = useEvidence.getState().graphs[runId]
held.current = { key, slot: cur?.status === 'ok' ? cur : null }
void loadGraph(runId)
}, [runId, key, loadGraph])
useEffect(() => {
const h = held.current
if (!runId || h.key !== key || !h.slot || slot !== h.slot) return
h.slot = null
const graph = slot.data
const mine = (graph?.reports ?? []).some((r) => sameReport(r, report, artifact))
if (!mine || (settled && !graph?.seal?.sealed)) void reloadGraph(runId)
}, [runId, key, slot, report, artifact, settled, reloadGraph])
return slot?.data
}
/**
* 这份报告里被反方审过的句子 → 判断(证据图 reports[].challenge_verdicts),只认说的就是正文这一份的那一项(sameReport)。
* 没有运行、证据图还没取到(或取不到)、一句都没审、老服务端都是 undefined
*/
function useChallengeMarks(runId: string | undefined, report: string | undefined, artifact: string | undefined):
Record<string, string> | undefined {
const graph = useEvidence((s) => (runId ? s.graphs[runId]?.data : undefined))
return useMemo(() => {
const hit = (graph?.reports ?? []).find((r) => (!report || !r?.node_id || r.node_id === report)
&& (!artifact || r?.doc_artifact === artifact))
const raw: unknown = hit?.challenge_verdicts
if (!raw || typeof raw !== 'object') return undefined
const marks = Object.fromEntries(Object.entries(raw as Record<string, unknown>)
.filter((e): e is [string, string] => !!e[0] && typeof e[1] === 'string' && !!e[1]))
return Object.keys(marks).length ? marks : undefined
}, [graph, report, artifact])
function challengeMarks(graph: EvidenceGraph | undefined, report: string | undefined, artifact: string | undefined):
EvidenceChallengeVerdicts | undefined {
const hit = (graph?.reports ?? []).find((r) => sameReport(r, report, artifact))
const raw: unknown = hit?.challenge_verdicts
if (!raw || typeof raw !== 'object') return undefined
const marks = Object.fromEntries(Object.entries(raw as Record<string, unknown>)
.filter((e): e is [string, string] => !!e[0] && typeof e[1] === 'string' && !!e[1]))
return Object.keys(marks).length ? marks : undefined
}
/** 句末标记读屏念的那一句:截到 40 字(同 lib/evidence 的 claimLabel) */
@@ -302,6 +344,11 @@ export const EvidenceDoc = forwardRef<EvidenceDocHandle, {
* 数字的出处都对得上,档位却因为别的原因(比如查询没通过 SQL 检查)降了
*/
tier?: string
/**
* 正文是运行的成果(成果区、问数据的回答,EvidenceField 给):运行已经结束。手里那份证据图要是没封存,就是收尾之前取的
* (比如审批卡里展开报告时),重取一次,见 useRunGraph
*/
settled?: boolean
/**
* 审批质询(期 4):给了就在每句结论后面挂「质询」(悬停、焦点在这一句上时出现),划选原文时浮出「质询」,点了打开
* 这份报告的提问框。能不能问由页面按运行状态定(审批卡:运行停在审批上;运行详情:封存了的探索运行),approvalId 是
@@ -309,23 +356,22 @@ export const EvidenceDoc = forwardRef<EvidenceDocHandle, {
*/
inquiry?: InquiryAccess | null
}>(function EvidenceDoc({ doc, artifact, runId, dense = false, label, panel = 'auto', dock, onView, tally = false, runClass,
tier, inquiry }, ref) {
tier, settled = false, inquiry }, ref) {
const blocks = useMemo(() => doc.blocks ?? [], [doc])
const report = doc.node_id || undefined
// 质询要知道是哪次运行的哪份报告:两样缺一样就不挂入口
const ask = !!inquiry && !!runId && !!report
// 封存之后按需追加的判定:盖过文档里的「未裁判 · 按需」。只换句末徽标,封存的文档一个字不改
const overlay = useVerdicts(runId, report)
// 有运行就取这次运行的证据图(同一次运行只取一次,不逐句请求;过期了重取一次):它带着被反方审过的句子
// (reports[].challenge_verdicts,正式、探索运行都可能有,反方审稿在报告写完之后才审,文档里没有这份记录),探索运行的
// 报告还带着之前按需判过的句子(reports[].post_seal_verdicts,useVerdicts 读),重新打开页面时标记、徽标都还在
const graph = useRunGraph(runId, report, artifact, settled)
// 被反方审过的句子:句末挂标记(和裁判的判定并在一个徽标里),点开是整句面板
const marks = useChallengeMarks(runId, report, artifact)
const marks = useMemo(() => challengeMarks(graph, report, artifact), [graph, report, artifact])
const model = useMemo(() => buildModel(blocks, overlay, ask, marks), [blocks, overlay, ask, marks])
const counts = useMemo(() => docTally(doc), [doc])
const claims = useMemo(() => claimCounts(doc, overlay), [doc, overlay])
// 有运行就取一次这次运行的证据图(同一次运行只取一次,不逐句请求):它带着被反方审过的句子(reports[].challenge_verdicts,
// 正式、探索运行都可能有,反方审稿在报告写完之后才审,文档里没有这份记录),探索运行的报告还带着之前按需判过的句子
// (reports[].post_seal_verdicts),重新打开页面时标记、徽标都还在
const loadGraph = useEvidence((s) => s.loadGraph)
useEffect(() => { if (runId) void loadGraph(runId) }, [runId, loadGraph])
const rootRef = useRef<HTMLDivElement>(null)
const instance = useId()
const panelId = `${instance}-panel`
@@ -344,9 +390,10 @@ export const EvidenceDoc = forwardRef<EvidenceDocHandle, {
setView(null)
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [blocks])
// 拿着 Tab 位的徽标没了(判成「不是结论句」):Tab 位交回第一个,整份报告不能一个 Tab 位都没有
// 拿着 Tab 位的徽标没了(判成「不是结论句」),或者挂上时一个键盘目标都没有(没有可点片段、没开裁判、没给质询)、
// 反方标记随证据图后来才到:Tab 位交给第一个,整份报告不能一个 Tab 位都没有
useEffect(() => {
if (current && !model.index.has(current)) setCurrent(model.order[0] ?? null)
if (current ? !model.index.has(current) : model.order.length > 0) setCurrent(model.order[0] ?? null)
}, [model, current])
// 同一时刻只开一个面板:另一份报告打开了自己的面板,这边的就收起
@@ -402,7 +449,8 @@ export const EvidenceDoc = forwardRef<EvidenceDocHandle, {
if (badge) {
claim(instance)
setView({ kind: 'unit', id: badge.unit.id })
setAnnounce(`${badge.verdict ? JUDGE_TEXT.section : CHALLENGE_TEXT.claimTitle}:${badgeLabel(badge)}`)
// 只有反方标记的句子:读屏名本身就说了「反方审稿:被推翻」,前面不再加一个标题,免得「反方审稿」念两遍
setAnnounce(badge.verdict ? `${JUDGE_TEXT.section}:${badgeLabel(badge)}` : badgeLabel(badge))
return
}
const hit = model.seg.get(id)
@@ -551,6 +599,7 @@ export const EvidenceDoc = forwardRef<EvidenceDocHandle, {
artifact={artifact}
runId={runId}
runClass={runClass}
marks={marks}
view={view}
onClose={() => close()}
onLocate={(id) => { focusSeg(id, { flash: true }); openSeg(id) }}
@@ -921,22 +970,31 @@ const DocBlock = memo(function DocBlock({ block, dense, doc, visual, current, ac
}
})
/** 反方审稿的判断在句末徽标里的样子 */
/** 反方审稿的判断在句末徽标里的样子。soft 是悬停、展开时铺的浅底,醒目的那两种不铺(见 LOUD_RING) */
interface MarkLook { icon: LucideIcon; color: string; soft: string; loud: boolean }
/**
* 被推翻、被削弱醒目:盾牌图标加判断两个字,用失败色、提醒色;经受住、无法判断低调:只有淡色的盾牌图标(悬停、读屏照样
* 说得出是哪一种)。四种图标各不相同,去掉颜色也分得开;判断是反方模型给的,经受住也不用确定性的绿。认不出的判断按低调画
* 说得出是哪一种)。四种图标各不相同,去掉颜色也分得开:无法判断用省略号不用问号——句末常常已经有裁判的「?」(未裁判、
* 证据不足)和「质询」的问号,再添一个问号就分不清了,和经受住的勾也更好分。判断是反方模型给的,经受住也不用确定性的绿。
* 认不出的判断按低调画
*/
const MARK_LOOK: Record<ChallengeVerdict, MarkLook> = {
refuted: { icon: ShieldX, color: 'var(--st-failed)', soft: 'var(--st-failed-soft)', loud: true },
weakened: { icon: ShieldMinus, color: 'var(--st-waiting)', soft: 'var(--st-waiting-soft)', loud: true },
refuted: { icon: ShieldX, color: 'var(--st-failed)', soft: 'transparent', loud: true },
weakened: { icon: ShieldMinus, color: 'var(--st-waiting)', soft: 'transparent', loud: true },
stands: { icon: ShieldCheck, color: 'var(--text-faint)', soft: 'var(--st-idle-soft)', loud: false },
inconclusive: { icon: ShieldQuestion, color: 'var(--text-faint)', soft: 'var(--st-idle-soft)', loud: false },
inconclusive: { icon: ShieldEllipsis, color: 'var(--text-faint)', soft: 'var(--st-idle-soft)', loud: false },
}
const markLook = (verdict: string): MarkLook => (Object.hasOwn(MARK_LOOK, verdict) ? MARK_LOOK[verdict as ChallengeVerdict]
: { icon: ShieldAlert, color: 'var(--text-faint)', soft: 'var(--st-idle-soft)', loud: false })
/**
* 带字的醒目标记悬停、展开时不铺浅底(index.css 的 .ev-badge 按 --ev-soft 铺),改描一圈细边:10px 的失败色、提醒色字叠在
* 14% 的浅底上,浅色主题里对比度只有 4.0 左右(页面底色上),面板开着时这枚标记一直是展开态。和裁判徽标并在一起的同样
* 不铺(浅底是裁判判定的颜色,字是反方的颜色)。细边用徽标的字色,和焦点环(2px 强调色、外扩)分得开
*/
const LOUD_RING = 'hover:shadow-[inset_0_0_0_1px_currentColor] aria-expanded:shadow-[inset_0_0_0_1px_currentColor]'
/**
* 句末徽标里反方审稿的那一截。和裁判的字形并在一个徽标里时跟在字形后面(after)。醒目的那两种连字一起写:字号定成
* 10px(同句末的「无证据」小标签),窄栏里 0.72em 的上标只有 8px,汉字认不清
@@ -1014,7 +1072,10 @@ function UnitView({ unit, doc, current, active, panelId, code, tag, badge, ask }
? `${meta.label}${verdict.post_seal ? ` · ${JUDGE_TEXT.postSeal}` : ''}(${verdict.judge || JUDGE_TEXT.judgeModel} · 非确定)${
verdictMissing(verdict) ? `。${JUDGE_TEXT.missing(verdictMissing(verdict))}` : ''}`
: limitOf(verdict) ? `${meta.label}:${JUDGE_TEXT.limitNotJudged}` : `${meta.label}:${meta.hint}`
const challengeTitle = badge?.challenge ? CHALLENGE_TEXT.markTitle(challengeLabel(badge.challenge)) : ''
// 无法判断的句子可能根本没反查成(服务端按规则记的无法判断,反方模型没看过),正文里分不出是哪一种:不说成反方模型的判断
const challengeTitle = !badge?.challenge ? ''
: badge.challenge === 'inconclusive' ? CHALLENGE_TEXT.markTitleUnsure(challengeLabel(badge.challenge))
: CHALLENGE_TEXT.markTitle(challengeLabel(badge.challenge))
const look = badge?.challenge ? markLook(badge.challenge) : null
const body = (
<>
@@ -1030,7 +1091,7 @@ function UnitView({ unit, doc, current, active, panelId, code, tag, badge, ask }
{badge && (meta || look) && (
<button
type="button"
className="ev-badge"
className={clsx('ev-badge', look?.loud && LOUD_RING)}
data-ev-claim={unit.id}
data-ev-verdict={badge.state}
data-ev-post-seal={verdict?.post_seal ? '' : undefined}
@@ -1040,8 +1101,9 @@ function UnitView({ unit, doc, current, active, panelId, code, tag, badge, ask }
aria-expanded={open}
aria-controls={open ? panelId : undefined}
title={[judgedTitle, challengeTitle].filter(Boolean).join('。')}
// 字形的颜色照裁判的判定;只被反方审过的照反方的判断(悬停的浅底同理)
style={meta ? segStyle(badge.state!) : { '--ev-glyph': look!.color, '--ev-soft': look!.soft } as CSSProperties}
// 字形的颜色照裁判的判定;只被反方审过的照反方的判断(悬停的浅底同理)。带着醒目的反方标记时不铺浅底(LOUD_RING)
style={meta ? { ...segStyle(badge.state!), ...(look?.loud ? { '--ev-soft': 'transparent' } : {}) } as CSSProperties
: { '--ev-glyph': look!.color, '--ev-soft': look!.soft } as CSSProperties}
>
{meta && <span aria-hidden="true">{meta.glyph}</span>}
{look && <ChallengeMark verdict={badge.challenge!} look={look} after={!!meta} />}
@@ -1100,8 +1162,9 @@ export const EvidenceField = forwardRef<EvidenceDocHandle, {
const counted = useMemo(() => (usable ? withVerdicts(usable, overlay) : null), [usable, overlay])
useEffect(() => { onDoc?.(counted) }, [counted, onDoc])
if (usable) {
// 成果只在运行结束之后才有:手里那份证据图要是没封存,就是收尾之前取的(settled,见 useRunGraph)
return <EvidenceDoc ref={ref} doc={usable} artifact={artifact} runId={runId} dense={dense} label={label} tally={tally}
runClass={runClass} />
runClass={runClass} settled />
}
const note = slot?.status === 'error' ? EVIDENCE_TEXT.docMissing
: otherRun ? EVIDENCE_TEXT.docOtherRun : mismatch ? EVIDENCE_TEXT.docMismatch : ''
+79 -20
View File
@@ -25,12 +25,12 @@ import {
import { useCatalog } from '../store/catalog'
import { askKey, segmentKey, useEvidence, useExplore, useVerdicts } from '../store/evidence'
import type {
ApprovalReport, EvidenceBlock, EvidenceDocData, EvidenceDualCheck, EvidenceInput, EvidenceMerge, EvidenceOnDemand,
EvidenceQuoteSource, EvidenceSeal, EvidenceSegment, EvidenceSegmentDetail, EvidenceStep, EvidenceUnit, EvidenceUnitChallenge,
EvidenceVerdict, EvidenceViolation,
ApprovalReport, EvidenceBlock, EvidenceChallengeVerdicts, EvidenceDocData, EvidenceDualCheck, EvidenceInput, EvidenceMerge,
EvidenceOnDemand, EvidenceQuoteSource, EvidenceSeal, EvidenceSegment, EvidenceSegmentDetail, EvidenceStep, EvidenceUnit,
EvidenceUnitChallenge, EvidenceVerdict, EvidenceViolation,
} from '../types'
import { ArtifactViewer, ResultTable } from './AssistantStream'
import { ChallengeSummary } from './ChallengeSummary'
import { ChallengeSummary, ClaimVerdictPending, type ClaimWait } from './ChallengeSummary'
import { useEvidenceHost } from './evidenceHost'
import { EvidenceProvenance } from './EvidenceProvenance'
import { CopyChip } from './Markdown'
@@ -80,7 +80,8 @@ import {
* 不对、没选、未能完成的写明报告里的数没换、已记为缺口;句子被反方审过的(点开整句、点开句中的数字都一样)多一节反方
* 审稿,用审批卡那一块的单句展示(run/ChallengeSummary 的 scope="claim"):这一句的判断、它可能没反查成的说明,展开看
* 反方的理由和查询,不画报告级的标题和计数,不说出具会不会降档(运行已经结束,看报告的出具横幅)。正文里被审过的句子
* 挂句末标记(run/EvidenceDoc),点开就是整句面板。取自遮罩列的输入,服务端已把值换成「已遮罩」,标签照样写「已遮罩」,
* 挂句末标记(run/EvidenceDoc),点开就是整句面板;片段接口还没答回来、答不了时,这一节先按标记(marks,证据图)写出
* 判断,说清在等什么、给重试(ClaimVerdictPending)。取自遮罩列的输入,服务端已把值换成「已遮罩」,标签照样写「已遮罩」,
* 输入来源里只说核对结果、不写值;遮没遮核对不了的(快照读不出来)同样不显示值,写明原因。类型都在 types.ts
* (EvidenceDualCheck、EvidenceUnitChallenge、EvidenceInput 的 masked / mask_unverified)。
*
@@ -129,7 +130,7 @@ function unverifiedOf(input: EvidenceInput): string {
export type PanelMode = 'side' | 'drawer' | 'inline' | 'dock'
export type PanelView = { kind: 'seg'; id: string } | { kind: 'unit'; id: string } | { kind: 'violations' }
export function EvidencePanel({ id, mode, doc, artifact, runId, runClass, view, onClose, onLocate, onViolations }: {
export function EvidencePanel({ id, mode, doc, artifact, runId, runClass, marks, view, onClose, onLocate, onViolations }: {
id: string
mode: PanelMode
doc: EvidenceDocData
@@ -138,6 +139,11 @@ export function EvidencePanel({ id, mode, doc, artifact, runId, runClass, view,
runId?: string
/** 运行类别:没开裁判的文档靠它认探索运行(「请模型判断这句」只在探索运行里有) */
runClass?: string
/**
* 正文句末标记用的反方审稿判断(证据图的 challenge_verdicts,正文已经按这一份对过工件 id):片段接口的 unit.challenge
* 还没答回来、答不了时,「反方审稿」一节先按它写出判断
*/
marks?: EvidenceChallengeVerdicts
view: PanelView
onClose: () => void
/** 跳到正文里的某个片段(违规清单里的「定位」) */
@@ -219,10 +225,11 @@ export function EvidencePanel({ id, mode, doc, artifact, runId, runClass, view,
? <ViolationList doc={doc} onLocate={onLocate} />
: found
? <SegmentBody panelId={id} doc={doc} artifact={artifact} runId={runId} runClass={runClass} seg={found.seg}
unit={found.unit} block={found.block} onViolations={onViolations} onLocate={onLocate} />
unit={found.unit} block={found.block} mark={marks?.[found.unit.id]} onViolations={onViolations}
onLocate={onLocate} />
: claimAt
? <ClaimBody doc={doc} artifact={artifact} runId={runId} runClass={runClass} unit={claimAt.unit}
block={claimAt.block} />
block={claimAt.block} mark={marks?.[claimAt.unit.id]} />
: <p className="text-dim">{NONE}</p>}
</div>
</section>
@@ -263,10 +270,12 @@ function flashOnce(el: HTMLElement) {
setTimeout(() => { if (el.dataset.flash === 'focus') delete el.dataset.flash }, 1600)
}
function SegmentBody({ panelId, doc, artifact, runId, runClass, seg, unit, block, onViolations, onLocate }: {
function SegmentBody({ panelId, doc, artifact, runId, runClass, seg, unit, block, mark, onViolations, onLocate }: {
panelId: string
doc: EvidenceDocData; artifact?: string; runId?: string; runClass?: string; seg: EvidenceSegment; unit: EvidenceUnit
block: EvidenceBlock
/** 正文标记上这一句的反方审稿判断(证据图):片段接口答回来之前先按它写 */
mark?: string
onViolations: () => void
/** 跳到正文里的某个片段(推演区「报告中会变的地方」的定位) */
onLocate: (segId: string) => void
@@ -394,6 +403,7 @@ function SegmentBody({ panelId, doc, artifact, runId, runClass, seg, unit, block
: docIssue ? EVIDENCE_TEXT.chainForeign
: slot?.status === 'error' ? EVIDENCE_TEXT.chainMissing : ''
const segChallenge = docIssue ? null : challengeOf(detail?.unit)
const segWait = waitOf(slot?.status, !!runId)
return (
<>
@@ -510,9 +520,12 @@ function SegmentBody({ panelId, doc, artifact, runId, runClass, seg, unit, block
<JudgePart doc={doc} unit={unit} block={block} runId={runId} runClass={runClass}
onDemand={detail?.unit?.on_demand} answered={detail?.unit?.verdict} pending={pending} />
{/* 反方审稿对这一句的判断:点句中的数字也看得到(没开结论句裁判的报告没有句末徽标,这里常是唯一的入口)。
正文不是封存的那一份时不用:服务端认的是封存的那份文档 */}
{segChallenge && <ChallengePart challenge={segChallenge} unit={unit} report={report} />}
{/* 反方审稿对这一句的判断:点句中的数字也看得到。片段接口还没答、答不了时先按正文标记写判断。正文不是封存的那一份
时都不用:服务端认的是封存的那份文档 */}
{!docIssue && (segChallenge || mark) && (
<ChallengePart challenge={segChallenge} mark={mark} wait={segWait} unit={unit} report={report}
onRetry={() => { if (runId) void loadSegment(runId, seg.id, report) }} />
)}
{host.onNode && (trace.producers.length > 0 || trace.consumers.length > 0) && (
// 画布右栏:这段证据经过的节点,点一下在画布上选中并对准
@@ -565,8 +578,13 @@ function useLateVerdict(runId: string | undefined, report: string | undefined,
* 点句末徽标打开的整句:句子、模型的解释、挂的依据、封存。封存状态和叠上的判定借这句第一个片段的
* 片段接口取(接口答的是另一份报告时一概不用)
*/
function ClaimBody({ doc, artifact, runId, runClass, unit, block }: {
function ClaimBody({ doc, artifact, runId, runClass, unit, block, mark }: {
doc: EvidenceDocData; artifact?: string; runId?: string; runClass?: string; unit: EvidenceUnit; block: EvidenceBlock
/**
* 正文标记上这一句的反方审稿判断(证据图):片段接口答回来之前、答不了时先按它写。没有可点片段、也没有裁判判定的句子
* 只能从这枚标记点进来
*/
mark?: string
}) {
const report = doc.node_id || undefined
const first = (unit.segments ?? []).find((s) => s.kind !== 'structural')
@@ -592,8 +610,10 @@ function ClaimBody({ doc, artifact, runId, runClass, unit, block }: {
const cites = (unit.cites ?? []).map((alias) => ({ alias, label: doc.catalog?.[alias]?.label as string | undefined }))
// 讲方法、讲结构的句子:SQL 和字段清单直接列在挂的依据下面。正文不是封存的那份时不列(链是另一份报告的)
const basis = useMemo(() => (foreign ? null : claimBasis(unit, doc)), [foreign, unit, doc])
// 反方审稿对这一句的判断:服务端只认审的就是封存的这一份文档;正文不是那一份时不用
// 反方审稿对这一句的判断:服务端只认审的就是封存的这一份文档;正文不是那一份时不用。片段接口还没答、答不了时先按正文
// 标记写(证据图,正文已经按工件 id 对过)
const challenge = foreign ? null : challengeOf(answered?.unit)
const wait = first ? waitOf(slot?.status, !!runId) : 'missing'
return (
<>
{foreign && (
@@ -607,7 +627,10 @@ function ClaimBody({ doc, artifact, runId, runClass, unit, block }: {
onDemand={foreign ? undefined : answered?.unit?.on_demand}
answered={foreign ? undefined : answered?.unit?.verdict}
pending={!!runId && !!first && (!slot || slot.status === 'loading')} />
{challenge && <ChallengePart challenge={challenge} unit={unit} report={report} />}
{!foreign && (challenge || mark) && (
<ChallengePart challenge={challenge} mark={mark} wait={wait} unit={unit} report={report}
onRetry={() => { if (runId && first) void loadSegment(runId, first.id, report) }} />
)}
<Part title={JUDGE_TEXT.cites} data-ev-cites="">
{cites.length ? (
<ul className="space-y-0.5">
@@ -643,23 +666,59 @@ function ClaimBody({ doc, artifact, runId, runClass, unit, block }: {
* 不谈出具(issuance={false},也不传 degrades):审批卡上预告「出具会降档」,是因为那时运行还没出具。证据面板看的是已经
* 结束的运行,降没降档、出没出具以报告的出具横幅(封存的出具判定)为准,再说一遍将来时的预告只会和横幅对不上(驳回了、
* 不予出具、反方审稿不在成果节点上游……)
*
* 判断有两个来源:片段接口答的 unit.challenge(带审稿记录和整份报告的计数,单句展示要它),和正文标记用的证据图(mark,
* 只有判断)。片段接口还在取、取不到、答了却没有可用的 unit.challenge 时,先按标记画出判断,说清在等什么,取不到给重试
* (ClaimVerdictPending):用户是点着句末醒目的「被推翻」进来的,没开裁判的报告里这几句也没有别的入口,这一节不能空着
*/
function ChallengePart({ challenge, unit, report }: { challenge: EvidenceUnitChallenge; unit: EvidenceUnit; report?: string }) {
const reports = useMemo<ApprovalReport[]>(() => [{
function ChallengePart({ challenge, mark, wait, onRetry, unit, report }: {
challenge: EvidenceUnitChallenge | null
mark?: string
/** 片段接口那一头:还在取、取不到、答了却没有可用的 unit.challenge(只在没有 challenge 时用得上) */
wait: ClaimWait
/** 重取这一句的片段接口 */
onRetry: () => void
unit: EvidenceUnit; report?: string
}) {
const reports = useMemo<ApprovalReport[]>(() => (challenge ? [{
node_id: report ?? '', label: challenge.report_label || report || '',
challenge: {
counts: challenge.counts, items: [{ unit: unit.id, text: unitText(unit).trim(), verdict: challenge.verdict }],
artifact: challenge.artifact ?? null, on_refuted: challenge.on_refuted,
...(typeof challenge.unreviewed === 'number' ? { unreviewed: challenge.unreviewed } : {}),
},
}], [challenge, unit, report])
}] : []), [challenge, unit, report])
// 按过「重试」:按钮一请求就拿掉了,焦点会掉到页面上。取到了落到完整展示里的「反方的理由与查询」(没有审稿记录、展开
// 不了时落到这一节上),又没取到落到新的「重试」上;这一会儿用户已经去了别处的不抢
const boxRef = useRef<HTMLDivElement>(null)
const retried = useRef(false)
const settledWait = challenge ? 'ok' : wait
useEffect(() => {
if (!retried.current || settledWait === 'loading') return
retried.current = false
if (document.activeElement && document.activeElement !== document.body) return
const box = boxRef.current
;(box?.querySelector<HTMLElement>('[data-challenge-toggle], [data-challenge-retry]') ?? box)?.focus()
}, [settledWait])
const verdict = challenge?.verdict ?? mark
if (!verdict) return null
return (
<Part title={CHALLENGE_TEXT.claimTitle} data-ev-challenge={challenge.verdict}>
<ChallengeSummary reports={reports} scope="claim" issuance={false} />
<Part title={CHALLENGE_TEXT.claimTitle} data-ev-challenge={verdict}>
<div ref={boxRef} tabIndex={-1} className="rounded-sm outline-none focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-1 focus-visible:outline-[color:var(--accent)]">
{challenge
? <ChallengeSummary reports={reports} scope="claim" issuance={false} />
: <ClaimVerdictPending verdict={verdict} wait={wait} onRetry={() => { retried.current = true; onRetry() }} />}
</div>
</Part>
)
}
/** 片段接口那一头现在的样子,给反方审稿的先行版用:没有运行时不会有答复,算答了却没有 */
function waitOf(status: 'loading' | 'ok' | 'error' | undefined, run: boolean): ClaimWait {
if (!run) return 'missing'
return !status || status === 'loading' ? 'loading' : status === 'error' ? 'error' : 'missing'
}
/**
* 模型的解释:只对结论句。判定、理由(斜体)、「模型判断 · 模型名 · 非确定」的徽标,封存之后按需追加的
* 另写「封存后追加」;到上限没判的写明哪个上限、到哪里调;改写过一次的写明原句。探索运行里还没判过的
+7 -1
View File
@@ -2042,7 +2042,7 @@ export interface EvidenceGraph {
* 期 4:被反方审过的句子 → 判断(_challenge_verdicts,和片段接口的 unit.challenge 同一个读法,每句的判断
* 一字不差)。正文据此给被审过的句子挂句末标记、点开整句面板。一句都没审、文档读不出来、老服务端都没有这个键
*/
challenge_verdicts?: Record<string, ChallengeVerdict | (string & {})> }[]
challenge_verdicts?: EvidenceChallengeVerdicts }[]
evidence?: { alias?: string; eid?: string; kind?: string; label?: string; node_id?: string; artifact?: string
sealed?: boolean; cited_by?: string[]; report?: string }[]
edges?: { from: string; to: string; rel: string }[]
@@ -2132,6 +2132,12 @@ export interface EvidenceDualCheck {
reason?: string
}
/**
* 一份报告里被反方审过的句子 → 判断(证据图 reports[].challenge_verdicts,_challenge_verdicts)。只有被审过的句子;判断和
* 点开这一句时片段接口答的 unit.challenge.verdict 一字不差。正文据此挂句末标记,证据面板在片段接口答回来之前先按它写判断
*/
export type EvidenceChallengeVerdicts = Record<string, ChallengeVerdict | (string & {})>
/** 句子上的反方审稿判断(_challenge_of):片段接口答的 unit.challenge。没被反方审过的句子没有这个键 */
export interface EvidenceUnitChallenge {
/** 这一句的判断(反方模型给的,不是系统核对) */
+19
View File
@@ -439,6 +439,25 @@ await section('整张审批卡:把审批带着的运行类别交给反方审
await ctx.close()
})
await section('证据面板的单句展示、不谈出具:给了正式运行、服务端说会降档,也一句和出具有关的话都不说,不为此取运行类别', async () => {
// 证据面板看的是已经结束的运行,降没降档以报告的出具横幅为准,单句那一块传 issuance={false}。以前证据面板既不传运行 id
// 也不传运行类别,这个开关在哪个用例里都观察不到:改成忽略它,「出具会降档」悄悄回到单句面板也没有检查会发现。用例
// challenge-claim-quiet 把审批卡上写降档要的几样(正式运行、运行 id、被推翻、degrades)都给齐了;那次运行的类别要是
// 去取,答的是正式运行
const { ctx, page, hits, errors } = await open('challenge-claim-quiet')
const block = page.locator('[data-challenge="write"][data-challenge-scope="claim"]')
await block.waitFor()
await page.waitForTimeout(500)
const all = await text(block)
check('单句:只画这一句的判断(被推翻),不画报告级的标题和计数', (await text(block.locator('[data-challenge-tag]'))) === '被推翻'
&& await page.locator('[data-challenge-counts], [data-challenge-items]').count() === 0, all)
check('……不谈出具:不写降档、不在出具路径上、只标注', await page.locator('[data-challenge-degrade], [data-challenge-degrade-note], '
+ '[data-challenge-degrade-off], [data-challenge-flag]').count() === 0 && !all.includes('降档') && !all.includes('出具'), all)
check('……也不为此取这次运行的类别', !hits.runs.includes(RUNS.formal), hits.runs.join('、') || '一次都没取')
check('……页面没有报错', errors.length === 0, errors.join(';'))
await ctx.close()
})
await section('有句子反查没完成:单独说一行,不混在「无法判断」里,不插在降档标记和它的说明中间', async () => {
// 服务端的 unreviewed:核查模型不可用、触顶没给出结论、数据源不在了……这几句记为无法判断,可反查没有完成。「无法判断
// 3 句」分不出是查了、数据不够,还是没查成,审批卡单独说。未能反查的每一句都记为无法判断,unreviewed 不会多于它
+323 -5
View File
@@ -3534,7 +3534,9 @@ await section('verify', '期 4:指标步骤的双盲复算、取自遮罩列
const block = cp.locator('[data-ev-challenge]')
const blockText = async () => (await block.innerText().catch(() => '')).replace(/\s+/g, ' ')
await badge(c.page, J, u.bad).click()
await c.page.waitForSelector('[data-evidence-panel] [data-ev-challenge] [data-challenge-item]', { timeout: 4000 }).catch(() => {})
// 单句展示没有逐句的条目(data-challenge-item):等的是片段接口答回来之后的单句那一块和它的判断标签
await c.page.waitForSelector('[data-evidence-panel] [data-ev-challenge] [data-challenge-scope="claim"]:not([data-challenge-pending]) '
+ '[data-challenge-tag]', { timeout: 4000 }).catch(() => {})
const text = await blockText()
if (w === 1280) {
check('整句面板:「反方审稿」一节写这一句的判断(被推翻),用单句展示', await block.getAttribute('data-ev-challenge', { timeout: 3000 }).catch(() => null) === 'refuted'
@@ -3612,6 +3614,11 @@ const MARK_COUNTS = {
plain: { counts: { stands: 1, weakened: 1, refuted: 1, inconclusive: 1 }, unreviewed: 1 },
formal: { counts: { stands: 1, weakened: 0, refuted: 1, inconclusive: 2 }, unreviewed: 1 },
}
/**
* 片段接口答回来之后的完整单句展示(面板里的「反方审稿」一节)。答回来之前那一节先按标记写判断(data-challenge-pending),
* 等的是之后这一块
*/
const FULL_CLAIM = '[data-evidence-panel] [data-ev-challenge] [data-challenge-scope="claim"]:not([data-challenge-pending])'
const markSet = (jset) => (jset === fxj.plain ? 'plain' : jset === fxj.formal ? 'formal' : jset === fxj.explore ? 'explore' : '')
const markGraph = (jset, g) => {
const key = markSet(jset)
@@ -3634,6 +3641,40 @@ function blendOver(fg, bg, alpha) {
const [f, b] = [nums(fg), nums(bg)]
return `rgb(${f.map((v, i) => Math.round(v * alpha + b[i] * (1 - alpha))).join(', ')})`
}
/** getComputedStyle 给的颜色(rgb / rgba / color(srgb …))→ [r, g, b, a],r g b 取 0–255 */
function rgbaOf(c) {
const m = c.match(/color\(srgb ([\d.]+) ([\d.]+) ([\d.]+)(?: \/ ([\d.]+))?\)/)
if (m) return [m[1] * 255, m[2] * 255, m[3] * 255, m[4] == null ? 1 : Number(m[4])]
const n = c.match(/rgba?\(([\d.]+),\s*([\d.]+),\s*([\d.]+)(?:,\s*([\d.]+))?\)/)
return n ? [Number(n[1]), Number(n[2]), Number(n[3]), n[4] == null ? 1 : Number(n[4])] : [0, 0, 0, 0]
}
/**
* 句末标记里那两个字(醒目的标记)的对比度:标记自己的底色(悬停、展开时铺的浅底)一层层叠到最近的不透明底色上再算。
* 返回比值、各层底色(从标记往外),以及量的时候它是不是展开态、是不是悬停着
*/
async function loudStack(pg, sel) {
const got = await pg.evaluate((s) => {
const btn = document.querySelector(s)
const word = btn?.querySelector('[data-ev-challenge-look="loud"] span')
if (!btn || !word) return null
const layers = []
for (let n = btn; n; n = n.parentElement) {
const c = getComputedStyle(n).backgroundColor
if (c && !/rgba\(0, 0, 0, 0\)|transparent/.test(c)) layers.push(c)
if (/^rgb\(/.test(c) || (c.startsWith('color(srgb') && !c.includes('/'))) break
}
layers.push(getComputedStyle(document.body).backgroundColor)
return { fg: getComputedStyle(word).color, layers, expanded: btn.getAttribute('aria-expanded') === 'true', hover: btn.matches(':hover') }
}, sel)
if (!got) return { ratio: 0, layers: [], expanded: false, hover: false }
let under = [255, 255, 255]
for (const c of [...got.layers].reverse()) {
const [r, g, b, a] = rgbaOf(c)
under = [r, g, b].map((v, i) => v * a + under[i] * (1 - a))
}
return { ratio: contrastOf(got.fg, `rgb(${under.map((v) => Math.round(v)).join(', ')})`), layers: got.layers,
expanded: got.expanded, hover: got.hover }
}
await section('marks', '期 4:被反方审过的句子在正文里挂句末标记——和裁判徽标并在一起、点开是整句面板、不逐句请求', async () => {
const r = await open('/ui-harness.html?evidence=1', { graph: markGraph, segPatch: markSeg })
@@ -3664,9 +3705,17 @@ await section('marks', '期 4:被反方审过的句子在正文里挂句末标
&& by.u3.icon, JSON.stringify([by.u2, by.u3]))
check('经受住、无法判断低调:只有淡色的盾牌图标,不写字', ['u4', 'u6'].every((k) => by[k]?.look === 'quiet' && by[k].icon
&& !by[k].text.trim() && by[k].color === faintC), JSON.stringify([by.u4, by.u6]))
// 低调的两种图标形状不同(经受住是勾、无法判断是省略号):句末已经有裁判的「?」和「质询」的问号,不再添一个问号
const shapes = await pg.evaluate((sel) => ['u4', 'u6'].map((u) => document.querySelector(`${sel} [data-ev-claim="${u}"] svg`)
?.getAttribute('class') ?? ''), JP)
check('……经受住、无法判断的图标形状不同,无法判断不用问号', shapes[0].includes('lucide-shield-ellipsis')
&& shapes[1].includes('lucide-shield-check') && !shapes.some((s) => s.includes('question')), shapes.join(' | '))
check('读屏名写明句子和反方审稿的判断,悬停写明是反方模型的判断',
by.u2?.label === '结论句「增长主要来自新客首单,老客复购持平。」,反方审稿:被推翻'
&& by.u2?.title === '反方审稿:被推翻(反方模型的判断,并非系统核对)', `${by.u2?.label} | ${by.u2?.title}`)
// 未能反查的句子也记为无法判断,正文里分不出是哪一种:无法判断的悬停说明不说成反方模型的判断
check('无法判断的悬停说明:不说成反方模型的判断(可能是未能反查时记下的)',
by.u4?.title === '反方审稿:无法判断(可能是反方模型的判断,也可能是未能反查时记下的,并非系统核对)', by.u4?.title)
const both = await pg.evaluate(({ sel, unit }) => {
const els = document.querySelectorAll(`${sel} [data-ev-claim="${unit}"]`)
@@ -3688,7 +3737,7 @@ await section('marks', '期 4:被反方审过的句子在正文里挂句末标
await pg.keyboard.press('ArrowDown')
check('↓ 从上一句走到只有标记的那一句', await activeKey(pg) === 'claim:u2', await activeKey(pg))
await pg.keyboard.press('Enter')
await pg.waitForSelector('[data-evidence-panel] [data-ev-challenge]', { timeout: 4000 }).catch(() => {})
await pg.waitForSelector(FULL_CLAIM, { timeout: 4000 }).catch(() => {})
const p = panel(pg)
const block = p.locator('[data-ev-challenge]')
const blockText = (await block.innerText().catch(() => '')).replace(/\s+/g, ' ')
@@ -3698,9 +3747,29 @@ await section('marks', '期 4:被反方审过的句子在正文里挂句末标
&& await block.locator('[data-challenge-scope="claim"]').count() === 1, blockText)
check('……只请求了这一句的一个片段', JSON.stringify(segHits()) === JSON.stringify(['j:s11']), segHits().join(','))
check('……标记标着展开了面板', await pg.locator(`${JP} [data-ev-claim="u2"]`).getAttribute('aria-expanded') === 'true')
check('……读屏从 live region 听到这一句的反方审稿判断',
(await pg.locator(`${JP} [aria-live="polite"]`).first().innerText()).includes('反方审稿:被推翻'))
// 只有反方标记的句子:读屏名本身已经说了「反方审稿:被推翻」,前面不再加一个「反方审稿:」
const said = await pg.locator(`${JP} [aria-live="polite"]`).first().innerText()
check('……读屏从 live region 听到这一句和反方审稿的判断,「反方审稿」只说一次',
said === '结论句「增长主要来自新客首单,老客复购持平。」,反方审稿:被推翻', said)
check('……判断不是无法判断:不说未能反查', await p.locator('[data-challenge-unreviewed]').count() === 0)
// 面板开着时这枚标记一直是展开态(悬停同理):带字的醒目标记不铺浅底——10px 的失败色、提醒色字叠在 14% 的浅底上,
// 浅色主题里不到 4.5。按标记自己的底色叠在外面的底色上算,深浅两套都量;悬停的是被削弱那一枚,和正式运行里和裁判徽标
// 并在一起的那一枚(浅底是裁判判定的颜色,字是反方的失败色)
for (const theme of ['light', 'dark']) {
await pg.evaluate((t) => document.documentElement.setAttribute('data-theme', t), theme)
await pg.waitForTimeout(100)
const open = await loudStack(pg, `${JP} [data-ev-claim="u2"]`)
await pg.locator(`${JP} [data-ev-claim="u3"]`).hover()
const hover = await loudStack(pg, `${JP} [data-ev-claim="u3"]`)
await pg.locator(`${J} [data-ev-claim="${fxj.formal.units.bad}"]`).hover()
const both = await loudStack(pg, `${J} [data-ev-claim="${fxj.formal.units.bad}"]`)
check(`${theme}:展开态、悬停时带字的标记对比度 ≥ 4.5`, open.expanded && hover.hover && both.hover
&& Math.min(open.ratio, hover.ratio, both.ratio) >= 4.5,
`展开 ${open.ratio.toFixed(2)}(${open.layers.join(' / ')})· 悬停 ${hover.ratio.toFixed(2)} · 并在一起的 ${both.ratio.toFixed(2)}`)
}
await pg.mouse.move(1, 1)
await pg.evaluate(() => document.documentElement.removeAttribute('data-theme'))
await pg.locator(`${JP} [data-ev-claim="u2"]`).focus()
await pg.keyboard.press('Escape')
await pg.waitForTimeout(150)
check('Esc 关掉,焦点回到标记', await panel(pg).count() === 0 && await activeKey(pg) === 'claim:u2', await activeKey(pg))
@@ -3712,6 +3781,10 @@ await section('marks', '期 4:被反方审过的句子在正文里挂句末标
const sureText = (await sure.innerText().catch(() => '')).replace(/\s+/g, ' ')
check('无法判断、而无法判断的全是没反查成的:说这一句未能反查', await sure.getAttribute('data-challenge-unreviewed').catch(() => null) === 'claim'
&& sureText.startsWith('这一句未能反查,已记为无法判断。反查没有完成'), sureText)
// 没反查成的句子是服务端按规则记的无法判断,反方模型根本没看过这一句:不能再写「判断由反方模型给出」
const sureBlock = (await p.locator('[data-ev-challenge]').innerText().catch(() => '')).replace(/\s+/g, ' ')
check('……这一句根本没反查:不写「判断由反方模型给出」', await p.locator('[data-ev-challenge] [data-challenge-judged]').count() === 0
&& !sureBlock.includes('反方模型'), sureBlock)
await badge(pg, J, fxj.formal.units.limit).click()
await pg.waitForSelector('[data-evidence-panel] [data-ev-challenge="inconclusive"] [data-challenge-unreviewed]', { timeout: 4000 })
.catch(() => {})
@@ -3720,6 +3793,7 @@ await section('marks', '期 4:被反方审过的句子在正文里挂句末标
check('……无法判断的还有查过了、数据不够的:说这份报告几句未能反查、这一句可能在其中',
await maybe.getAttribute('data-challenge-unreviewed').catch(() => null) === 'maybe'
&& maybeText.startsWith('这份报告有 1 句未能反查,已记为无法判断,这一句可能在其中'), maybeText)
check('……说不准的照旧写明判断出自反方模型、并非系统核对', await p.locator('[data-ev-challenge] [data-challenge-judged]').count() === 1)
await pg.keyboard.press('Escape')
await pg.waitForTimeout(120)
@@ -3752,7 +3826,7 @@ await section('marks', '期 4:被反方审过的句子在正文里挂句末标
const n = await open('/ui-harness.html?evidence=1', { graph: markGraph, segPatch: markSeg, w: 390, h: 844 })
await n.page.waitForSelector(`${JP} [data-ev-challenge-mark]`, { timeout: 5000 }).catch(() => {})
await n.page.locator(`${JP} [data-ev-claim="u2"]`).click()
await n.page.waitForSelector('[data-evidence-panel] [data-ev-challenge]', { timeout: 4000 }).catch(() => {})
await n.page.waitForSelector(FULL_CLAIM, { timeout: 4000 }).catch(() => {})
const wide390 = await n.page.evaluate(() => {
const doc = document.querySelector('#evidence-judge-plain')
const el = document.querySelector('[data-evidence-panel]')
@@ -3763,6 +3837,250 @@ await section('marks', '期 4:被反方审过的句子在正文里挂句末标
await n.ctx.close()
})
await section('mark-panel', '期 4:从只有反方标记的句子打开整句面板——片段接口还没答、答不了时,「反方审稿」一节照样写出判断,取不到给重试', async () => {
// 正文的标记来自证据图(challenge_verdicts),面板里的理由、整份报告的计数要等这一句第一个片段的片段接口(unit.challenge)。
// 只认片段接口的话:还在取时这一节什么都不写,答 500 时整节消失、也不说为什么——用户点的可是醒目的「被推翻」,没开裁判的
// 报告里这几句也没有别的入口。u2 的第一个片段 s11 先压着不答、放行时答 500,重试时照常答;u4(无法判断)的 s17 一律 500
const plainSeg = (id) => `/api/runs/${fxj.plain.run_id}/evidence/segments/${id}`
let release = () => {}
const gate = new Promise((res) => { release = res })
const st = { s11: 0, mode: 'hold' }
const r = await open('/ui-harness.html?evidence=1', {
graph: markGraph, segPatch: markSeg,
before: (page) => page.route((u) => [plainSeg('s11'), plainSeg('s17')].includes(new URL(u).pathname), async (route) => {
if (new URL(route.request().url()).pathname === plainSeg('s17')) {
return route.fulfill({ status: 500, json: { detail: '服务暂时不可用' } })
}
st.s11++
if (st.mode === 'hold') {
await gate
return route.fulfill({ status: 500, json: { detail: '服务暂时不可用' } })
}
return route.fallback()
}),
})
const pg = r.page
await pg.waitForSelector(`${JP} [data-ev-claim="u2"][data-ev-challenge-mark="refuted"]`, { timeout: 5000 }).catch(() => {})
await pg.locator(`${JP} [data-ev-claim="u2"]`).click()
const p = panel(pg)
const block = p.locator('[data-ev-challenge]')
const text = async () => (await block.innerText().catch(() => '')).replace(/\s+/g, ' ')
await pg.waitForSelector('[data-evidence-panel] [data-ev-challenge]', { timeout: 3000 }).catch(() => {})
check('片段接口还在取:「反方审稿」一节已经按标记写出判断(被推翻),说正在获取理由与查询',
await block.getAttribute('data-ev-challenge').catch(() => null) === 'refuted'
&& (await block.locator('[data-challenge-tag="refuted"]').innerText().catch(() => '')).trim() === '被推翻'
&& await block.locator('[data-challenge-pending="loading"]').count() === 1 && (await text()).includes('正在获取反方的理由与查询'),
await text())
check('……判断出自反方模型、并非系统核对,同样写明', (await text()).includes('判断由反方模型给出,并非系统核对'), await text())
release()
await pg.waitForSelector('[data-evidence-panel] [data-challenge-pending="error"]', { timeout: 4000 }).catch(() => {})
const failedText = await text()
check('片段接口答 500:判断还在,写明未能获取理由与查询,给重试', await block.locator('[data-challenge-tag="refuted"]').count() === 1
&& failedText.includes('未能获取反方的理由与查询') && await block.locator('button', { hasText: '重试' }).count() === 1, failedText)
// 重试:这回照常答(带 unit.challenge),换成完整的单句展示;按过的「重试」没了,焦点不掉到页面上
st.mode = 'ok'
await block.locator('button', { hasText: '重试' }).click()
await pg.waitForSelector('[data-evidence-panel] [data-ev-challenge] [data-challenge-scope="claim"]:not([data-challenge-pending]) '
+ '[data-challenge-toggle]', { timeout: 4000 }).catch(() => {})
check('重试:片段接口再请求一次,答回来换成完整的单句展示(能展开理由与查询)', st.s11 === 2
&& await block.locator('[data-challenge-pending]').count() === 0 && await block.locator('[data-challenge-toggle]').count() === 1
&& await block.locator('[data-challenge-tag="refuted"]').count() === 1, `${st.s11} 次 | ${await text()}`)
check('……焦点留在面板里', await pg.evaluate(() => !!document.activeElement?.closest('[data-evidence-panel]')),
await pg.evaluate(() => document.activeElement?.outerHTML.slice(0, 80) ?? ''))
// 无法判断的那一句:片段接口答不了,说不准它是不是根本没反查成,不说成反方模型的判断
await pg.keyboard.press('Escape')
await pg.locator(`${JP} [data-ev-claim="u4"]`).click()
await pg.waitForSelector('[data-evidence-panel] [data-ev-challenge="inconclusive"] [data-challenge-pending="error"]', { timeout: 4000 })
.catch(() => {})
const unsure = await text()
check('无法判断的那一句、片段接口答不了:写出判断和未能获取,不说成反方模型的判断', unsure.includes('无法判断')
&& unsure.includes('未能获取反方的理由与查询') && !unsure.includes('判断由反方模型') && unsure.includes('也可能是未能反查时记下的'), unsure)
check('没有运行时报错', r.errors.length === 0, r.errors.join(' | '))
await r.ctx.close()
// 390px(底部抽屉):取不到时那一节(判断、未能获取、重试)不横向溢出
const n = await open('/ui-harness.html?evidence=1', {
graph: markGraph, segPatch: markSeg, w: 390, h: 844,
before: (page) => page.route((u) => new URL(u).pathname === plainSeg('s11'),
(route) => route.fulfill({ status: 500, json: { detail: '服务暂时不可用' } })),
})
await n.page.waitForSelector(`${JP} [data-ev-claim="u2"][data-ev-challenge-mark]`, { timeout: 5000 }).catch(() => {})
await n.page.locator(`${JP} [data-ev-claim="u2"]`).click()
await n.page.waitForSelector('[data-evidence-panel] [data-challenge-pending="error"]', { timeout: 4000 }).catch(() => {})
const over = await n.page.evaluate(() => {
const el = document.querySelector('[data-evidence-panel]')
return { pending: !!el?.querySelector('[data-challenge-pending="error"]'),
page: document.documentElement.scrollWidth - document.documentElement.clientWidth, panel: el ? el.scrollWidth - el.clientWidth : 99 }
})
check('390px:取不到时那一节(判断、未能获取、重试)不横向溢出', over.pending && over.page <= 0 && over.panel <= 1, JSON.stringify(over))
check('390px:没有运行时报错', n.errors.length === 0, n.errors.join(' | '))
await n.ctx.close()
})
await section('mark-tab', '期 4:一个可点的片段都没有的报告,标记随证据图晚到:标记进 Tab 顺序', async () => {
// 用例 evidence-marks-text(dev/fixtures/evidence_marks.tsx):挂上时整份报告没有键盘目标(没有可点片段、没开裁判、没给
// 质询),拿 Tab 位的是空的;证据图晚 0.7 秒到,带着被审过的三句。只在「拿着 Tab 位的那个没了」时补的话,空的从来不补:
// 三枚标记都是 tabindex=-1,Tab 直接跳过整份报告
const RUN_T = 'run-evidence-marks-text'
const r = await open('/preview.html?syn=evidence-marks-text', {
before: (page) => page.route((u) => new URL(u).pathname.startsWith(`/api/runs/${RUN_T}/`), async (route) => {
if (new URL(route.request().url()).pathname !== `/api/runs/${RUN_T}/evidence`) {
return route.fulfill({ status: 404, json: { detail: 'Not Found' } })
}
await new Promise((res) => setTimeout(res, 700))
const g = structuredClone(fxj.plain.graph)
g.run_id = RUN_T
g.reports[0].challenge_verdicts = { u2: 'refuted', u4: 'weakened', u6: 'stands' }
return route.fulfill({ json: g })
}),
})
const pg = r.page
await pg.waitForSelector('[data-marks-doc] [data-ev-challenge-mark]', { timeout: 5000 }).catch(() => {})
const tabs = await pg.evaluate(() => [...document.querySelectorAll('[data-marks-doc] [data-ev-claim]')]
.map((el) => `${el.getAttribute('data-ev-claim')}:${el.tabIndex}`))
check('标记到了:三枚都挂上,第一枚拿着这份报告唯一的 Tab 位', JSON.stringify(tabs) === JSON.stringify(['u2:0', 'u4:-1', 'u6:-1'])
&& await pg.locator('[data-marks-doc] [tabindex="0"]').count() === 1, tabs.join(', '))
await pg.locator('[data-marks-before]').focus()
await pg.keyboard.press('Tab')
check('从报告前面的按钮按 Tab:落到第一枚标记上', await activeKey(pg) === 'claim:u2', await activeKey(pg))
await pg.keyboard.press('ArrowRight')
check('……→ 走到下一枚标记', await activeKey(pg) === 'claim:u4', await activeKey(pg))
check('没有运行时报错', r.errors.length === 0, r.errors.join(' | '))
await r.ctx.close()
})
await section('stale', '期 4:手里那份证据图过期了(报告改写过、运行收尾之前取的):正文、证据页重取一次,对上了就不再取', async () => {
// 正文有运行就取证据图,同一次运行只取一回、之后一直用缓存。审批卡里展开过报告的话,缓存的是运行停在审批上那一刻的图:
// 之后报告改写了(第二次审批、同一张卡换稿),新稿在那份图里找不到,一个标记都不挂;审批之后才审完的反方审稿,成果区
// 也看不到;证据页挂上时只在「运行已结束、图没封存」时重取,停在第二次审批上的运行、别处正在取的那份都不管,画的是
// 旧稿,审计表却是新取的。用例 evidence-marks-stale(dev/fixtures/evidence_marks.tsx)按场景重新挂,证据图在这里按
// st.answer 答(请求进来那一刻的答复和延迟),数得出取了几回
const RUN_S = 'run-evidence-marks-stale'
const OLD = fxj.plain.doc_artifact
const NEW = 'b7'.repeat(32)
const SEALED = { sealed: true, ok: true, manifest_seq: 64, legacy: false }
const OPEN = { sealed: false, ok: null, manifest_seq: null, legacy: false }
const graphOf = (art, marks, seal) => ({
...structuredClone(fxj.plain.graph), run_id: RUN_S, seal,
reports: [{ ...structuredClone(fxj.plain.graph.reports[0]), doc_artifact: art, doc_sealed: seal.sealed, challenge_verdicts: marks }],
})
// 第一次审批时:初稿,没封存;改写后第二次审批:新稿,没封存;运行结束:审批之后的反方审稿也审完了,封存了
const G1 = graphOf(OLD, { u2: 'refuted' }, OPEN)
const G2 = graphOf(NEW, { u4: 'weakened' }, OPEN)
const G3 = graphOf(NEW, { u2: 'refuted', u4: 'weakened' }, SEALED)
const start = async () => {
const st = { answer: G1, delay: 0, n: 0 }
const r = await open('/preview.html?syn=evidence-marks-stale', {
before: (page) => page.route((u) => new URL(u).pathname.startsWith(`/api/runs/${RUN_S}/`), async (route) => {
if (new URL(route.request().url()).pathname !== `/api/runs/${RUN_S}/evidence`) {
// 审计接口答「老服务端」(证据页按页面上的文档拼审计表),片段、问答串一律没有
return route.fulfill({ status: 404, json: { detail: 'Not Found' } })
}
st.n++
const { answer, delay } = st
if (delay) await new Promise((res) => setTimeout(res, delay))
return route.fulfill({ json: structuredClone(answer) })
}),
})
return { ...r, st }
}
const stage = async (pg, name) => {
await pg.locator(`[data-marks-stage="${name}"]`).click()
await pg.waitForSelector(`[data-marks-at="${name}"]`)
}
const marksIn = (pg) => pg.evaluate(() => JSON.stringify(Object.fromEntries([...document.querySelectorAll('[data-marks-at] [data-ev-challenge-mark]')]
.map((el) => [el.getAttribute('data-ev-claim'), el.getAttribute('data-ev-challenge-mark')]).sort())))
// 审批卡 → 第二次审批 → 成果区:每处重新挂上
const a = await start()
await a.page.waitForSelector('[data-marks-at="old"] [data-ev-challenge-mark="refuted"]', { timeout: 5000 }).catch(() => {})
check('审批卡里展开初稿:证据图取一回,标记照它挂', a.st.n === 1 && await marksIn(a.page) === '{"u2":"refuted"}',
`${a.st.n} 回 | ${await marksIn(a.page)}`)
a.st.answer = G2
await stage(a.page, 'new')
await a.page.waitForSelector('[data-marks-at="new"] [data-ev-claim="u4"][data-ev-challenge-mark="weakened"]', { timeout: 3000 })
.catch(() => {})
check('改写后第二次审批的新稿:手里那份图里没有这一稿,重取一次,标记按新图挂', a.st.n === 2
&& await marksIn(a.page) === '{"u4":"weakened"}', `${a.st.n} 回 | ${await marksIn(a.page)}`)
await stage(a.page, 'new')
await a.page.waitForTimeout(500)
check('……再挂一次:手里那份对上了,不再取', a.st.n === 2 && await marksIn(a.page) === '{"u4":"weakened"}', `${a.st.n} 回`)
a.st.answer = G3
await stage(a.page, 'output')
await a.page.waitForSelector('[data-marks-at="output"] [data-ev-claim="u2"][data-ev-challenge-mark="refuted"]', { timeout: 3000 })
.catch(() => {})
check('运行结束后的成果区:手里那份是收尾之前取的(没封存),重取一次,审批之后才审完的标记也挂上', a.st.n === 3
&& await marksIn(a.page) === '{"u2":"refuted","u4":"weakened"}', `${a.st.n} 回 | ${await marksIn(a.page)}`)
await stage(a.page, 'output')
await a.page.waitForTimeout(500)
check('……再挂一次:封存了的图不再取', a.st.n === 3, `${a.st.n} 回`)
check('没有运行时报错', a.errors.length === 0, a.errors.join(' | '))
await a.ctx.close()
// 同一个实例从初稿换到新稿(画布的审批浮层换审批,不重新挂)
const b = await start()
await b.page.waitForSelector('[data-marks-at="old"] [data-ev-challenge-mark]', { timeout: 5000 }).catch(() => {})
await stage(b.page, 'switch')
await b.page.waitForTimeout(400)
check('同一张卡:初稿重新挂上,手里那份对得上,不重取', b.st.n === 1, `${b.st.n} 回`)
b.st.answer = G2
await b.page.locator('[data-marks-switch]').click()
await b.page.waitForSelector(`[data-marks-card="${NEW}"] [data-ev-claim="u4"][data-ev-challenge-mark="weakened"]`, { timeout: 3000 })
.catch(() => {})
check('……同一个实例换成新稿:重取一次,标记按新图挂', b.st.n === 2 && await marksIn(b.page) === '{"u4":"weakened"}',
`${b.st.n} 回 | ${await marksIn(b.page)}`)
await b.ctx.close()
// 证据页,运行停在第二次审批上:手里那份是第一次审批时的初稿
const c = await start()
await c.page.waitForSelector('[data-marks-at="old"] [data-ev-challenge-mark]', { timeout: 5000 }).catch(() => {})
c.st.answer = G2
// 证据页挂上之后画没画过旧稿,哪怕只画了一帧又收起来:证据页里加进来、拿下去的节点带着旧稿的句子就记下来(画的是旧稿、
// 审计表却是新取的,点一行会打开旧稿里同号的片段)。按变动记录里的节点认,不按回调时的页面认——先画旧稿、紧接着换成
// 占位的话,回调时页面上已经没有了
await c.page.evaluate(() => {
window.__sawOld = false
new MutationObserver((muts) => {
for (const m of muts) {
const at = m.target.nodeType === 1 ? m.target : m.target.parentElement
const nodes = [...m.addedNodes, ...m.removedNodes]
// 证据页里面的变动看全部节点;外面的(换场景时拿下审批卡那一层)只看证据页那一层自己
const suspects = at?.closest?.('[data-marks-at^="pane"]') ? nodes
: nodes.filter((n) => n.nodeType === 1 && n.matches('[data-marks-at^="pane"]'))
if (suspects.some((n) => n.textContent?.includes('增长主要来自新客首单'))) window.__sawOld = true
}
}).observe(document.body, { subtree: true, childList: true, characterData: true })
})
await stage(c.page, 'pane-interrupted')
await c.page.waitForSelector('[data-marks-at="pane-interrupted"] [data-evidence-report="write"] [data-ev-claim="u4"]', { timeout: 4000 })
.catch(() => {})
const report = (await c.page.locator('[data-marks-at] [data-evidence-report="write"]').innerText().catch(() => '')).replace(/\s+/g, ' ')
check('证据页(运行停在第二次审批上):手里那份没封存,重取一次,画的是新稿,标记按新图挂', c.st.n === 2
&& report.includes('增长主要来自老客复购') && !report.includes('增长主要来自新客首单') && await marksIn(c.page) === '{"u4":"weakened"}',
`${c.st.n} 回 | ${report.slice(0, 80)}`)
check('……重取回来之前先占位,旧稿一眼都没画', !(await c.page.evaluate(() => window.__sawOld)))
const table = (await c.page.locator('[data-marks-at] [data-evidence-audit]').innerText().catch(() => '')).replace(/\s+/g, ' ')
check('……审计表也是新稿的(退款 31 单)', table.includes('退款 31 单') && !table.includes('退款 29 单'), table.slice(0, 160))
await c.ctx.close()
// 证据页,运行已经结束:挂上时别处正在取证据图(新稿重新挂上触发的那一次,慢),取回来的那份没封存,再取一次
const d = await start()
await d.page.waitForSelector('[data-marks-at="old"] [data-ev-challenge-mark]', { timeout: 5000 }).catch(() => {})
Object.assign(d.st, { answer: G2, delay: 1200 })
await stage(d.page, 'new')
for (let i = 0; i < 30 && d.st.n < 2; i++) await d.page.waitForTimeout(50)
Object.assign(d.st, { answer: G3, delay: 0 })
await stage(d.page, 'pane-succeeded')
await d.page.waitForSelector('[data-marks-at="pane-succeeded"] [data-evidence-seal="done"]', { timeout: 5000 }).catch(() => {})
const seal = (await d.page.locator('[data-marks-at] [data-evidence-seal]').innerText().catch(() => '')).replace(/\s+/g, ' ')
check('证据页(运行已结束):挂上时别处正在取,取回来的那份没封存,再取一次,顶上写已封存', d.st.n === 3
&& seal.includes('已封存'), `${d.st.n} 回 | ${seal}`)
await d.page.waitForTimeout(500)
check('……之后不再取', d.st.n === 3, `${d.st.n} 回`)
check('没有运行时报错', d.errors.length === 0, d.errors.join(' | '))
await d.ctx.close()
})
await section('ask', '期 4:句末「质询」图标平时的对比度——深浅两套、页面底色和面板底色上都 ≥ 3:1,显出来时不撑开排版', async () => {
// 平时是淡淡的一个小图标(字色压一层不透明度),可 WCAG 1.4.11 要求界面组件对背景 ≥ 3:1(以前最淡的字色压到 60%,深色
// 约 2.75、浅色约 2.33)。用例 evidence-ask(dev/fixtures/evidence_ask.tsx):同一份报告摆在页面底色(同审批卡)和面板