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

一、结论句裁判

- 报告节点新增 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
+15
View File
@@ -392,6 +392,21 @@ export function hasPendingApproval(approvals: Approval[], runId: string | null |
return approvals.some((a) => a.run_id === runId && a.status === 'pending')
}
/**
* 只写了模型、没选接入时,后端按模型名找接入(providers/factory.resolve_provider):启用的接入里模型清单有它的,
* 再看默认模型是它的;只有停用的接入认得它时后端直接报错(不会悄悄换一家)。都认不出返回 undefined——
* 后端这时用第一个启用的非 mock 接入去调
*/
export function providerOfModel(providers: Provider[], model: string):
{ provider: Provider; enabled: boolean } | undefined {
const owns = (p: Provider) => (p.models ?? []).some((m) => m?.id === model)
const enabled = providers.filter((p) => p.enabled)
const hit = enabled.find(owns) ?? enabled.find((p) => p.default_model === model)
if (hit) return { provider: hit, enabled: true }
const off = providers.find((p) => !p.enabled && (owns(p) || p.default_model === model))
return off ? { provider: off, enabled: false } : undefined
}
/** 把所有 provider 的模型拉平成下拉选项。 */
export function modelOptions(providers: Provider[]): { value: string; label: string; group: string }[] {
const out: { value: string; label: string; group: string }[] = []
+92 -1
View File
@@ -1,6 +1,10 @@
import { useEffect, useMemo } from 'react'
import { create } from 'zustand'
import { ApiError, api } from '../api/client'
import type { EvidenceDocData, EvidenceGraph, EvidenceSegmentDetail, EvidenceStats } from '../types'
import { graphVerdicts, judgedVerdicts } from '../lib/evidence'
import type {
EvidenceDocData, EvidenceGraph, EvidenceJudgeResult, EvidenceSegmentDetail, EvidenceStats, EvidenceVerdict,
} from '../types'
/**
* 可点击证据的缓存:报告文档、证据图、点开过的片段。
@@ -12,6 +16,10 @@ import type { EvidenceDocData, EvidenceGraph, EvidenceSegmentDetail, EvidenceSta
*
* 出错的不缓存成定论:下次点开再取一次(后端刚重启、接口还没部署到这个版本都会是
* 一时的)。正在取的不重复发。
*
* 四期:封存之后按需追加的结论句判定按 `runId@报告` 记在 judged 里(按需裁判接口、片段接口叠上的
* 判定都记进来),正文的句末徽标、横幅的结论句计数据此盖过文档里的「未裁判 · 按需」。封存的文档本身
* 一个字不改。同一句正在判的不重复发;判过的(判定不是未裁判)不再给按钮,也就不会再发
*/
export interface Slot<T> {
@@ -49,8 +57,23 @@ interface EvidenceState {
* 不一定还是最近的。清掉以后,运行摘下来(「清除」、换一张图再回来)时 loadLatest 重新取
*/
dropLatest: (workflowId: string) => void
/** 封存之后追加的判定:`runId@报告` → {unit: 判定} */
judged: Record<string, Record<string, EvidenceVerdict>>
/** 按需裁判的请求:`runId@报告:unit` → 这一次的答复(触顶、失败说什么靠它) */
asks: Record<string, Slot<EvidenceJudgeResult>>
/** 运行类别(formal / exploratory):没开裁判的文档靠它认探索运行,按需取一次 */
runClasses: Record<string, Slot<string | null>>
/** 记下几句封存后追加的判定(片段接口叠上的、证据图带来的) */
noteVerdicts: (runId: string, report: string | undefined, verdicts: Record<string, EvidenceVerdict>) => void
/** 请模型判断这几句(探索运行)。判定记进 judged;答复(含触顶、出错)记进 asks */
judge: (runId: string, report: string | undefined, units: string[]) => Promise<void>
loadRunClass: (runId: string) => Promise<void>
}
/** 封存后追加的判定按哪份报告记:一次运行里有好几份报告时 unit id 会撞(每份都从 u0 数起) */
export const docKey = (runId: string, report?: string) => `${runId}@${report ?? ''}`
export const askKey = (runId: string, report: string | undefined, unit: string) => `${docKey(runId, report)}:${unit}`
/**
* 片段的缓存键:`runId:segId`。一次运行里有好几份报告时片段 id 会撞(每份都从 s0 数起),
* 带上报告节点:`runId:segId@report`
@@ -134,5 +157,73 @@ export const useEvidence = create<EvidenceState>((set, get) => {
return { latest }
})
},
judged: {},
asks: {},
runClasses: {},
noteVerdicts: (runId, report, verdicts) => {
const key = docKey(runId, report)
const cur = get().judged[key] ?? {}
// 内容一样就不换引用:正文按它重算徽标,片段接口每次答同样的判定不该让整份报告重渲染
const fresh = Object.entries(verdicts).filter(([u, v]) => JSON.stringify(cur[u]) !== JSON.stringify(v))
if (!fresh.length) return
set((s) => ({ judged: { ...s.judged, [key]: { ...(s.judged[key] ?? {}), ...Object.fromEntries(fresh) } } }))
},
judge: async (runId, report, units) => {
const keys = units.map((u) => askKey(runId, report, u))
if (!units.length || keys.some((k) => get().asks[k]?.status === 'loading')) return
const mark = (slot: Slot<EvidenceJudgeResult>) =>
set((s) => ({ asks: { ...s.asks, ...Object.fromEntries(keys.map((k) => [k, slot])) } }))
mark({ status: 'loading' })
try {
const res = await api.evidence.judge(runId, { units, ...(report ? { report } : {}) })
get().noteVerdicts(runId, report, judgedVerdicts(res))
mark({ status: 'ok', data: res })
} catch (error) {
mark({ status: 'error', error })
}
},
loadRunClass: (runId) => {
const cur = get().runClasses[runId]
if (cur && cur.status !== 'error') return Promise.resolve()
set((s) => ({ runClasses: { ...s.runClasses, [runId]: { status: 'loading' } } }))
return api.runs.get(runId).then(
(run) => set((s) => ({ runClasses: { ...s.runClasses, [runId]: { status: 'ok', data: run?.run_class ?? null } } })),
(error) => set((s) => ({ runClasses: { ...s.runClasses, [runId]: { status: 'error', error } } })),
)
},
}
})
/**
* 一份报告封存之后追加的判定:证据图带来的(reports[].judged),叠上这一页里按需判的、片段接口答的
* (后者新)。没有运行、什么都没有时是 undefined
*/
export function useVerdicts(runId: string | undefined, report: string | undefined):
Record<string, EvidenceVerdict> | undefined {
const own = useEvidence((s) => (runId ? s.judged[docKey(runId, report)] : undefined))
const graph = useEvidence((s) => (runId ? s.graphs[runId]?.data : undefined))
return useMemo(() => {
const fromGraph = graphVerdicts(graph, report)
if (!own && !Object.keys(fromGraph).length) return undefined
return { ...fromGraph, ...(own ?? {}) }
}, [own, graph, report])
}
/**
* 这份报告出自探索运行吗(按需裁判只在探索运行里有)。开了裁判的文档自己记着:on_demand 是探索运行、
* inline 是正式运行;没开裁判的看调用方给的运行类别,再没有就按运行 id 取一次(enabled 时才取)。
* 还不知道时是 null:按钮先不出,免得在正式运行里闪一下
*/
export function useExplore(doc: Pick<EvidenceDocData, 'judge'>, runId: string | undefined, runClass: string | undefined,
enabled: boolean): boolean | null {
const mode = doc.judge?.mode
const known = mode === 'on_demand' ? true : mode === 'inline' ? false
: runClass ? runClass === 'exploratory' : undefined
const slot = useEvidence((s) => (runId ? s.runClasses[runId] : undefined))
const loadRunClass = useEvidence((s) => s.loadRunClass)
const need = known === undefined && enabled && !!runId
useEffect(() => { if (need && runId) void loadRunClass(runId) }, [need, runId, loadRunClass])
if (known !== undefined) return known
if (!runId) return false
return slot?.status === 'ok' ? slot.data === 'exploratory' : null
}