可点击证据第四期:结论句由模型裁判;只引单元格的问数据图能发成受管

一、结论句裁判

- 报告节点新增 claims: judge:写完、核对完之后,把结论句和它引用的证据摘录交给裁判模型,
  判为支持 / 部分支持 / 不支持 / 不是结论,附一句理由;判定只标注,不改写正文
- 送裁判的句子按固定规则预筛:带引用的、含方向词或因果词的送去判,短句、过渡句不送
- 证据摘录:指标写名称、值和原式;查询给 SQL 前 300 字和被引用的行,被引用的列一定给到;遮罩列一律不给;
  规则里写明「数字已经由系统核对过,不要复算」
- 一份报告合并成一次调用,超出句数就分批;结构化输出失败时退回 JSON 解析,再失败记为未裁判
- 裁判模型的优先级:节点上写的 > 设置里的「证据裁判模型」> Copilot 的模型;思考关闭;
  和写作模型相同时给警告(等于自己审自己)
- rewrite_once(默认关):把不支持的句子和理由交回写作者只改这几句,再裁一次;
  改写稿冒出原稿没有的问题就不采用,保留原稿和原来的判定

二、成本上限

- 每份报告的句数、金额、时长,探索运行每次点击的金额,全局每日金额,每一项都可以自定义,也都可以设成不限;
  默认 40 句、$0.05、30 秒,每次点击 $0.01,每天 $2
- 调用前先估算,超出上限按优先级截断:先判带引用的,再判含方向词、因果词的,其余记为未裁判并写明「已到上限」;
  不报错,也不让报告失败
- 每日花费按本地日期计数,持久化在设置表里;重跑同一次运行不重复计费;价格目录里没有的模型只计次数,并写明估不出金额

三、正式运行与探索运行

- 正式运行在报告节点内裁判,判定写进报告文档、随文档封存;不支持的按 on_unsupported(degrade / withhold)降档或不予出具,
  裁判没跑成记缺口,不能判完整出具
- 探索运行按需裁判:POST /api/runs/{id}/evidence/judge,点开哪句判哪句;判定作为 evidence.judged 事件追加在封存之后,
  标「封存后追加」,封存核对仍然一致;只读封存范围内的工件;同一句不重复判;运行在裁判期间被接着跑时不记录
- 正式运行调这个接口返回 409,写明「正式运行的裁判在节点内完成」

四、治理与自动修复

- G3 放开 judge:受管级别写 judge 必须写预算(judge.max_cost_usd,或显式写 null 表示不限)
- 发布前自动修复:缺预算时给选项(默认金额 / 不限),不替人选;
  从 require_citation 改成 judge 不算降低要求,judge 改回 off、withhold 放宽成 degrade 算降低要求
- Copilot 手册:受管模板可以写 judge 并带预算;问数据按需裁判,不替人打开结论句策略

五、界面

- 结论句句末放徽标:支持 ◆、部分支持 ◇、不支持 ! 整句浅底、未裁判 ?;不用表示「已核对」的绿色;n / N 也跳到不支持的句子
- 证据面板里「模型的解释」:带「模型判断 · 模型名 · 非确定」,封存后追加的另外标出;
  「请模型判断这句」只在探索运行、还没判过时出现,触顶时写明已到上限和怎么调
- 出具横幅多一段结论句计数;设置页新增「证据裁判」一组(裁判模型、各项上限、今日花费),设成不限时写明费用受什么约束;
  报告节点可以配 judge;运行轨迹里裁判相关的事件都有中文标题

六、门禁修正

- 引用模式下,图里没有口径卡(只引查询单元格)的,出具契约不再要求 metrics_from,受管门禁也不再要求 required:
  strict 加 cells 已经保证每个数都点得开、对不上就不予出具;有口径卡的照旧要求。
  以前问数据的图怎么都发不成受管,Copilot 补上契约也会被判「冒出新的问题」作废
This commit is contained in:
ThearchyHelios
2026-09-29 11:10:53 +08:00
parent d071bf119f
commit 9727c21d8d
47 changed files with 12367 additions and 263 deletions
+18 -9
View File
@@ -15,14 +15,14 @@ import { humanizeError } from '../lib/errors'
import { explainRunError } from '../lib/explain'
import { formatClock, formatDuration, formatNumber, NONE, shortId } from '../lib/format'
import { statusLabel } from '../lib/status'
import { EVIDENCE_TEXT, evidenceTally, issuanceLabel, nodeTypeLabel } from '../lib/terms'
import { EVIDENCE_TEXT, JUDGE_TEXT, evidenceTally, issuanceLabel, nodeTypeLabel } from '../lib/terms'
import {
childrenByExec, compactSteps, parseQueryResult, progressOf, spread, teamVerdictOf,
type Exec, type FixKind, type ResultTable as Table, type Step, type StepKind, type TeamMemberEx,
type TeamRun,
} from './decode'
import { CODE_COLUMN, CopyChip, LEADING_ZERO, Markdown, type MarkSpec } from './Markdown'
import { EvidenceField, type EvidenceDocHandle } from './EvidenceDoc'
import { ClaimTally, EvidenceField, type EvidenceDocHandle } from './EvidenceDoc'
import { EVIDENCE_STATE, docTally, evidenceFields, issuanceMarks, type EvidenceTally } from '../lib/evidence'
import type { EvidenceDocData } from '../types'
import { useRunClock } from './useRunClock'
@@ -2027,7 +2027,7 @@ function Output({ output, runClass, broken, question, onFollowUp, runId }: {
<EvidenceField
ref={key === firstEvidence ? docRef : undefined}
artifact={evidence.get(key)!.artifact} text={value} runId={runId} dense={dense} label={key}
tally={!banner}
tally={!banner} runClass={runClass}
onDoc={key === firstEvidence ? setTallyDoc : undefined}
/>
)
@@ -2262,6 +2262,12 @@ export function IssuanceBanner({ issuance, runClass, evidence }: {
const uncitedClaims = Number(issuance?.claims?.uncited_claims ?? 0) || 0
const numbers = counts ? evidenceTally(counts.cited, counts.total, counts.other) : ''
const numbersOk = !counts?.none && !counts?.other
// 四期:结论句有判定(开了裁判,或探索运行里按需判过)时多一段「结论 4 句(支持 3 · 无证据 1)」。
// 没开裁判的文档里没挂依据的都数在这一段的「无证据」里,不再另起一句;开了裁判的文档里,没挂依据却送了
// 裁判的句子按判定数、预筛放掉的不数——出具照样按没挂依据计缺口(require_citation、judge 都是),这时
// 结论句那一段盖不全,照出具的数另起「没挂依据的结论句 N」,不能让花了档位的缺口从横幅上消失
const claims = counts?.claims?.total ? counts.claims : null
const uncitedLine = uncitedClaims > (claims?.uncited ?? 0)
return (
// data-issuance-banner:画布上成果节点的出具印章据此滚过来;tabIndex 让「去看出具」能把焦点带到这里
@@ -2281,9 +2287,10 @@ export function IssuanceBanner({ issuance, runClass, evidence }: {
</span>
</div>
{meta.hint && <div className="mt-1 text-2xs leading-relaxed text-dim">{meta.hint}</div>}
{counts && (counts.total > 0 || counts.other > 0 || suspect > 0 || uncitedClaims > 0) && (
{counts && (counts.total > 0 || counts.other > 0 || suspect > 0 || uncitedClaims > 0 || !!claims) && (
// 逐段证据的计数:和报告核对那一行、证据条同一种说法。可疑名字、没挂依据的结论句不是数字,
// 各自另起一句。有无证据的数字、可疑名字时才给「定位下一处」(结论句不是片段,定位不到)
// 各自另起一句。有无证据的数字、可疑名字、证据不支持(或部分支持)的结论句时才给「定位下一处」——
// 结论句靠句末徽标定位;只是没挂依据的结论句没有徽标,定位不到
<div className="mt-1 flex flex-wrap items-center gap-2 text-2xs" data-evidence-line="">
{numbers && (
<span className="tnum" style={{ color: numbersOk ? 'var(--st-done)' : 'var(--st-waiting)' }}>{numbers}</span>
@@ -2293,12 +2300,14 @@ export function IssuanceBanner({ issuance, runClass, evidence }: {
{numbers ? '· ' : ''}{EVIDENCE_STATE.suspect.glyph} {EVIDENCE_TEXT.suspectTag} {formatNumber(suspect)}
</span>
)}
{uncitedClaims > 0 && (
<span className="tnum" style={{ color: 'var(--st-waiting)' }} data-evidence-line-claims="">
{numbers || suspect > 0 ? '· ' : ''}{EVIDENCE_TEXT.uncitedClaimsTag} {formatNumber(uncitedClaims)}
{claims && <ClaimTally claims={claims} lead={!!numbers || suspect > 0} />}
{uncitedLine && (
<span className="tnum" style={{ color: 'var(--st-waiting)' }} data-evidence-line-claims=""
title={claims ? JUDGE_TEXT.uncitedBesides : undefined}>
{numbers || suspect > 0 || claims ? '· ' : ''}{EVIDENCE_TEXT.uncitedClaimsTag} {formatNumber(uncitedClaims)}
</span>
)}
{(counts.none > 0 || counts.other > 0 || suspect > 0) && evidence?.onNext && (
{(counts.none > 0 || counts.other > 0 || suspect > 0 || !!claims?.unsupported || !!claims?.partial) && evidence?.onNext && (
<button type="button" className="btn btn-xs" data-evidence-next="" onClick={evidence.onNext}>
{EVIDENCE_TEXT.locateNext}
</button>
+168 -50
View File
@@ -8,13 +8,13 @@ import { ListChecks } from 'lucide-react'
import clsx from 'clsx'
import { rovingTarget } from '../components/ui'
import {
EVIDENCE_STATE, docTally, segmentKind, segmentLabel, segmentState, tallySummary, unitText, type EvidenceStateCode,
type EvidenceTally as Tally,
EVIDENCE_STATE, claimCounts, claimLabel, docTally, segmentKind, segmentLabel, segmentState, tallySummary, unitText,
isJudged, limitOf, unitVerdict, verdictState, withVerdicts, type EvidenceStateCode, type EvidenceTally as Tally,
} from '../lib/evidence'
import { formatNumber } from '../lib/format'
import { EVIDENCE_STATE_LABEL, EVIDENCE_TEXT, evidenceTally } from '../lib/terms'
import { useEvidence } from '../store/evidence'
import type { EvidenceBlock, EvidenceDocData, EvidenceSegment, EvidenceUnit } from '../types'
import { EVIDENCE_STATE_LABEL, EVIDENCE_TEXT, JUDGE_TEXT, claimTally, evidenceTally, type ClaimTallyCounts } from '../lib/terms'
import { useEvidence, useVerdicts } from '../store/evidence'
import type { EvidenceBlock, EvidenceDocData, EvidenceSegment, EvidenceUnit, EvidenceVerdict } from '../types'
import { EvidencePanel, type PanelMode, type PanelView } from './EvidencePanel'
import { BlockView, Markdown, StyledSlice, inlineStyles, numericColumns, type InlineStyles } from './Markdown'
@@ -26,10 +26,13 @@ import { BlockView, Markdown, StyledSlice, inlineStyles, numericColumns, type In
* BlockView,和普通答案长得一模一样;有出处的数字画细实线,没有出处的画点状线、
* 句末挂「无证据」。
*
* 键盘:整份报告只占一个 Tab 位(roving tabindex)。←/→ 在有状态的片段间走,↑/↓ 按
* 结论句的判定(四期)只在句末挂一枚小徽标(◆ ◇ ! ?),整句不画线;证据不支持的整句铺一层浅底。
* 徽标也是按钮:点开是这一句的「模型的解释」。判定是模型给的,颜色一律不用确定性的绿。
*
* 键盘:整份报告只占一个 Tab 位(roving tabindex)。←/→ 在有状态的片段、句末徽标间走,↑/↓ 按
* 句子走(表格里按列走到上一行 / 下一行,出了表格接着按句子走),n / N 跳到下一处 /
* 上一处无证据,回车打开证据面板,Esc 关掉并留在原片段;面板开着时方向键走到哪、面板
* 跟到哪,Tab 进面板。
* 上一处无证据、证据不支持的地方,回车打开证据面板,Esc 关掉并留在原片段;面板开着时方向键走到哪、
* 面板跟到哪,Tab 进面板。
*
* 长报告:事件都挂在容器上(片段只带 data-seg),块用 memo,外加
* content-visibility: auto;超过 TEXT_CAP 的部分先折叠,跳转到折叠里的片段时自动展开。
@@ -47,11 +50,19 @@ export interface EvidenceDocHandle {
/** 和 AssistantStream 的长文本折叠同一个量级:先显示这么多字,后面的折起来 */
const TEXT_CAP = 3000
/** 句末徽标在键盘顺序里的键:片段 id 是 s0…,不会撞 */
const badgeKey = (unit: string) => `claim:${unit}`
const unitOfKey = (key: string) => (key.startsWith('claim:') ? key.slice(6) : null)
interface Badge { unit: EvidenceUnit; block: number; verdict: EvidenceVerdict; state: EvidenceStateCode }
interface Model {
/** 可点的片段,按正文顺序 */
/** 可点的片段和句末徽标,按正文顺序 */
order: string[]
index: Map<string, number>
seg: Map<string, { seg: EvidenceSegment; unit: EvidenceUnit; block: number }>
/** 句末徽标:键是 claim:<unit>,带着这一句眼下的判定 */
badge: Map<string, Badge>
/** 每个有可点片段的句子里第一个可点片段,按正文顺序(↑/↓ 用) */
unitFirst: string[]
unitOf: Map<string, number>
@@ -65,10 +76,11 @@ interface Model {
grid: Map<string, string>
}
function buildModel(blocks: EvidenceBlock[]): Model {
function buildModel(blocks: EvidenceBlock[], overlay?: Record<string, EvidenceVerdict>): Model {
const order: string[] = []
const index = new Map<string, number>()
const seg = new Map<string, { seg: EvidenceSegment; unit: EvidenceUnit; block: number }>()
const badge = new Map<string, Badge>()
const unitFirst: string[] = []
const unitOf = new Map<string, number>()
const alerts: string[] = []
@@ -96,12 +108,28 @@ function buildModel(blocks: EvidenceBlock[]): Model {
if (!grid.has(key)) grid.set(key, s.id)
}
}
// 句末徽标排在这一句的片段后面:←/→ 走到句尾就是它,证据不支持的也进 n / N
const verdict = unitVerdict(unit, overlay)
const state = verdictState(verdict)
if (verdict && state) {
const key = badgeKey(unit.id)
badge.set(key, { unit, block: b, verdict, state })
index.set(key, order.length)
order.push(key)
if (first) { unitFirst.push(key); first = false }
unitOf.set(key, unitFirst.length - 1)
if (EVIDENCE_STATE[state].alert) alerts.push(key)
}
}
chars.push(total)
})
return { order, index, seg, unitFirst, unitOf, alerts, chars, cell, grid }
return { order, index, seg, badge, unitFirst, unitOf, alerts, chars, cell, grid }
}
/** 片段或徽标在第几块 */
const blockOf = (model: Model, key: string | null | undefined): number =>
(key ? model.seg.get(key)?.block ?? model.badge.get(key)?.block : undefined) ?? -1
/**
* ↑/↓ 该去哪。表格里按列走:下一行同一列(那一格空着就找这一行离它最近的一格);
* 走出表格的上下边,接着按句子走到表格前后那一句——不在表格里一格一格地横着挪
@@ -123,11 +151,11 @@ function verticalTarget(model: Model, id: string, down: boolean): string | null
// 出了表格:往下找表格之后的第一句,往上找表格之前的最后一句
const u = model.unitOf.get(id) ?? 0
const list = down ? model.unitFirst.slice(u + 1) : model.unitFirst.slice(0, u).reverse()
const out = list.find((sid) => model.seg.get(sid)?.block !== at.block)
const out = list.find((sid) => blockOf(model, sid) !== at.block)
if (out) return out
// 表格就是整份报告的首尾:和句子一样首尾相接
const wrap = down ? model.unitFirst : [...model.unitFirst].reverse()
return wrap.find((sid) => model.seg.get(sid)?.block !== at.block) ?? null
return wrap.find((sid) => blockOf(model, sid) !== at.block) ?? null
}
const u = model.unitOf.get(id) ?? 0
return model.unitFirst[(u + (down ? 1 : -1) + n) % n] ?? null
@@ -168,10 +196,24 @@ export const EvidenceDoc = forwardRef<EvidenceDocHandle, {
onView?: (open: boolean) => void
/** 自己显示「N/N 数字有出处」那一条。上面已经有出具横幅(它会写这一行)时不用 */
tally?: boolean
}>(function EvidenceDoc({ doc, artifact, runId, dense = false, label, panel = 'auto', dock, onView, tally = false }, ref) {
/**
* 运行类别(formal / exploratory):「请模型判断这句」只在探索运行里有。开了裁判的文档自己记着
* (on_demand / inline),没开的看这里,不给就按运行 id 取一次
*/
runClass?: string
}>(function EvidenceDoc({ doc, artifact, runId, dense = false, label, panel = 'auto', dock, onView, tally = false, runClass }, ref) {
const blocks = useMemo(() => doc.blocks ?? [], [doc])
const model = useMemo(() => buildModel(blocks), [blocks])
const report = doc.node_id || undefined
// 封存之后按需追加的判定:盖过文档里的「未裁判 · 按需」。只换句末徽标,封存的文档一个字不改
const overlay = useVerdicts(runId, report)
const model = useMemo(() => buildModel(blocks, overlay), [blocks, overlay])
const counts = useMemo(() => docTally(doc), [doc])
const claims = useMemo(() => claimCounts(doc, overlay), [doc, overlay])
// 探索运行的报告(开了裁判的按需文档,或调用方说了是探索运行):证据图带着这次运行里之前按需判过的句子
// (reports[].post_seal_verdicts),取一次,重新打开页面时徽标还在。别的报告不多发这个请求
const loadGraph = useEvidence((s) => s.loadGraph)
const lateOnes = doc.judge?.mode === 'on_demand' || (runClass === 'exploratory' && doc.judge?.mode !== 'inline')
useEffect(() => { if (lateOnes && runId) void loadGraph(runId) }, [lateOnes, runId, loadGraph])
const rootRef = useRef<HTMLDivElement>(null)
const instance = useId()
const panelId = `${instance}-panel`
@@ -183,11 +225,17 @@ export const EvidenceDoc = forwardRef<EvidenceDocHandle, {
const pendingFocus = useRef<string | null>(null)
const mode = usePanelMode(panel, dense)
// 换了一份文档:焦点位回到第一个片段,面板关掉
// 换了一份文档:焦点位回到第一个片段,面板关掉。只认文档本身——判定回来了(徽标变了)不算换文档,
// 面板正开着这一句的解释,不能因此收起
useEffect(() => {
setCurrent(model.order[0] ?? null)
setView(null)
}, [model])
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [blocks])
// 拿着 Tab 位的徽标没了(判成「不是结论句」):Tab 位交回第一个,整份报告不能一个 Tab 位都没有
useEffect(() => {
if (current && !model.index.has(current)) setCurrent(model.order[0] ?? null)
}, [model, current])
// 同一时刻只开一个面板:另一份报告打开了自己的面板,这边的就收起
const owner = useEvidence((s) => s.owner)
@@ -205,15 +253,18 @@ export const EvidenceDoc = forwardRef<EvidenceDocHandle, {
const shownBlocks = expanded ? blocks.length : foldAt
const totalChars = model.chars[model.chars.length - 1] ?? 0
const segEl = useCallback((id: string) =>
rootRef.current?.querySelector<HTMLElement>(`[data-seg="${CSS.escape(id)}"]`) ?? null, [])
const segEl = useCallback((id: string) => {
const unit = unitOfKey(id)
const sel = unit ? `[data-ev-claim="${CSS.escape(unit)}"]` : `[data-seg="${CSS.escape(id)}"]`
return rootRef.current?.querySelector<HTMLElement>(sel) ?? null
}, [])
/** 把焦点挪到某个片段上。在折叠里的先展开,渲染出来再聚焦 */
/** 把焦点挪到某个片段(或句末徽标)上。在折叠里的先展开,渲染出来再聚焦 */
const focusSeg = useCallback((id: string, opts?: { flash?: boolean }) => {
const hit = model.seg.get(id)
if (!hit) return
const block = blockOf(model, id)
if (block < 0) return
setCurrent(id)
if (hit.block >= shownBlocks) {
if (block >= shownBlocks) {
pendingFocus.current = id
setExpanded(true)
return
@@ -233,6 +284,13 @@ export const EvidenceDoc = forwardRef<EvidenceDocHandle, {
}, [expanded, segEl])
const openSeg = useCallback((id: string) => {
const badge = model.badge.get(id)
if (badge) {
claim(instance)
setView({ kind: 'unit', id: badge.unit.id })
setAnnounce(`${JUDGE_TEXT.section}:${claimLabel(badge.unit, badge.verdict)}`)
return
}
const hit = model.seg.get(id)
if (!hit) return
claim(instance)
@@ -247,7 +305,7 @@ export const EvidenceDoc = forwardRef<EvidenceDocHandle, {
}, [claim, instance, doc])
const close = useCallback((refocus = true) => {
const back = view?.kind === 'seg' ? view.id : current
const back = view?.kind === 'seg' ? view.id : view?.kind === 'unit' ? badgeKey(view.id) : current
setView(null)
setAnnounce('')
if (refocus && back) requestAnimationFrame(() => segEl(back)?.focus())
@@ -265,16 +323,18 @@ export const EvidenceDoc = forwardRef<EvidenceDocHandle, {
const open = !!view
useEffect(() => { onView?.(open) }, [open, onView])
const viewKey = view?.kind === 'seg' ? view.id : view?.kind === 'unit' ? badgeKey(view.id) : null
useImperativeHandle(ref, () => ({
open: (id, opts) => {
if (!model.seg.has(id)) return false
if (!model.seg.has(id) && !model.badge.has(id)) return false
if (opts?.focus) focusSeg(id, { flash: true })
else setCurrent(id)
openSeg(id)
return true
},
next: (dir = 1) => {
const target = step(model.alerts, view?.kind === 'seg' ? view.id : current, dir)
const target = step(model.alerts, viewKey ?? current, dir)
if (target) {
focusSeg(target, { flash: true })
openSeg(target)
@@ -288,19 +348,20 @@ export const EvidenceDoc = forwardRef<EvidenceDocHandle, {
openViolations()
return true
},
}), [step, model, view, current, focusSeg, openSeg, openViolations, doc])
}), [step, model, viewKey, current, focusSeg, openSeg, openViolations, doc])
// 事件委托:片段只带 data-seg,点击和按键都在容器上认
// 事件委托:片段只带 data-seg、句末徽标只带 data-ev-claim,点击和按键都在容器上认
const segOf = (target: EventTarget | null): string | null => {
const el = (target as HTMLElement | null)?.closest?.<HTMLElement>('[data-seg]')
return el && rootRef.current?.contains(el) ? el.dataset.seg ?? null : null
const el = (target as HTMLElement | null)?.closest?.<HTMLElement>('[data-seg], [data-ev-claim]')
if (!el || !rootRef.current?.contains(el)) return null
return el.dataset.seg ?? (el.dataset.evClaim ? badgeKey(el.dataset.evClaim) : null)
}
const onClick = (e: ReactMouseEvent) => {
const id = segOf(e.target)
if (!id) return
e.preventDefault()
setCurrent(id)
if (view?.kind === 'seg' && view.id === id) close(false)
if (viewKey === id) close(false)
else openSeg(id)
}
const onFocus = (e: ReactFocusEvent) => {
@@ -341,9 +402,9 @@ export const EvidenceDoc = forwardRef<EvidenceDocHandle, {
if (view) openSeg(target)
}
const activeSeg = view?.kind === 'seg' ? view.id : null
const activeBlock = activeSeg ? model.seg.get(activeSeg)?.block ?? -1 : -1
const currentBlock = current ? model.seg.get(current)?.block ?? -1 : -1
const activeSeg = viewKey
const activeBlock = blockOf(model, activeSeg)
const currentBlock = blockOf(model, current)
const visual = blocks.length > 40
const panelNode = view && (
@@ -353,6 +414,7 @@ export const EvidenceDoc = forwardRef<EvidenceDocHandle, {
doc={doc}
artifact={artifact}
runId={runId}
runClass={runClass}
view={view}
onClose={() => close()}
onLocate={(id) => { focusSeg(id, { flash: true }); openSeg(id) }}
@@ -361,14 +423,14 @@ export const EvidenceDoc = forwardRef<EvidenceDocHandle, {
)
// 画不了线的两种分开说:列表序号、代码块标签里的数字,和正文里根本没有对应字的(句末依据里的引用)
const summary = tallySummary(counts, model.order.length > 0)
const summary = tallySummary({ ...counts, claims }, model.order.length > 0)
return (
<div ref={rootRef} data-evidence-doc="" className="min-w-0">
<p id={summaryId} className="sr-only" data-evidence-summary="">{summary}</p>
<div className="sr-only" aria-live="polite" aria-atomic="true">{announce}</div>
{tally && (counts.total > 0 || counts.other > 0 || !!counts.suspect) && (
<EvidenceTally counts={counts} onNext={() => {
{tally && (counts.total > 0 || counts.other > 0 || !!counts.suspect || !!claims?.total) && (
<EvidenceTally counts={{ ...counts, claims }} onNext={() => {
const target = step(model.alerts, current, 1)
if (target) { focusSeg(target, { flash: true }); openSeg(target) } else openViolations()
}} onList={doc.violations?.length ? openViolations : undefined} />
@@ -388,7 +450,7 @@ export const EvidenceDoc = forwardRef<EvidenceDocHandle, {
<DocBlock block={block} dense={dense} doc={doc} visual={visual}
current={b === currentBlock ? current : null}
active={b === activeBlock ? activeSeg : null}
panelId={panelId} />
panelId={panelId} model={model} />
{mode === 'inline' && b === activeBlock && panelNode}
</Fragment>
))}
@@ -437,14 +499,18 @@ function usePanelMode(panel: 'auto' | PanelMode, dense: boolean): PanelMode {
return wide ? 'side' : 'drawer'
}
/** 证据条:没有出具横幅时由文档自己说「7/12 数字有出处 · 无证据 5 · 另有 1 处引用解析不了」 */
/**
* 证据条:没有出具横幅时由文档自己说「7/12 数字有出处 · 无证据 5 · 另有 1 处引用解析不了」,
* 有结论句判定时接着说「结论 4 句(支持 3 · 不支持 1)」
*/
export function EvidenceTally({ counts, onNext, onList }: {
counts: Pick<Tally, 'total' | 'cited' | 'none' | 'other' | 'suspect'>
counts: Pick<Tally, 'total' | 'cited' | 'none' | 'other' | 'suspect' | 'claims'>
onNext?: () => void
onList?: () => void
}) {
const suspect = counts.suspect ?? 0
const clean = !counts.none && !counts.other && !suspect
const claims = counts.claims
const clean = !counts.none && !counts.other && !suspect && !claims?.unsupported && !claims?.partial
const numbers = evidenceTally(counts.cited, counts.total, counts.other)
return (
<div className="mb-1.5 flex flex-wrap items-center gap-x-2 gap-y-1 text-2xs" data-evidence-tally="">
@@ -459,6 +525,7 @@ export function EvidenceTally({ counts, onNext, onList }: {
{numbers ? '· ' : ''}{EVIDENCE_STATE.suspect.glyph} {EVIDENCE_TEXT.suspectTag} {formatNumber(suspect)}
</span>
)}
{claims && claims.total > 0 && <ClaimTally claims={claims} lead={!!numbers || suspect > 0} />}
{!clean && onNext && (
<button type="button" className="btn btn-xs" data-evidence-next="" onClick={onNext}>
{EVIDENCE_TEXT.locateNext}
@@ -473,6 +540,22 @@ export function EvidenceTally({ counts, onNext, onList }: {
)
}
/**
* 「结论 4 句(支持 3 · 不支持 1)」:和数字那一段同一种说法。判定是模型给的:全都支持也不用确定性的绿,
* 有不支持、部分支持、没挂依据的用提醒色,其余用暗字色(它是概率性的,不该和「有出处」一样笃定)
*/
export function ClaimTally({ claims, lead }: { claims: ClaimTallyCounts; lead: boolean }) {
const text = claimTally(claims)
if (!text) return null
const warn = claims.unsupported > 0 || claims.partial > 0 || claims.uncited > 0
return (
<span className="tnum" style={{ color: warn ? 'var(--st-waiting)' : 'var(--text-dim)' }} data-evidence-claims=""
title={JUDGE_TEXT.badge(null)}>
{lead ? '· ' : ''}{text}
</span>
)
}
// -------------------------------------------------------------------------
// 块与片段
// -------------------------------------------------------------------------
@@ -480,10 +563,12 @@ export function EvidenceTally({ counts, onNext, onList }: {
/** 列表项的开头:结构片段里带着行首的 - / 1. 。列表项被分成几句时,后面几句接在同一项里 */
const ITEM_START = /(^|\n)[ \t]*([-*+]|\d+[.)])[ \t]+$/
const DocBlock = memo(function DocBlock({ block, dense, doc, visual, current, active, panelId }: {
const DocBlock = memo(function DocBlock({ block, dense, doc, visual, current, active, panelId, model }: {
block: EvidenceBlock
dense: boolean
doc: EvidenceDocData
/** 句末徽标从这里取:这一句眼下的判定(封存后追加的盖过文档里的) */
model: Model
/**
* 长文档:块上加 content-visibility,屏幕外的块不排版不绘制。短文档不加:它自带 paint
* containment,贴着块边的片段的焦点描边会被裁掉一截,而短文档本来就不慢
@@ -502,7 +587,7 @@ const DocBlock = memo(function DocBlock({ block, dense, doc, visual, current, ac
}
const unit = (u: EvidenceUnit, opts?: { code?: boolean; tag?: boolean }) => (
<UnitView key={u.id} unit={u} doc={doc} current={current} active={active} panelId={panelId}
code={opts?.code} tag={opts?.tag ?? true} />
code={opts?.code} tag={opts?.tag ?? true} badge={model.badge.get(badgeKey(u.id))} />
)
switch (block.type) {
@@ -569,11 +654,12 @@ const DocBlock = memo(function DocBlock({ block, dense, doc, visual, current, ac
/**
* 一句话:文字按行内 Markdown 渲染(整句算一次样式,跨片段的 `code`、**粗体** 不会
* 被切坏),有状态的片段包成按钮。含无证据片段的句子末尾挂「? 无证据」
* 被切坏),有状态的片段包成按钮。含无证据片段的句子末尾挂「? 无证据」;有判定的结论句末尾挂
* 一枚徽标(也是按钮),证据不支持的整句铺浅底——字本身不画线
*/
function UnitView({ unit, doc, current, active, panelId, code, tag }: {
function UnitView({ unit, doc, current, active, panelId, code, tag, badge }: {
unit: EvidenceUnit; doc: EvidenceDocData; current: string | null; active: string | null; panelId: string
code?: boolean; tag: boolean
code?: boolean; tag: boolean; badge?: Badge
}) {
const segs = (unit.segments ?? []).filter((s) => s.kind !== 'structural')
const text = segs.map((s) => s.text).join('')
@@ -611,14 +697,41 @@ function UnitView({ unit, doc, current, active, panelId, code, tag }: {
</button>
)
})
const key = badge ? badgeKey(unit.id) : ''
const meta = badge ? EVIDENCE_STATE[badge.state] : null
const open = !!badge && active === key
return (
<>
{nodes}
{badge?.state === 'unsupported'
// 证据不支持:整句铺一层浅底(折行时每行各自带圆角),字色、字重都不动,也不画线
? <span className="ev-claim" data-ev-claim-shade={unit.id} style={{ '--ev-soft': meta!.soft } as CSSProperties}>{nodes}</span>
: nodes}
{tag && [...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}{TAG_TEXT[state]}
</span>
))}
{badge && meta && (
<button
type="button"
className="ev-badge"
data-ev-claim={unit.id}
data-ev-verdict={badge.state}
data-ev-post-seal={badge.verdict.post_seal ? '' : undefined}
tabIndex={current === key ? 0 : -1}
aria-label={claimLabel(unit, badge.verdict)}
aria-expanded={open}
aria-controls={open ? panelId : undefined}
// 模型判过的写明谁判的、非确定;模型没判过的(按需还没点、到上限、没跑成)只说这是什么状态——
// 到上限没判的也记着裁判模型,但不能写成「(模型 · 非确定)」,像是它判过一样
title={isJudged(badge.verdict)
? `${meta.label}${badge.verdict.post_seal ? ` · ${JUDGE_TEXT.postSeal}` : ''}(${badge.verdict.judge || JUDGE_TEXT.judgeModel} · 非确定)`
: limitOf(badge.verdict) ? `${meta.label}:${JUDGE_TEXT.limitNotJudged}` : `${meta.label}:${meta.hint}`}
style={segStyle(badge.state)}
>
<span aria-hidden="true">{meta.glyph}</span>
</button>
)}
</>
)
}
@@ -631,8 +744,10 @@ function UnitView({ unit, doc, current, active, panelId, code, tag }: {
*/
export const EvidenceField = forwardRef<EvidenceDocHandle, {
artifact: string; text: string; runId?: string; dense?: boolean; label?: string; tally?: boolean
/** 交给出具横幅数数的文档:封存之后按需追加的判定已经叠上去了(只给计数用,正文照样按封存的那份画) */
onDoc?: (doc: EvidenceDocData | null) => void
}>(function EvidenceField({ artifact, text, runId, dense, label, tally, onDoc }, ref) {
runClass?: string
}>(function EvidenceField({ artifact, text, runId, dense, label, tally, onDoc, runClass }, ref) {
const slot = useEvidence((s) => s.docs[artifact])
const loadDoc = useEvidence((s) => s.loadDoc)
useEffect(() => { void loadDoc(artifact) }, [artifact, loadDoc])
@@ -640,9 +755,12 @@ export const EvidenceField = forwardRef<EvidenceDocHandle, {
const mismatch = !!doc && (typeof doc.markdown !== 'string' || doc.markdown.trim() !== text.trim())
const otherRun = !!doc && !!runId && typeof doc.run_id === 'string' && !!doc.run_id && doc.run_id !== runId
const usable = doc && !mismatch && !otherRun ? doc : null
useEffect(() => { onDoc?.(usable) }, [usable, onDoc])
const overlay = useVerdicts(runId, usable?.node_id || undefined)
const counted = useMemo(() => (usable ? withVerdicts(usable, overlay) : null), [usable, overlay])
useEffect(() => { onDoc?.(counted) }, [counted, onDoc])
if (usable) {
return <EvidenceDoc ref={ref} doc={usable} artifact={artifact} runId={runId} dense={dense} label={label} tally={tally} />
return <EvidenceDoc ref={ref} doc={usable} artifact={artifact} runId={runId} dense={dense} label={label} tally={tally}
runClass={runClass} />
}
const note = slot?.status === 'error' ? EVIDENCE_TEXT.docMissing
: otherRun ? EVIDENCE_TEXT.docOtherRun : mismatch ? EVIDENCE_TEXT.docMismatch : ''
+319 -21
View File
@@ -3,22 +3,25 @@ import {
type ReactNode,
} from 'react'
import { createPortal } from 'react-dom'
import { ArrowLeft, CornerDownRight, ListChecks, ShieldCheck, X } from 'lucide-react'
import { Link } from 'react-router-dom'
import { ArrowLeft, CornerDownRight, ListChecks, Scale, ShieldCheck, X } from 'lucide-react'
import clsx from 'clsx'
import { StatusBadge, isComposing } from '../components/ui'
import { ApiError } from '../api/client'
import { Spinner, StatusBadge, isComposing } from '../components/ui'
import {
EVIDENCE_KIND_STYLE, EVIDENCE_STATE, caliberSourceText, caliberUpgradeText, closestNames, docForeign, entitySources,
evidenceTrace, evidenceValue as valueText, graphDoc, inputSource, integrityFailures, locatable, locatorText, notableInput,
queryOf, queryWindow, quoteWhere, quoteWindow, reasonOf, sealVerdict, segName, segmentKind, segmentState, sourceOf,
type SealStatus, type SourceTone,
evidenceTrace, evidenceValue as valueText, graphDoc, inputSource, integrityFailures, isJudged, judgeable, limitOf,
locatable, locatorText, notableInput, queryOf, queryWindow, quoteWhere, quoteWindow, reasonOf, rewriteOf, sealVerdict,
segName, segmentKind, segmentState, sourceOf, unitText, unitVerdict, verdictState, type SealStatus, type SourceTone,
} from '../lib/evidence'
import { humanizeError } from '../lib/errors'
import { formatDateTime, formatNumber, NONE, shortId } from '../lib/format'
import { EVIDENCE_TEXT } from '../lib/terms'
import { EVIDENCE_TEXT, JUDGE_TEXT } from '../lib/terms'
import { useCatalog } from '../store/catalog'
import { segmentKey, useEvidence } from '../store/evidence'
import { askKey, segmentKey, useEvidence, useExplore, useVerdicts } from '../store/evidence'
import type {
EvidenceDocData, EvidenceInput, EvidenceQuoteSource, EvidenceSeal, EvidenceSegment, EvidenceStep, EvidenceUnit,
EvidenceViolation,
EvidenceBlock, EvidenceDocData, EvidenceInput, EvidenceOnDemand, EvidenceQuoteSource, EvidenceSeal, EvidenceSegment,
EvidenceStep, EvidenceUnit, EvidenceVerdict, EvidenceViolation,
} from '../types'
import { ArtifactViewer, ResultTable } from './AssistantStream'
import { useEvidenceHost } from './evidenceHost'
@@ -46,21 +49,27 @@ import { CopyChip } from './Markdown'
* 名字给出最接近的已知名字),逐字引文(原文所在的文档和片段,引文在原文里的位置高亮)。
* 画布右栏里点开片段时,把证据路径交给画布(evidenceHost),节点名点一下就对准那个节点。
*
* 四期多了「模型的解释」:只对结论句显示——裁判模型的判定、理由(斜体)、带「模型判断 · 模型名 · 非确定」
* 的徽标,封存之后按需追加的另写「封存后追加」。探索运行里还没判过的句子给「请模型判断这句」;到了上限
* 写明是哪个上限、到哪里调。点句末徽标打开的是整句(kind: 'unit'):句子、模型的解释、挂的依据、封存。
*
* 四种摆法:side 从右侧弹出(宽屏),drawer 从底部抽出(窄屏),inline 在 360px 的
* 画布右栏里直接栏内展开,dock 放进页面给的一块常驻位置(记录页的「证据」页签)。
* 都不是模态的:开着面板照样能在正文里走。
*/
export type PanelMode = 'side' | 'drawer' | 'inline' | 'dock'
export type PanelView = { kind: 'seg'; id: string } | { kind: 'violations' }
export type PanelView = { kind: 'seg'; id: string } | { kind: 'unit'; id: string } | { kind: 'violations' }
export function EvidencePanel({ id, mode, doc, artifact, runId, view, onClose, onLocate, onViolations }: {
export function EvidencePanel({ id, mode, doc, artifact, runId, runClass, view, onClose, onLocate, onViolations }: {
id: string
mode: PanelMode
doc: EvidenceDocData
/** 正文这份文档的工件 id:和证据接口报的封存文档比对,不是同一份就不信接口给的链 */
artifact?: string
runId?: string
/** 运行类别:没开裁判的文档靠它认探索运行(「请模型判断这句」只在探索运行里有) */
runClass?: string
view: PanelView
onClose: () => void
/** 跳到正文里的某个片段(违规清单里的「定位」) */
@@ -69,7 +78,11 @@ export function EvidencePanel({ id, mode, doc, artifact, runId, view, onClose, o
}) {
const titleId = `${id}-title`
const found = useMemo(() => (view.kind === 'seg' ? findSeg(doc, view.id) : null), [doc, view])
const state = found ? segmentState(found.seg) : null
const claimAt = useMemo(() => (view.kind === 'unit' ? findUnit(doc, view.id) : null), [doc, view])
const overlay = useVerdicts(runId, doc.node_id || undefined)
const claimVerdict = claimAt ? unitVerdict(claimAt.unit, overlay) : undefined
const claimState = verdictState(claimVerdict)
const state = found ? segmentState(found.seg) : claimState
const meta = state ? EVIDENCE_STATE[state] : null
const onKeyDown = (e: ReactKeyboardEvent) => {
@@ -81,7 +94,8 @@ export function EvidencePanel({ id, mode, doc, artifact, runId, view, onClose, o
}
const title = view.kind === 'violations' ? EVIDENCE_TEXT.violations
: found ? segName(found.seg) : EVIDENCE_TEXT.panelTitle
: found ? segName(found.seg)
: claimAt ? unitText(claimAt.unit).trim() || JUDGE_TEXT.claim : EVIDENCE_TEXT.panelTitle
// 有出处的实体、引文:徽标写得更具体(「有出处 · 逐字引文」),颜色和字形照同一套
const kind = found && state === 'deterministic' ? segmentKind(found.seg) : null
const badge = kind ? { ...meta!, label: EVIDENCE_KIND_STYLE[kind].label, glyph: EVIDENCE_KIND_STYLE[kind].glyph } : meta
@@ -110,7 +124,10 @@ export function EvidencePanel({ id, mode, doc, artifact, runId, view, onClose, o
</button>
)}
{badge && (
<span className="chip shrink-0" style={{ color: badge.color, borderColor: badge.color }} data-ev-badge={badge.code}>
// 概率性的判定(结论句)用虚线框:和系统核对过的「有出处」连框线都不一样
<span className="chip shrink-0"
style={{ color: badge.color, borderColor: badge.color, borderStyle: badge.line === 'badge' ? 'dashed' : undefined }}
data-ev-badge={badge.code}>
{badge.glyph && <span aria-hidden>{badge.glyph}</span>}{badge.label}
</span>
)}
@@ -129,24 +146,35 @@ export function EvidencePanel({ id, mode, doc, artifact, runId, view, onClose, o
{view.kind === 'violations'
? <ViolationList doc={doc} onLocate={onLocate} />
: found
? <SegmentBody panelId={id} doc={doc} artifact={artifact} runId={runId} seg={found.seg} unit={found.unit}
onViolations={onViolations} />
: <p className="text-dim">{NONE}</p>}
? <SegmentBody panelId={id} doc={doc} artifact={artifact} runId={runId} runClass={runClass} seg={found.seg}
unit={found.unit} block={found.block} onViolations={onViolations} />
: claimAt
? <ClaimBody doc={doc} artifact={artifact} runId={runId} runClass={runClass} unit={claimAt.unit}
block={claimAt.block} />
: <p className="text-dim">{NONE}</p>}
</div>
</section>
)
}
function findSeg(doc: EvidenceDocData, id: string): { seg: EvidenceSegment; unit: EvidenceUnit } | null {
function findSeg(doc: EvidenceDocData, id: string): { seg: EvidenceSegment; unit: EvidenceUnit; block: EvidenceBlock } | null {
for (const block of doc.blocks ?? []) {
for (const unit of block.units ?? []) {
const seg = (unit.segments ?? []).find((s) => s.id === id)
if (seg) return { seg, unit }
if (seg) return { seg, unit, block }
}
}
return null
}
function findUnit(doc: EvidenceDocData, id: string): { unit: EvidenceUnit; block: EvidenceBlock } | null {
for (const block of doc.blocks ?? []) {
const unit = (block.units ?? []).find((u) => u.id === id)
if (unit) return { unit, block }
}
return null
}
/** 面板里的一节:小标题 + 内容 */
function Part({ title, children, ...rest }: { title: string; children: ReactNode } & Record<`data-${string}`, string>) {
return (
@@ -163,9 +191,10 @@ function flashOnce(el: HTMLElement) {
setTimeout(() => { if (el.dataset.flash === 'focus') delete el.dataset.flash }, 1600)
}
function SegmentBody({ panelId, doc, artifact, runId, seg, unit, onViolations }: {
function SegmentBody({ panelId, doc, artifact, runId, runClass, seg, unit, block, onViolations }: {
panelId: string
doc: EvidenceDocData; artifact?: string; runId?: string; seg: EvidenceSegment; unit: EvidenceUnit
doc: EvidenceDocData; artifact?: string; runId?: string; runClass?: string; seg: EvidenceSegment; unit: EvidenceUnit
block: EvidenceBlock
onViolations: () => void
}) {
const report = doc.node_id || undefined
@@ -191,6 +220,7 @@ function SegmentBody({ panelId, doc, artifact, runId, seg, unit, onViolations }:
const inGraph = graphDoc(graphData, artifact)
const docIssue: 'foreign' | 'tampered' | null = foreign || inGraph === 'foreign' ? 'foreign'
: inGraph === 'tampered' ? 'tampered' : null
useLateVerdict(runId, report, docIssue ? undefined : detail?.unit, unit.id)
const state = segmentState(seg)
const cite = seg.cite
@@ -355,6 +385,9 @@ function SegmentBody({ panelId, doc, artifact, runId, seg, unit, onViolations }:
<p className="text-dim">{sourceOf(seg, doc) || detail?.note}</p>
)}
<JudgePart doc={doc} unit={unit} block={block} runId={runId} runClass={runClass}
onDemand={detail?.unit?.on_demand} pending={pending} />
{host.onNode && (trace.producers.length > 0 || trace.consumers.length > 0) && (
// 画布右栏:这段证据经过的节点,点一下在画布上选中并对准
<Part title="画布上的节点" data-ev-nodes="">
@@ -386,6 +419,271 @@ function SegmentBody({ panelId, doc, artifact, runId, seg, unit, onViolations }:
)
}
/**
* 片段接口答的这一句带着封存之后追加的判定(后端按最新的 evidence.judged 叠上的):记进缓存,正文的句末
* 徽标、横幅的计数跟着变。接口答的是另一份报告时调用方不传 unit
*/
function useLateVerdict(runId: string | undefined, report: string | undefined,
answered: { id?: string; verdict?: EvidenceVerdict } | undefined, unitId: string) {
const noteVerdicts = useEvidence((s) => s.noteVerdicts)
const late = answered?.verdict?.post_seal && (!answered.id || answered.id === unitId) ? answered.verdict : undefined
const sig = late ? JSON.stringify(late) : ''
useEffect(() => {
if (runId && late) noteVerdicts(runId, report, { [unitId]: late })
// 按内容比:同一条判定不重记
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [runId, report, unitId, sig, noteVerdicts])
}
/**
* 点句末徽标打开的整句:句子、模型的解释、挂的依据、封存。封存状态和叠上的判定借这句第一个片段的
* 片段接口取(接口答的是另一份报告时一概不用)
*/
function ClaimBody({ doc, artifact, runId, runClass, unit, block }: {
doc: EvidenceDocData; artifact?: string; runId?: string; runClass?: string; unit: EvidenceUnit; block: EvidenceBlock
}) {
const report = doc.node_id || undefined
const first = (unit.segments ?? []).find((s) => s.kind !== 'structural')
const key = runId && first ? segmentKey(runId, first.id, report) : ''
const slot = useEvidence((s) => (key ? s.segments[key] : undefined))
const loadSegment = useEvidence((s) => s.loadSegment)
useEffect(() => {
if (runId && first) void loadSegment(runId, first.id, report)
}, [runId, first, report, loadSegment])
const answered = slot?.status === 'ok' ? slot.data : undefined
const foreign = first ? docForeign(answered, { artifact, node: report, seg: first }) : null
useLateVerdict(runId, report, foreign ? undefined : answered?.unit, unit.id)
const overlay = useVerdicts(runId, report)
const verdict = unitVerdict(unit, overlay)
const seal = foreign ? undefined : answered?.seal
const late = !!verdict?.post_seal
const sealed = sealVerdict(seal, {
foreign: !!foreign, pending: !!runId && !seal && slot?.status === 'loading', noRun: !runId, docOnly: true,
})
// 一整句没有「这一段的证据」可言:封存核对通过时只说报告文档封存了,节点里当场判的判定跟着一起封存
const sealLabel = sealed.status !== 'done' ? sealed.label
: verdict && !late && isJudged(verdict) ? JUDGE_TEXT.sealedWithDoc : JUDGE_TEXT.sealedDoc
const cites = (unit.cites ?? []).map((alias) => ({ alias, label: doc.catalog?.[alias]?.label as string | undefined }))
return (
<>
{foreign && (
<IntegrityList code="doc" items={[EVIDENCE_TEXT.integrity.doc,
...(foreign.sealedText != null ? [EVIDENCE_TEXT.integrity.sealedText(foreign.sealedText)] : [])]} />
)}
<Part title={JUDGE_TEXT.claim} data-ev-sentence="">
<Sentence unit={unit} active="" />
</Part>
<JudgePart doc={doc} unit={unit} block={block} runId={runId} runClass={runClass}
onDemand={foreign ? undefined : answered?.unit?.on_demand}
pending={!!runId && !!first && (!slot || slot.status === 'loading')} />
<Part title={JUDGE_TEXT.cites} data-ev-cites="">
{cites.length ? (
<ul className="space-y-0.5">
{cites.map((c) => (
<li key={c.alias} className="flex min-w-0 items-baseline gap-1.5">
<span className="mono shrink-0 font-medium">{c.alias}</span>
{c.label && <span className="min-w-0 truncate text-dim" title={c.label}>{c.label}</span>}
</li>
))}
</ul>
) : <p className="text-dim">{JUDGE_TEXT.noCites}</p>}
</Part>
<Part title={EVIDENCE_TEXT.seal} data-ev-seal="">
<SealLine status={sealed.status} label={sealLabel} />
{late && (
// 封存后追加的判定:报告文档封存着,这条判断不在封存范围里——两件事分开说
<p className="mt-1 flex items-center gap-1.5" data-ev-seal-late="">
<StatusBadge status="waiting" size={12} decorative animate={false} />
<span>{JUDGE_TEXT.postSeal}:{JUDGE_TEXT.postSealHint}</span>
</p>
)}
</Part>
</>
)
}
/**
* 模型的解释:只对结论句。判定、理由(斜体)、「模型判断 · 模型名 · 非确定」的徽标,封存之后按需追加的
* 另写「封存后追加」;到上限没判的写明哪个上限、到哪里调;改写过一次的写明原句。探索运行里还没判过的
* (没有判定、未裁判)给「请模型判断这句」。什么都说不上的(正式运行、没开裁判的文档)不画这一节
*/
function JudgePart({ doc, unit, block, runId, runClass, onDemand, pending }: {
doc: EvidenceDocData; unit: EvidenceUnit; block: EvidenceBlock; runId?: string; runClass?: string
/**
* 片段接口答的「这句能不能请模型判断」:有它就照它(运行还没跑完封存、封存被改过这些前端认不出来);
* 老后端没有时按运行类别和文档自己认
*/
onDemand?: EvidenceOnDemand
/** 片段接口还在取:先不按运行类别另取一次 */
pending?: boolean
}) {
const report = doc.node_id || undefined
const overlay = useVerdicts(runId, report)
const verdict = unitVerdict(unit, overlay)
const eligible = judgeable(unit, block)
const known = onDemand && typeof onDemand.available === 'boolean' ? onDemand : undefined
const explore = useExplore(doc, runId, runClass, eligible && !isJudged(verdict) && !known && !pending)
const ask = useEvidence((s) => (runId ? s.asks[askKey(runId, report, unit.id)] : undefined))
const judge = useEvidence((s) => s.judge)
const state = verdictState(verdict)
const meta = state ? EVIDENCE_STATE[state] : null
const limit = limitOf(verdict)
const late = !!verdict?.post_seal
const rewrite = rewriteOf(doc, unit.id)
const judgeDoc = !!doc.judge
const canAsk = !!runId && !isJudged(verdict) && (known ? !!known.available : eligible && explore === true)
// 探索运行里暂时判不了(还没跑完封存、封存被改过、升级前的运行):照接口的原话说为什么没有按钮
const blocked = known && !known.available && BLOCKED.has(known.reason ?? '') ? known.message || '' : ''
// 这一次按需裁判的答复里没有这一句的判定:接口说了为什么(跳过了、触顶)就照说
const res = ask?.status === 'ok' ? ask.data : undefined
const skipped = res?.skipped?.[unit.id]
const resLimit = !verdict || verdict.status !== 'unjudged' ? null
: (Array.isArray(res?.limits_hit) && res.limits_hit.find((l) => typeof l === 'string')) || null
const shownLimit = limit ?? resLimit
const judged = isJudged(verdict)
// 这一次答复的那句话(message):判定之外接口还想说的,照原话写出来。最要紧的是「运行已经接着跑了,这次的
// 判定没有记进运行记录」——判定照样交回来、也标着封存后追加,只看徽标会以为它记进去了。已经由别处说过的不重复:
// 跳过的那一行就是它、上限的那一框说的就是它、和判定里写的理由一字不差
const resMessage = typeof res?.message === 'string' ? res.message.trim() : ''
const showMessage = !!resMessage && !(skipped && !judged) && !(shownLimit && resMessage.startsWith(JUDGE_TEXT.limit))
&& resMessage !== verdict?.rationale
// 只对结论句:表格单元格、代码、标题不是一句话,开了裁判的文档里也不画这一节
const show = !!verdict || (judgeDoc && eligible) || canAsk || !!blocked || ask?.status === 'error' || showMessage
if (!show) return null
const asking = ask?.status === 'loading'
const how = shownLimit ? JUDGE_TEXT.limitHow[late || explore ? 'click' : 'report'][shownLimit] : ''
return (
<Part title={JUDGE_TEXT.section} data-ev-judge={verdict?.status ?? 'none'}>
{verdict && judged && (
// 「模型判断 · 模型名 · 非确定」只挂在模型真判过的句子上:到上限、没跑成的未裁判也记着裁判模型,
// 但模型没看过这句,挂上这枚徽标就像它判过一样
<div className="mb-1 flex flex-wrap items-center gap-1">
<span className="chip max-w-full truncate" data-ev-judge-badge=""
style={{ color: 'var(--st-running)', borderColor: 'var(--st-running)', borderStyle: 'dashed' }}
title={late ? JUDGE_TEXT.postSealHint : JUDGE_TEXT.sealedHint}>
<Scale size={10} aria-hidden /> {JUDGE_TEXT.badge(verdict.judge)}
</span>
{late && (
<span className="chip" data-ev-post-seal="" style={{ color: 'var(--st-waiting)', borderColor: 'var(--st-waiting)', borderStyle: 'dashed' }}
title={JUDGE_TEXT.postSealHint}>
{JUDGE_TEXT.postSeal}
</span>
)}
</div>
)}
{verdict && (
<p className="font-medium" style={{ color: meta?.color ?? 'var(--text-dim)' }} data-ev-verdict={verdict.status}>
{meta?.glyph && <span aria-hidden className="mr-1">{meta.glyph}</span>}
{meta ? meta.label : JUDGE_TEXT.notClaim}
</p>
)}
{showMessage && (
<p className="mb-1 mt-0.5 text-2xs leading-relaxed" role="note" style={{ color: 'var(--st-waiting)' }} data-ev-judge-message="">
{resMessage}
</p>
)}
{verdict && !judged && verdict.judge && (
// 没判的句子只中性地说一句裁判模型是谁(到上限时知道是哪个模型的价钱、哪个模型没跑成)
<p className="mt-0.5 text-2xs text-faint" data-ev-judge-model="">{JUDGE_TEXT.notJudgedBy(verdict.judge)}</p>
)}
{verdict?.rationale && !shownLimit && (
// 理由是模型写的话:斜体,和系统给的说明分开
<p className="mt-0.5 italic text-dim" data-ev-rationale=""><em>{verdict.rationale}</em></p>
)}
{shownLimit && (
<div className="mt-1 rounded border px-2 py-1" role="note" data-ev-judge-limit={shownLimit}
style={{ borderColor: 'var(--st-waiting)', background: 'var(--st-waiting-soft)' }}>
<p><span className="font-medium" style={{ color: 'var(--st-waiting)' }}>{JUDGE_TEXT.limit}</span>
{limitWords(verdict?.rationale) ? `:${limitWords(verdict?.rationale)}` : ''}</p>
{how && (
<p className="mt-0.5 text-2xs text-dim" data-ev-judge-how="">
{how}
{how.startsWith('到「设置') && (
<> <Link to="/settings/prefs" className="text-[var(--accent)] underline-offset-2 hover:underline" data-ev-judge-settings="">去设置</Link></>
)}
</p>
)}
</div>
)}
{verdict?.status === 'unjudged' && !shownLimit && verdict.reason !== 'on_demand' && verdict.rationale && (
<p className="mt-0.5 text-dim" data-ev-judge-why="">{verdict.rationale}</p>
)}
{!!verdict?.used?.length && judged && (
<p className="mono mt-0.5 text-2xs text-faint" data-ev-used="">{JUDGE_TEXT.used(verdict.used)}</p>
)}
{!verdict && judgeDoc && eligible && !canAsk && (
// 开了裁判的文档里没有判定的结论句:预筛放掉的照实说;探索运行里暂时判不了的由上面 blocked 说
<p className="text-dim" data-ev-judge-screened="">
{doc.judge?.screened?.includes(unit.id) || explore !== false ? JUDGE_TEXT.screened : JUDGE_TEXT.formalOnly}
</p>
)}
{rewrite?.kind === 'changed' && (
<div className="mt-1 text-2xs" data-ev-rewritten="">
<p style={{ color: 'var(--st-waiting)' }}>{JUDGE_TEXT.rewritten}</p>
{rewrite.sentences.length > 0 && (
<p className="mt-0.5 text-dim">{JUDGE_TEXT.rewriteFrom}:{rewrite.sentences.map((t) => `「${t}」`).join('')}</p>
)}
</div>
)}
{rewrite?.kind === 'rejected' && (
<p className="mt-1 text-2xs" style={{ color: 'var(--st-waiting)' }} data-ev-rewrite-rejected="">
{JUDGE_TEXT.rewriteRejected(rewrite.reason)}
</p>
)}
{verdict && !late && judged && (
// 封存后追加的那句说明放在「封存」一节(它说的是封存);节点里当场判的在这里说一句随报告封存
<p className="mt-1 text-2xs text-faint" data-ev-judge-sealed="">{JUDGE_TEXT.sealedHint}</p>
)}
{skipped && !judged && (
<p className="mt-1 text-2xs text-dim" data-ev-judge-skipped={skipped}>
{res?.message || (skipped === 'not_a_claim' ? JUDGE_TEXT.notClaim : JUDGE_TEXT.notFound)}
</p>
)}
{blocked && !canAsk && (
<p className="mt-1 text-2xs text-dim" data-ev-judge-blocked={known?.reason ?? ''}>{blocked}</p>
)}
{ask?.status === 'error' && (
<p className="mt-1 text-2xs" style={{ color: 'var(--st-failed)' }} role="alert" data-ev-judge-error="">
{askError(ask.error)}
</p>
)}
{canAsk && (
<div className="mt-1.5 flex flex-wrap items-center gap-x-2 gap-y-1">
{!verdict || verdict.reason === 'on_demand' ? <span className="text-dim">{JUDGE_TEXT.notAsked}</span> : null}
<button type="button" className="btn btn-xs" data-ev-judge-ask="" disabled={asking} aria-busy={asking || undefined}
onClick={() => { if (runId) void judge(runId, report, [unit.id]) }}>
{asking ? <Spinner size={10} /> : <Scale size={11} aria-hidden />}
{asking ? JUDGE_TEXT.asking : verdict && verdict.reason !== 'on_demand' ? JUDGE_TEXT.askAgain : JUDGE_TEXT.ask}
</button>
<span className="basis-full text-2xs text-faint">{JUDGE_TEXT.askHint}</span>
</div>
)}
</Part>
)
}
/** 「已到上限(这份报告的裁判金额上限 $0.05),这句没判」→「这份报告的裁判金额上限 $0.05,这句没判」 */
function limitWords(rationale: string | undefined): string {
if (!rationale) return ''
const m = /^已到上限((.+?))[,,]?\s*(.*)$/.exec(rationale)
return m ? [m[1], m[2]].filter(Boolean).join(',') : rationale.replace(/^已到上限[::]?/, '')
}
/** 接口说这句暂时判不了、值得告诉人为什么的几种(正式运行、判过了、不是结论句不用说) */
const BLOCKED = new Set(['unsealed', 'seal_broken', 'legacy'])
/**
* 按需裁判没成:409 是这次运行不让判(正式运行、还没跑完封存、封存被改过),照后端的原话;老后端没有这个
* 接口另有说法;其余按通用的错误说法
*/
function askError(error: unknown): string {
if (error instanceof ApiError) {
if (error.status === 409) return error.message || JUDGE_TEXT.formalOnly
if ((error.status === 404 || error.status === 405) && !error.code) return JUDGE_TEXT.oldBackend
}
return JUDGE_TEXT.failed(humanizeError(error).title)
}
type InputLink = { index: number; alias: string; go: () => void } | undefined
/**
File diff suppressed because it is too large Load Diff
+100 -5
View File
@@ -1,7 +1,7 @@
import type { RunEvent, TeamMember, TeamRound, TeamRun, ToolChange } from '../types'
import type { NodeState, RunPhase } from './trace'
import { formatDuration, formatNumber } from '../lib/format'
import { TYPE_LABEL, evidenceTally, issuanceLabel, nodeTypeLabel } from '../lib/terms'
import { TYPE_LABEL, claimTally, evidenceTally, issuanceLabel, nodeTypeLabel } from '../lib/terms'
import { statsTally } from '../lib/evidence'
// 泳道数据画布也要用(supervisor 节点要展开成协作矩阵),所以类型放在
@@ -646,6 +646,23 @@ function queryTitle(sql: string, source: string): string {
/** agent 开了 cite_fields 时循环结束后那次结构化抽取 */
const EXTRACT_TITLE = '按出处抽取字段'
/**
* report.checked 带的裁判摘要 → 「结论 4 句(支持 1 · 不支持 1 · 未裁判 2)」,和出具横幅同一种说法。
* 「不是结论句」不算;没有摘要(没开裁判、老后端)返回空串
*/
function judgeTally(judge: unknown): string {
const c = judge && typeof judge === 'object' ? (judge as { counts?: Record<string, unknown> }).counts : undefined
if (!c || typeof c !== 'object') return ''
const n = (k: string) => (typeof c[k] === 'number' && Number.isFinite(c[k] as number) ? c[k] as number : 0)
const counts = { supported: n('supported'), partial: n('partial'), unsupported: n('unsupported'), unjudged: n('unjudged'),
uncited: 0 }
return claimTally({ ...counts, total: counts.supported + counts.partial + counts.unsupported + counts.unjudged })
}
/** 报告撰写节点请裁判模型判断结论句(四期,claims: judge):units 是这一批几句 */
const judgeTitle = (units: unknown) =>
`请裁判模型判断${typeof units === 'number' && units > 0 ? ` ${formatNumber(units)} 句` : ''}结论`
const JUDGE_FAILED_TITLE = '结论句裁判没跑成'
/** 审批行末尾:批的时候点了「始终允许」,这个工具之后不再问人 */
const ALWAYS_NOTE = ',并设为「始终允许 · 门控把关」'
@@ -731,6 +748,59 @@ function explainLog(code: string | undefined, message: string): Pick<Step, 'titl
next: '模型说的出处在查询结果里找不到。让它先查到这些字段再交,查不到的就是空',
}
}
case 'judge_limit': {
// 「结论句裁判已到上限(这份报告的裁判金额上限 $0.05):3 句没判,记为未裁判;已判的保留」(judge.py run_request)
const n = message.match(/[::]\s*(\d+)\s*句没判/)?.[1]
return {
title: `结论句裁判已到上限${n ? `,${n} 句没判` : ''}(记为未裁判,已判的保留)`,
sub: message.match(/已到上限((.+?))/)?.[1],
next: '没判的结论句不能算完整出具。到报告撰写节点的「结论句裁判」调高上限(也可以设成不限),或到设置 → 证据裁判改默认值',
fix: 'canvas',
}
}
case 'judge_failed': {
// 「结论句裁判没跑完:有 2 句结论没裁判:裁判调用失败(…)」
return {
title: '结论句裁判没跑完,没判的记为未裁判',
sub: message.replace(/^结论句裁判没跑完[::]\s*/, '') || undefined,
next: '没判的结论句记一条缺口,出具不能算完整。先看裁判模型的接入(设置 → 证据裁判)能不能用,再重跑',
}
}
case 'judge_unpriced': {
// 「模型「x」不在价格目录里,按令牌估不出金额:金额上限(每份报告、每次点击、每日)对它不起作用,…」
const model = message.match(/模型「(.+?)」/)?.[1]
return {
title: `裁判模型${model ? `「${model}」` : ''}估不出金额,金额上限对它不起作用`,
sub: message.split(/[::]/).slice(1).join(':').trim() || undefined,
next: '费用只受句数、时长上限约束。要按金额控住,换一个价格目录里有的裁判模型',
}
}
case 'judge_same_model': {
// 「裁判模型和写作模型都是「x」:等于自己审自己,…。到设置里选一个不同的「证据裁判模型」…」
const model = message.match(/都是「(.+?)」/)?.[1]
return {
title: `裁判模型和写作模型都是${model ? `「${model}」` : '同一个'}:等于自己审自己`,
next: '到设置 → 证据裁判选一个不同的模型,或者在报告撰写节点的「结论句裁判」里指定裁判模型',
fix: 'canvas',
}
}
case 'report_rewrite': {
// 「裁判认为 2 句结论证据不支持(「…」「…」),已交回写作者只改这几句」
const n = message.match(/裁判认为\s*(\d+)\s*句/)?.[1]
return {
title: `裁判认为${n ? ` ${n} 句` : ''}结论证据不支持,已交回写作者只改这几句`,
sub: message.match(/证据不支持((.+))/)?.[1],
}
}
case 'report_rewrite_rejected': {
// 「改写稿冒出 1 处原稿没有的问题(「…」),没有采用,保留原稿和原来的判定」
const n = message.match(/冒出\s*(\d+)\s*处/)?.[1]
return {
title: `改写稿冒出${n ? ` ${n} 处` : ''}原稿没有的问题,没有采用`,
sub: message.match(/问题((.+))/)?.[1],
next: '保留的是原稿和原来的判定',
}
}
case 'repair_invented': {
// 「第 1 次修复作废:修复时出现了原文没有的值:total_count=0」
const values = message.match(/原文没有的值[::]\s*(.+)$/)?.[1]?.trim()
@@ -1387,12 +1457,15 @@ export function decodeRun(events: RunEvent[], final?: RunFinal, opts?: DecodeOpt
// 一出现就成行:模型想的那几十秒里得有一行在走,而不是等 end 才冒出来。
// 团队成员和调度者的调用没有 start(它们的 end 只用来记账),不会走到这
closeLlm(nodeId, 'done', at)
// agent 开了 cite_fields:循环结束后多一次结构化抽取,按出处把字段交出来。它不是在「作答」
// agent 开了 cite_fields:循环结束后多一次结构化抽取,按出处把字段交出来。它不是在「作答」。
// 报告撰写节点请裁判模型判断结论句(purpose judge)同理,另起名字
const extract = d.purpose === 'cite_fields'
const judging = d.purpose === 'judge'
const step: Step = {
id: `llm-${seq}`, seq, kind: 'llm', title: extract ? EXTRACT_TITLE : '思考并作答',
id: `llm-${seq}`, seq, kind: 'llm',
title: extract ? EXTRACT_TITLE : judging ? judgeTitle(d.units) : '思考并作答',
status: 'running', nodeId, startedAt: at,
...(extract ? { code: 'cite_fields' } : {}),
...(extract ? { code: 'cite_fields' } : judging ? { code: 'judge' } : {}),
...(d.model ? { detail: `模型:${d.model}` } : {}),
}
pendingLlm.set(nodeId ?? '_', step)
@@ -1429,6 +1502,12 @@ export function decodeRun(events: RunEvent[], final?: RunFinal, opts?: DecodeOpt
step.title = `${EXTRACT_TITLE}没跑成`
step.detail = [String(d.error), step.detail].filter(Boolean).join('\n')
}
if (d.purpose === 'judge' && d.error) {
// 裁判没跑成(超时、调用失败):这一批记为未裁判、报告照常交——同样是提醒,不是失败
step.level = 'warn'
step.title = JUDGE_FAILED_TITLE
step.detail = [String(d.error), step.detail].filter(Boolean).join('\n')
}
pendingLlm.delete(nodeId ?? '_')
break
}
@@ -1684,7 +1763,8 @@ export function decodeRun(events: RunEvent[], final?: RunFinal, opts?: DecodeOpt
const none = counts ? counts.none + counts.other : 0
const violations: any[] = Array.isArray(d.violations) ? d.violations : []
const repairs = num(d.repairs) ?? 0
const tally = counts ? evidenceTally(counts.cited, counts.total, counts.other) : ''
const tally = [counts ? evidenceTally(counts.cited, counts.total, counts.other) : '', judgeTally(d.judge)]
.filter(Boolean).join(' · ')
const listed = violations.slice(0, 8)
.map((v) => `· ${String(v?.message ?? v?.text ?? v?.code ?? '')}`).filter((x) => x.length > 2)
const more = violations.length > listed.length ? [`…另有 ${violations.length - listed.length} 处`] : []
@@ -1701,6 +1781,21 @@ export function decodeRun(events: RunEvent[], final?: RunFinal, opts?: DecodeOpt
break
}
case 'evidence.judged': {
// 探索运行跑完、封存之后,有人点开结论句请模型判断:判定追加在封存之后,不改封存的报告
const verdicts = d.verdicts && typeof d.verdicts === 'object' ? Object.values(d.verdicts as Record<string, any>) : []
const judged = verdicts.filter((v) => ['supported', 'partial', 'unsupported', 'not_a_claim'].includes(v?.status)).length
const hit: string[] = Array.isArray(d.limits_hit) ? d.limits_hit : []
push({
id: `ej-${seq}`, seq, kind: 'note', nodeId, status: 'done', code: 'evidence_judged',
level: hit.length || (Array.isArray(d.gaps) && d.gaps.length) ? 'warn' : 'info',
title: `封存后按需裁判了 ${formatNumber(judged)} 句结论${hit.length ? ',有的到了上限没判' : ''}`,
sub: '封存后追加 · 模型判断,非确定',
...(d.model ? { detail: [`模型:${d.model}`, ...(Array.isArray(d.gaps) ? d.gaps.map(String) : [])].join('\n') } : {}),
}, nodeId)
break
}
case 'caliber.upgrade':
out.push({
id: `cu-${seq}`, seq, kind: 'note', level: 'warn', status: 'done',