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

一、结论句裁判

- 报告节点新增 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
+160 -5
View File
@@ -8,11 +8,11 @@ import { fieldOfIssue, unboundToolOf, withToolBound, type FieldRef } from './iss
import { hintOf } from './shortcuts'
import { isActivePhase } from '../run/trace'
import { EDIT_LOCK_TEXT, useEditLock, useStudio } from '../store/studio'
import { datasourceTools, modelOptions, useCatalog, useDatasources } from '../store/catalog'
import { datasourceTools, modelOptions, providerOfModel, useCatalog, useDatasources } from '../store/catalog'
import { api } from '../api/client'
import { IconButton, JsonInput, Modal, isComposing, useRadioGroup } from '../components/ui'
import { formatShortcut } from '../lib/keys'
import { SUBGRAPH_UPGRADE_HELP, upgradeNewerText } from '../lib/terms'
import { JUDGE_FIELD_LABEL, JUDGE_ON_UNSUPPORTED_LABEL, JUDGE_SETTING_TEXT, SUBGRAPH_UPGRADE_HELP, judgeByModelText, upgradeNewerText } from '../lib/terms'
import { TemplateText } from './TemplateText'
import type { NodeType, ValidationIssue, WorkflowVersion } from '../types'
@@ -403,9 +403,10 @@ function Field({ field, nodeId, value, config, issues, onChange }: {
const id = `f-${nodeId}-${field.key}`
const syntax = syntaxOf(field)
const composite = field.type === 'cases' || field.type === 'agents' || field.type === 'ioFields'
|| field.type === 'metricsList' || field.type === 'caliberFrom'
// 复合字段自己把问题落到第几项;落不到具体某一项的,和普通字段一样挂在下面
const own = composite ? issues.filter((i) => i.at?.index == null) : issues
|| field.type === 'metricsList' || field.type === 'caliberFrom' || field.type === 'judge'
// 复合字段自己把问题落到第几项;落不到具体某一项的,和普通字段一样挂在下面。结论句裁判按子键(judge.max_cost_usd)落
const own = field.type === 'judge' ? issues.filter((i) => !i.at?.sub || !JUDGE_SUB_KEYS.has(i.at.sub))
: composite ? issues.filter((i) => i.at?.index == null) : issues
const bad = own.some((i) => i.level === 'error')
const errorId = own.length ? `${id}-issues` : undefined
// 长文本在 360px 宽的栏里没法写:提示词、代码可以展开到大编辑器里(同一份值,边写边存)
@@ -608,6 +609,9 @@ function FieldInput({ field, id, nodeId, syntax, value, config, invalid, describ
case 'caliberFrom':
return <CaliberFromPicker id={id} value={value} invalid={invalid} describedBy={describedBy} />
case 'judge':
return <JudgeConfig id={id} value={value} config={config} issues={issues} onChange={onChange} />
case 'agents':
return <AgentList value={value ?? []} issues={issues} config={config} onChange={onChange} />
@@ -616,6 +620,157 @@ function FieldInput({ field, id, nodeId, syntax, value, config, invalid, describ
}
}
/** judge 子配置里各有自己一行的键:落在这些键上的问题挂在那一行下面 */
const JUDGE_SUB_KEYS = new Set(['provider', 'model', 'max_claims', 'max_cost_usd', 'timeout_s', 'rewrite_once', 'on_unsupported'])
/**
* 结论句裁判(claims: judge)的子配置:裁判模型、三项上限(各自可以设成不限)、改写一次、证据不支持时怎么判档。
*
* 上限有三种写法,得分得清:没写(跟随设置里「证据裁判」的默认值)、写数、写 null(不限)。勾「不限」写 null,
* 清空数字框回到没写。全都没写时整个 judge 去掉,不留一个空对象。受管级别发布要求写了 max_cost_usd(数或 null)
*/
function JudgeConfig({ id, value, config, issues, onChange }: {
id: string; value: any; config: Record<string, any>; issues: FieldIssue[]; onChange: (v: any) => void
}) {
const providers = useCatalog((s) => s.providers)
const judge: Record<string, any> = value && typeof value === 'object' && !Array.isArray(value) ? value : {}
const set = (key: string, v: unknown) => {
const next = { ...judge }
if (v === undefined) delete next[key]
else next[key] = v
onChange(Object.keys(next).length ? next : undefined)
}
const issuesOf = (key: string) => issues.filter((i) => i.at?.sub === key)
const lines = (key: string) => issuesOf(key).map((i, k) => <IssueLine key={k} issue={i} />)
const provider = typeof judge.provider === 'string' ? judge.provider : ''
const pv = provider ? providers.find((p) => p.name === provider) : undefined
const model = typeof judge.model === 'string' ? judge.model : ''
// 和写报告的模型是同一个:等于自己审自己。校验也会报(report.judge_same_model),报了就不重复说
const same = !!model && model === config.model && !issuesOf('model').length
// 节点上只写了模型:这一级写了就整组用节点上的(judge_model_spec 不跨级拼),后端按模型名找接入——
// 不再跟随设置,接入留空那一项不能还叫「跟随设置」
const byModel = !provider && !!model.trim()
const owner = byModel ? providerOfModel(providers, model.trim()) : undefined
const enabled = providers.filter((p) => p.enabled)
const fallback = enabled.find((p) => p.kind !== 'mock') ?? enabled[0]
const byModelHint = byModel && providers.length > 0
? judgeByModelText('node', model.trim(), owner && { name: owner.provider.name, enabled: owner.enabled }, fallback?.name)
: ''
const models = pv ? (pv.models ?? []).map((m) => m.id) : [...new Set(modelOptions(providers).map((o) => o.value))]
return (
<div className="space-y-2.5 rounded border px-2.5 py-2" data-judge-config="">
<div data-judge-key="model">
<div className="grid grid-cols-2 gap-2">
<div className="min-w-0">
<label className="label" htmlFor={`${id}-provider`}>{JUDGE_FIELD_LABEL.provider}</label>
<select id={`${id}-provider`} className="field" value={provider}
onChange={(e) => set('provider', e.target.value || undefined)}>
<option value="">{byModel ? JUDGE_SETTING_TEXT.providerFromModel : '跟随设置'}</option>
{provider && !pv && providers.length > 0 && <option value={provider}>{provider}(不存在)</option>}
{providers.map((p) => <option key={p.id} value={p.name}>{p.name}{p.enabled ? '' : '(已停用)'}</option>)}
</select>
</div>
<div className="min-w-0">
<label className="label" htmlFor={`${id}-model`}>{JUDGE_FIELD_LABEL.model}</label>
<input id={`${id}-model`} className="field mono text-xs" list={`${id}-models`} value={model} spellCheck={false}
placeholder={provider ? '留空:接入的默认模型' : '跟随设置'}
onChange={(e) => set('model', e.target.value.trim() ? e.target.value : undefined)} />
<datalist id={`${id}-models`}>{models.map((m) => <option key={m} value={m} />)}</datalist>
</div>
</div>
<div className="mt-1 text-2xs leading-snug text-faint">
接入和模型都没写就用设置里的「证据裁判模型」;写了哪一项就整组用节点上的,不和设置拼。建议和写报告的模型不同:同一个模型审自己写的,写错的地方它多半也看不出来
</div>
{byModelHint && (
<div className="mt-1 text-2xs leading-snug" data-judge-by-model={owner ? (owner.enabled ? 'found' : 'disabled') : 'default'}
style={owner?.enabled ? undefined : { color: 'var(--st-waiting)' }}>
<span className={owner?.enabled ? 'text-faint' : undefined}>{byModelHint}</span>
</div>
)}
{same && (
<div className="mt-1 text-2xs leading-snug" style={{ color: 'var(--st-waiting)' }} data-judge-same="">
裁判模型和写报告的模型都是「{model}」:等于自己审自己
</div>
)}
{lines('provider')}{lines('model')}
</div>
{(['max_claims', 'max_cost_usd', 'timeout_s'] as const).map((key) => (
<JudgeLimit key={key} id={`${id}-${key}`} name={key} value={judge[key]} issues={lines(key)}
onChange={(v) => set(key, v)} />
))}
<div data-judge-key="rewrite_once">
<label className="flex cursor-pointer items-start gap-2 text-xs">
<input type="checkbox" className="mt-0.5 accent-[var(--accent)]" checked={judge.rewrite_once === true}
onChange={(e) => set('rewrite_once', e.target.checked ? true : undefined)} />
<span>
{JUDGE_FIELD_LABEL.rewrite_once}
<span className="mt-0.5 block text-2xs leading-snug text-faint">
默认关。打开后裁判认为证据不支持的句子连同理由交回写作者只改这几句,再判一次,最多一轮;多一次写作和裁判的花费,
改写稿冒出原稿没有的问题就不采用
</span>
</span>
</label>
{lines('rewrite_once')}
</div>
<div data-judge-key="on_unsupported">
<label className="label" htmlFor={`${id}-on_unsupported`}>{JUDGE_FIELD_LABEL.on_unsupported}</label>
<select id={`${id}-on_unsupported`} className="field" value={judge.on_unsupported ?? ''}
onChange={(e) => set('on_unsupported', e.target.value || undefined)}>
<option value="">默认:{JUDGE_ON_UNSUPPORTED_LABEL.degrade}</option>
<option value="degrade">{JUDGE_ON_UNSUPPORTED_LABEL.degrade}(degrade)</option>
<option value="withhold">{JUDGE_ON_UNSUPPORTED_LABEL.withhold}(withhold)</option>
{typeof judge.on_unsupported === 'string' && judge.on_unsupported
&& !(judge.on_unsupported in JUDGE_ON_UNSUPPORTED_LABEL) && (
<option value={judge.on_unsupported} disabled>{judge.on_unsupported}:不认识的值,只能选上面两项</option>
)}
</select>
<div className="mt-1 text-2xs leading-snug text-faint">只管正式运行;探索运行只标注,不拦</div>
{lines('on_unsupported')}
</div>
</div>
)
}
/** 一项裁判上限:数字框加「不限」。没写、写数、写 null(不限)三种各有一句说明 */
function JudgeLimit({ id, name, value, issues, onChange }: {
id: string; name: 'max_claims' | 'max_cost_usd' | 'timeout_s'; value: unknown; issues: React.ReactNode
onChange: (v: number | null | undefined) => void
}) {
const off = value === null
const shown = typeof value === 'number' || typeof value === 'string' ? String(value) : ''
const note = off ? JUDGE_LIMIT_OFF[name]
: value === undefined ? '没写:用设置里「证据裁判」的默认值' : ''
return (
<div data-judge-key={name} data-judge-unlimited={off ? '' : undefined}>
<label className="label" htmlFor={id}>{JUDGE_FIELD_LABEL[name]}</label>
<div className="flex items-center gap-2">
<input id={id} className="field tnum min-w-0 flex-1" type="number" min={0} step={name === 'max_claims' ? 1 : 'any'}
value={off ? '' : shown} disabled={off} placeholder={off ? '不限' : '跟随设置'}
onChange={(e) => onChange(e.target.value === '' ? undefined : Number(e.target.value))} />
<label className="flex shrink-0 cursor-pointer items-center gap-1 text-xs">
<input type="checkbox" className="accent-[var(--accent)]" checked={off} aria-label={`${JUDGE_FIELD_LABEL[name]}:不限`}
onChange={(e) => onChange(e.target.checked ? null : undefined)} />
不限
</label>
</div>
{note && (
<div className="mt-1 text-2xs leading-snug" style={off ? { color: 'var(--st-waiting)' } : undefined}
data-judge-note={off ? 'unlimited' : 'default'}>
<span className={off ? undefined : 'text-faint'}>{note}</span>
</div>
)}
{issues}
</div>
)
}
/** 节点上某项设成不限时写明:费用还受什么约束(同设置页,节点上的只说这一份报告) */
const JUDGE_LIMIT_OFF: Record<'max_claims' | 'max_cost_usd' | 'timeout_s', string> = {
max_claims: '不设上限,句数只受报告里结论句多少约束',
max_cost_usd: '不设上限,这份报告的裁判费用只受句数、时长上限和每日上限约束',
timeout_s: '不设上限,时长只受模型接口自身的超时约束',
}
/**
* 值里能写 {{ }} 的 JSON(工具参数、子工作流入参、出具契约)。
*
+12 -2
View File
@@ -16,7 +16,7 @@ import { matchedSource } from '../lib/evidence'
import { explainRunError } from '../lib/explain'
import { formatDuration, formatLapse, formatNumber, formatTokens, NONE, shortId } from '../lib/format'
import { statusMeta } from '../lib/status'
import { issuanceLabel, reportStampText, RUN_CLASS_LABEL } from '../lib/terms'
import { claimTally, issuanceLabel, reportStampText, RUN_CLASS_LABEL } from '../lib/terms'
import { useReportStamp, type ReportStamp } from './reportStamp'
import { ApprovalCard } from '../run/RunPanel'
import type { NodeState, NodeTrace } from '../run/trace'
@@ -188,6 +188,13 @@ function matchedLines(matched: unknown): string {
return `回指明细:\n${lines.join('\n')}${more}`
}
/** stats 里的裁判句数(claims 为 judge 时才有)→「结论 4 句(支持 1 · 不支持 1 · 未裁判 2)」 */
function claimsLine(st: ReportStamp['stats']): string {
const n = (v: unknown) => (typeof v === 'number' && Number.isFinite(v) ? v : 0)
const c = { supported: n(st.supported), partial: n(st.partial), unsupported: n(st.unsupported), unjudged: n(st.unjudged), uncited: 0 }
return claimTally({ ...c, total: c.supported + c.partial + c.unsupported + c.unjudged })
}
/** 报告节点章的悬停说明:两个数怎么来的,缺口里各有什么 */
function reportStampTitle(r: ReportStamp): string {
const st = r.stats
@@ -200,7 +207,10 @@ function reportStampTitle(r: ReportStamp): string {
n(st.unresolved) ? `引用解析不了 ${formatNumber(n(st.unresolved))} 处` : '',
n(st.unknown_entities) ? `可能是编造的名字 ${formatNumber(n(st.unknown_entities))} 个` : '',
n(st.unverified_entities) ? `核对不了的名字 ${formatNumber(n(st.unverified_entities))} 个(只标注,不计入)` : '',
uncited ? `没挂依据的结论句 ${formatNumber(uncited)} 句${r.claims === 'require_citation' ? '(计入缺口)' : '(结论句策略不要求,不计入)'}` : '',
uncited ? `没挂依据的结论句 ${formatNumber(uncited)} 句${r.claims === 'require_citation' || r.claims === 'judge'
? '(计入缺口)' : '(结论句策略不要求,不计入)'}` : '',
// 结论句裁判(四期):模型的判断,不计入章上的两个数
r.claims === 'judge' && claimsLine(st) ? `${claimsLine(st)}(模型判断,非确定,不计入)` : '',
'完整清单在记录页这次运行的「证据」页签',
].filter(Boolean).join('\n')
}
+34 -3
View File
@@ -11,7 +11,7 @@
* 那一栏,定位落到工具上(见 toolBindingOf)。
*/
import { ApiError } from '../api/client'
import { APPROVAL_POLICY_LABEL } from '../lib/terms'
import { APPROVAL_POLICY_LABEL, JUDGE_FIELD_LABEL, JUDGE_ON_UNSUPPORTED_LABEL } from '../lib/terms'
import { NODE_DEFS } from './nodeDefs'
import type { FlowNode } from '../store/studio'
import type { AutofixResult, GraphSpec, PublishCheck, PublishFix, PublishLevel, ValidationIssue } from '../types'
@@ -370,14 +370,33 @@ export type NodeNameOf = (id: string) => string | undefined
const isRecord = (v: unknown): v is Record<string, unknown> => !!v && typeof v === 'object' && !Array.isArray(v)
/** 修复改的是哪个字段:顶层键用节点定义里的叫法,契约里的键另有一张表,其余原样 */
/** 修复改的是哪个字段:顶层键用节点定义里的叫法,契约里的键另有一张表,结论句裁判(judge.*)另一张,其余原样 */
export function fixFieldLabel(field: string | null | undefined, nodeType?: string): string {
if (!field) return ''
const [head, ...rest] = field.split('.')
if (head === 'label') return '节点名称'
const def = nodeType ? NODE_DEFS[nodeType as keyof typeof NODE_DEFS] : undefined
const base = def?.fields.find((f) => f.key === head)?.label ?? EXTRA_FIELDS[head] ?? head
return [base, ...rest.map((k) => SUB_KEYS[k] ?? k)].join(' · ')
const sub = head === 'judge' ? JUDGE_FIELD_LABEL : SUB_KEYS
return [base, ...rest.map((k) => sub[k] ?? k)].join(' · ')
}
/** judge 里写 null 表示不限的三项上限:预览里 null 写「不限」,不写「(空)」——没写和不限是两回事 */
const JUDGE_LIMITS = new Set(['max_claims', 'max_cost_usd', 'timeout_s'])
/** judge.* 一项的值怎么写:上限带单位,null 是不限,判档写选项文字。不是 judge 的键返回 null */
function judgeValueText(value: unknown, key: string): string | null {
if (JUDGE_LIMITS.has(key)) {
if (value === null) return '不限'
if (typeof value === 'number' && Number.isFinite(value)) {
return key === 'max_cost_usd' ? `$${value}` : key === 'timeout_s' ? `${value} 秒` : `${value} 句`
}
return null
}
if (key === 'on_unsupported' && typeof value === 'string' && value in JUDGE_ON_UNSUPPORTED_LABEL) {
return JUDGE_ON_UNSUPPORTED_LABEL[value]
}
return null
}
/**
@@ -386,6 +405,10 @@ export function fixFieldLabel(field: string | null | undefined, nodeType?: strin
* 其余压成一行
*/
export function fixValueText(value: unknown, field?: string | null, nameOf?: NodeNameOf): string {
if (field?.startsWith('judge.')) {
const said = judgeValueText(value, field.slice(6))
if (said != null) return said
}
if (value === undefined || value === null || value === '' || (Array.isArray(value) && !value.length)
|| (isRecord(value) && !Object.keys(value).length)) return '(空)'
const key = field?.split('.').pop()
@@ -414,6 +437,14 @@ export function fixValueText(value: unknown, field?: string | null, nameOf?: Nod
* 不是整份契约的返回 null
*/
export function fixValueLines(value: unknown, field?: string | null, nameOf?: NodeNameOf): string[] | null {
// 整份结论句裁判(补预算那条修复按整份 judge 记):一键一行,「金额上限(美元):不限」
if (field === 'judge' && isRecord(value) && Object.keys(value).length) {
const order = Object.keys(JUDGE_FIELD_LABEL)
return Object.keys(value).sort((a, b) => {
const [x, y] = [order.indexOf(a), order.indexOf(b)]
return (x < 0 ? order.length : x) - (y < 0 ? order.length : y)
}).map((k) => `${JUDGE_FIELD_LABEL[k] ?? k}:${fixValueText(value[k], `judge.${k}`, nameOf)}`)
}
if (field !== 'contract' || !isRecord(value) || !Object.keys(value).length) return null
const order = Object.keys(CONTRACT_KEYS)
const keys = Object.keys(value).sort((a, b) => {
+13 -6
View File
@@ -8,7 +8,7 @@ import type { NodeType } from '../types'
export type FieldType =
| 'text' | 'textarea' | 'prompt' | 'code' | 'number' | 'select' | 'switch'
| 'json' | 'model' | 'tools' | 'skills' | 'collection'
| 'ioFields' | 'cases' | 'agents' | 'metricsList' | 'nodeRefs' | 'caliberFrom'
| 'ioFields' | 'cases' | 'agents' | 'metricsList' | 'nodeRefs' | 'caliberFrom' | 'judge'
/**
* 这个字段里写的是什么语法。
@@ -564,17 +564,24 @@ export const NODE_DEFS: Record<NodeType, NodeDef> = {
help: '有违规时把清单交回去让模型重写。每次都是一整篇的调用,写不对的模型多给几次也大多写不对',
},
{
// 后端只认 off / require_citation(schema.REPORT_CLAIMS);judge 是四期的模型裁判,写了会被校验拦下。
// 没写等于 off:select 显示第一项,正好是默认
// 后端认 off / require_citation / judge(schema.CLAIMS_VALUES)。没写等于 off:select 显示第一项,正好是默认
key: 'claims', label: '没挂依据的结论句', type: 'select',
options: [
{ value: 'off', label: '不管(默认):不参与出具判档' },
{ value: 'require_citation', label: '计入缺口:出具按档位降档' },
{ value: 'judge', label: '计入缺口,并请模型逐句判断证据支不支持' },
],
help: '结论句是带数字、方向词或因果词的句子。选「计入缺口」时,写作提示要求每句结论挂上 [[see:…]] 依据,'
+ '没挂的记为缺口、出具降档(系统自动链接的表名字段名不算依据)。受管级别发布必须显式选它。'
+ '结论句裁判在后续版本支持',
unknownLabel: (v) => (v === 'judge' ? 'judge:结论句裁判在后续版本支持,现在不能用' : `${v}:不认识的值,只能选上面两项`),
+ '没挂的记为缺口、出具降档(系统自动链接的表名字段名不算依据)。选「请模型逐句判断」时,另一个模型按证据'
+ '判断每句结论:正式运行里当场判、结果随报告封存,探索运行点开哪句判哪句;判断是模型给的,不是系统核对。'
+ '受管级别发布必须显式选后两项之一,选模型判断的还要在高级选项里写金额上限(或写不限)',
unknownLabel: (v) => `${v}:不认识的值,只能选上面三项`,
},
{
// claims 为 judge 时的子配置(schema.JUDGE_KEYS)。没写的上限用设置里「证据裁判」的默认值;写 null 是不限
key: 'judge', label: '结论句裁判', type: 'judge', advanced: true,
when: (c) => c.claims === 'judge' || (!!c.judge && typeof c.judge === 'object'),
help: '没写的上限用设置里「证据裁判」的默认值;勾「不限」写 null,只受其余上限约束。裁判模型建议和写报告的模型不同',
},
{
// 后端只认 link / off(report.py 的 ENTITIES)