合入期 4 期 3 收尾:核查缺口分「核查未通过」「核查未完成」两组,时间线认得核查类日志代码;双盲复算写目录的预告和真写逐字一致(被目录挡下的那一边也说清原因,几个指标落到同一项时按组合预告);反方审稿说清「根本没反查」和「到底降不降档」;字段叫法挪到 labels.py;记录页的核查工件有名字和说明

This commit is contained in:
ThearchyHelios
2026-10-06 11:31:11 +08:00
32 changed files with 3213 additions and 660 deletions
+53 -164
View File
@@ -1,62 +1,41 @@
import { useEffect, useMemo, useState } from 'react'
import { useMemo } from 'react'
import type { ReactNode } from 'react'
import { X } from 'lucide-react'
import clsx from 'clsx'
import { api } from '../api/client'
import { useStudio } from '../store/studio'
import { modelOptions, providerOfModel, useCatalog } from '../store/catalog'
import { useRadioGroup } from '../components/ui'
import { DUAL_CHECK_TEXT } from '../lib/terms'
import type { VerifySettings } from '../types'
import type { FieldRenderProps, NodeSummaryContext } from './nodeDefs'
import {
ModelInput, NodePick, ProviderPick, TriState, resolvePick, upstreamOf, useVerifyDefaults,
type CanvasEdge, type CanvasNode, type NodePickText, type TriStateText, type VerifyModelText,
} from './verifyFields'
/*
* 双盲复算节点的检查器控件(nodeDefs 里 dual_check 各字段的 render)和节点卡片的摘要。
*
* 口径卡、要复算的指标、口径说明都得看画布上别的节点:从 studio store 读,不往检查器的 props 里加字段。
* 每个控件只写自己那个键(FieldRenderProps.onChange);写回 undefined 就是「留空 = 跟随默认」,配置里不留空值。
* 后端认的键和缺省见 types.ts 的 DualCheckConfig
* 选口径卡、盲算模型、启用三态用核查类节点共用的控件(verifyFields.tsx,反方审稿也用它们),这里只给文案;双盲复算
* 特有的选指标、口径说明、相对误差在这里。口径卡、要复算的指标、口径说明都得看画布上别的节点:从 studio store 读,
* 不往检查器的 props 里加字段。每个控件只写自己那个键(FieldRenderProps.onChange);写回 undefined 就是「留空 = 跟随
* 默认」,配置里不留空值。后端认的键和缺省见 types.ts 的 DualCheckConfig
*/
const T = DUAL_CHECK_TEXT
type CanvasNode = NodeSummaryContext['nodes'][number]
type CanvasEdge = NodeSummaryContext['edges'][number]
const isRecord = (v: unknown): v is Record<string, any> => !!v && typeof v === 'object' && !Array.isArray(v)
const ids = (v: unknown): string[] => (Array.isArray(v) ? v.filter((x): x is string => typeof x === 'string' && !!x) : [])
/** 某个节点的全部上游(沿连线往回走),不含它自己 */
function upstreamOf(id: string, edges: readonly CanvasEdge[]): Set<string> {
const parents = new Map<string, string[]>()
for (const e of edges) parents.set(e.target, [...(parents.get(e.target) ?? []), e.source])
const seen = new Set<string>()
const stack = [...(parents.get(id) ?? [])]
while (stack.length) {
const cur = stack.pop()!
if (seen.has(cur) || cur === id) continue
seen.add(cur)
stack.push(...(parents.get(cur) ?? []))
}
return seen
}
/** 画布上的口径卡:本节点上游的在前(复算只能复算它们),其余的另列 */
function cardsOf(id: string, nodes: readonly CanvasNode[], edges: readonly CanvasEdge[]) {
const up = upstreamOf(id, edges)
const cards = nodes.filter((n) => n.data.nodeType === 'metrics')
return { upstream: cards.filter((n) => up.has(n.id)), other: cards.filter((n) => !up.has(n.id)) }
}
/**
* 实际复算哪张卡:写了 card 就是它(不在画布上时 node 为 null);没写取上游的口径卡,上游只有一张时就是它,
* 好几张时说不准,node 为 null、由调用方照实说
* 实际复算哪张卡:写了 card 就是它(不在画布上、不是口径卡时 node 为 null;不在上游也照样是它,指标照列,选卡的地方
* 另外提醒);没写取上游的口径卡(schema.dual_check_card 的认法),上游只有一张时就是它,好几张时说不准,node 为 null、
* 由调用方照实说
*/
function targetOf(config: Record<string, any>, id: string, nodes: readonly CanvasNode[], edges: readonly CanvasEdge[]) {
const { upstream } = cardsOf(id, nodes, edges)
const up = upstreamOf(id, edges)
const upstream = nodes.filter((n) => up.has(n.id) && n.data.nodeType === 'metrics')
const card = typeof config.card === 'string' && config.card ? config.card : ''
if (card) return { node: nodes.find((n) => n.id === card && n.data.nodeType === 'metrics') ?? null, card, upstream }
return { node: upstream.length === 1 ? upstream[0] : null, card: '', upstream }
const pick = resolvePick(id, card, 'metrics', 'upstream', nodes, edges)
const node = pick.kind === 'target' || pick.kind === 'notUpstream' ? pick.node : null
return { node, card, upstream }
}
/** 一张口径卡在摘要里的名字:节点名,没起名的用口径名,再没有用 id */
@@ -92,33 +71,7 @@ export function dualCheckSummary({ id, config, nodes, edges }: NodeSummaryContex
return config.enabled === false ? `${text} · ${S.off}` : text
}
// ---------------------------------------------------------------- 设置里的默认值
/**
* 设置里核查一组的值:相对误差、启用的「跟随设置」要写出现在是多少。每次打开检查器都重取一次——去设置页关掉双盲
* 复算、改了误差再回到画布,这里得是新值(不同于检查器的运行默认值,核查开关是常改的)。先用上次取到的画,免得
* 闪一下;同一次打开里的几个字段共用一个请求;取不到就沿用上次的(没有就不写),不挡编辑
*/
let verifyPending: Promise<VerifySettings | null> | null = null
let verifyValue: VerifySettings | null | undefined
function fetchVerify(): Promise<VerifySettings | null> {
verifyPending ??= api.settings.get().then(
(s) => (verifyValue = isRecord(s?.verify) ? s.verify as VerifySettings : null),
() => verifyValue ?? null,
).finally(() => { verifyPending = null })
return verifyPending
}
function useVerifyDefaults(): VerifySettings | null {
const [value, setValue] = useState<VerifySettings | null>(verifyValue ?? null)
useEffect(() => {
let alive = true
void fetchVerify().then((v) => { if (alive) setValue(v) })
return () => { alive = false }
}, [])
return value
}
/** 字段下面的一行提醒(所选口径卡不在上游之类),提醒色 */
/** 字段下面的一行提醒(写了说明的指标不在复算范围里之类),提醒色 */
function Warn({ children, attr }: { children: ReactNode; attr: string }) {
return (
<div className="mt-1 text-2xs leading-snug" style={{ color: 'var(--st-waiting)' }} {...{ [attr]: '' }}>{children}</div>
@@ -127,33 +80,23 @@ function Warn({ children, attr }: { children: ReactNode; attr: string }) {
// ---------------------------------------------------------------- 各字段
/** 要复算的口径卡:下拉选画布上的口径卡,上游的一组、其余的一组;留空取上游的口径卡 */
function CardField({ id, nodeId, value, invalid, describedBy, onChange }: FieldRenderProps) {
const nodes = useStudio((s) => s.nodes)
const edges = useStudio((s) => s.edges)
const { upstream, other } = useMemo(() => cardsOf(nodeId, nodes, edges), [nodeId, nodes, edges])
const current = typeof value === 'string' ? value : ''
const known = [...upstream, ...other].some((n) => n.id === current)
const option = (n: CanvasNode) => (
<option key={n.id} value={n.id}>{T.cardOption(String(n.data.label || n.id), n.data.config?.caliber)}</option>
)
return (
<>
<select id={id} className="field" value={current} aria-invalid={invalid || undefined} aria-describedby={describedBy}
data-dual-field="card" onChange={(e) => onChange(e.target.value || undefined)}>
<option value="">{T.cardDefault(upstream.length === 1 ? cardName(upstream[0]) : null, upstream.length)}</option>
{upstream.length > 0 && <optgroup label={T.cardUpstream}>{upstream.map(option)}</optgroup>}
{other.length > 0 && <optgroup label={T.cardOther}>{other.map(option)}</optgroup>}
{/* 写着的卡已经不在画布上:照实列出来(不让它看着像「默认」),下面再说一句 */}
{current && !known && <option value={current}>{T.cardGone(current)}</option>}
</select>
{/* 上游有好几张又没选:服务端校验会挡住发起运行,用提醒色写明要选 */}
{!current && upstream.length > 1 && <Warn attr="data-dual-card-warn">{T.cardChoose(upstream.length)}</Warn>}
{current && known && !upstream.some((n) => n.id === current) && <Warn attr="data-dual-card-warn">{T.cardNotUpstream}</Warn>}
{current && !known && <Warn attr="data-dual-card-warn">{T.cardMissing(current)}</Warn>}
</>
)
/**
* 要复算的口径卡(共用的 NodePick):上游的一组、其余的一组(选了不在上游的,提醒把它连到上游);留空取上游的口径卡,
* 上游有好几张又没选时写明要选(服务端校验会挡住发起运行);写着的卡不在画布上、不是口径卡时照实列出来、说一句
*/
const CARD_TEXT: NodePickText = {
auto: (only, count) => T.cardDefault(only, count),
many: (n) => T.cardChoose(n),
missing: (id) => T.cardGone(id),
notUpstream: (label) => label,
wrongType: (label) => T.cardWrongType(label),
missingHint: T.cardMissingHint,
notUpstreamHint: T.cardNotUpstream,
wrongTypeHint: (type) => T.cardWrongTypeHint(type),
groups: { upstream: T.cardUpstream, other: T.cardOther },
}
/** 一张口径卡在下拉里的叫法:节点名,口径名不同时附在后面 */
const cardOption = (n: CanvasNode) => T.cardOption(String(n.data.label || n.id), n.data.config?.caliber)
/**
* 复算的指标:所选口径卡的指标逐个勾。没写(全部勾着)是缺省——复算输入来自查询的全部指标;全部勾回来时写回
@@ -280,52 +223,12 @@ function DefinitionsField({ id, nodeId, value, config, describedBy, onChange }:
}
/**
* 盲算模型 · 接入。照报告节点「结论句裁判」的写法:留空跟随设置;只填了模型时接入按模型名找,留空那一项改叫
* 「按模型名找接入」(verify_model_spec 哪一级写了就整组用哪一级,不跨级拼)
* 盲算模型(共用的 ProviderPick、ModelInput):留空跟随设置;只填了模型时接入按模型名找,留空那一项改叫「按模型名找
* 接入」,并写明实际用哪个接入(verify_model_spec 哪一级写了就整组用哪一级,不跨级拼)。取值链的说明在字段的帮助里
*/
function ProviderField({ id, value, config, invalid, describedBy, onChange }: FieldRenderProps) {
const providers = useCatalog((s) => s.providers)
const provider = typeof value === 'string' ? value : ''
const known = providers.some((p) => p.name === provider)
const byModel = !provider && typeof config.model === 'string' && !!config.model.trim()
return (
<select id={id} className="field" value={provider} aria-invalid={invalid || undefined} aria-describedby={describedBy}
data-dual-field="provider" onChange={(e) => onChange(e.target.value || undefined)}>
<option value="">{byModel ? T.providerFromModel : T.providerFollow}</option>
{provider && !known && providers.length > 0 && <option value={provider}>{T.providerGone(provider)}</option>}
{providers.map((p) => <option key={p.id} value={p.name}>{p.name}{p.enabled ? '' : T.providerOff}</option>)}
</select>
)
}
/** 盲算模型 · 模型:可以手填,下拉给所选接入(没选接入时给全部启用接入)的模型;只填了模型时写明实际用哪个接入 */
function ModelField({ id, value, config, invalid, describedBy, onChange }: FieldRenderProps) {
const providers = useCatalog((s) => s.providers)
const provider = typeof config.provider === 'string' ? config.provider : ''
const pv = provider ? providers.find((p) => p.name === provider) : undefined
const model = typeof value === 'string' ? value : ''
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 hint = byModel && providers.length > 0
? T.byModel(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 (
<>
<input id={id} className="field mono text-xs" list={`${id}-models`} value={model} spellCheck={false}
placeholder={provider ? T.modelOfProvider : T.modelFollow} aria-invalid={invalid || undefined}
aria-describedby={describedBy} data-dual-field="model"
onChange={(e) => onChange(e.target.value.trim() ? e.target.value : undefined)} />
<datalist id={`${id}-models`}>{models.map((m) => <option key={m} value={m} />)}</datalist>
{hint && (
<div className="mt-1 text-2xs leading-snug" data-dual-by-model={owner ? (owner.enabled ? 'found' : 'disabled') : 'default'}
style={owner?.enabled ? undefined : { color: 'var(--st-waiting)' }}>
<span className={owner?.enabled ? 'text-faint' : undefined}>{hint}</span>
</div>
)}
</>
)
const MODEL_TEXT: VerifyModelText = {
providerFollow: T.providerFollow, providerFromModel: T.providerFromModel, providerMissing: T.providerGone,
providerDisabled: T.providerOff, modelFollow: T.modelFollow, modelDefault: T.modelOfProvider, byModel: T.byModel,
}
/** 允许的相对误差:留空跟随设置,占位里写出设置里眼下是多少;负数标出来(服务端也不收) */
@@ -344,39 +247,25 @@ function ToleranceField({ id, value, invalid, describedBy, onChange }: FieldRend
)
}
const ENABLED = ['follow', 'on', 'off'] as const
type Enabled = typeof ENABLED[number]
/** 启用:跟随设置 / 开启 / 关闭三态(null 或不写、true、false)。跟随设置时写回 undefined,不在配置里留 null */
function EnabledField({ id, value, describedBy, onChange }: FieldRenderProps) {
const settings = useVerifyDefaults()
const current: Enabled = value === true ? 'on' : value === false ? 'off' : 'follow'
const pick = (v: Enabled) => onChange(v === 'on' ? true : v === 'off' ? false : undefined)
const radio = useRadioGroup(ENABLED, current, pick)
return (
<div id={id} role="radiogroup" aria-label={T.field.enabled} aria-describedby={describedBy}
className="flex flex-wrap gap-0.5 rounded border p-0.5" data-dual-field="enabled">
{ENABLED.map((v) => (
<button key={v} type="button" {...radio(v)} data-value={v}
// 按字数分宽度、不折行:「跟随设置(当前开启)」比「开启」长得多,平分会把它挤成两行;太窄时整段换到下一行
className={clsx('flex-auto whitespace-nowrap rounded px-2 py-1 text-2xs transition-colors',
current === v ? 'font-medium text-fg' : 'text-dim hover:bg-hover')}
style={current === v ? { background: 'var(--accent-soft)', boxShadow: 'inset 0 0 0 1px var(--accent)' } : undefined}
onClick={() => pick(v)}>
{v === 'follow' ? T.enabledFollow(settings?.dual_check?.enabled) : T.enabled[v]}
</button>
))}
</div>
)
/**
* 启用(共用的 TriState):跟随设置 / 开启 / 关闭三态(null 或不写、true、false)。跟随设置时写回 undefined,不在配置里
* 留 null;「跟随设置」后面写出设置里现在是开是关(每次打开检查器都重取)。各态的说明在字段的帮助里
*/
const ENABLED_TEXT: TriStateText = {
follow: T.enabled.follow, on: T.enabled.on, off: T.enabled.off, followNow: (on) => T.enabledFollow(on),
}
/** nodeDefs 里 dual_check 各字段的 render */
export const dualCheckFields = {
card: (p: FieldRenderProps) => <CardField {...p} />,
card: (p: FieldRenderProps) => (
<NodePick p={p} fieldKey="card" nodeType="metrics" rule="upstream" text={CARD_TEXT} optionLabel={cardOption} nameOf={cardName} />
),
metrics: (p: FieldRenderProps) => <MetricsField {...p} />,
definitions: (p: FieldRenderProps) => <DefinitionsField {...p} />,
provider: (p: FieldRenderProps) => <ProviderField {...p} />,
model: (p: FieldRenderProps) => <ModelField {...p} />,
provider: (p: FieldRenderProps) => <ProviderPick p={p} text={MODEL_TEXT} />,
model: (p: FieldRenderProps) => <ModelInput p={p} fieldKey="model" text={MODEL_TEXT} />,
tolerance: (p: FieldRenderProps) => <ToleranceField {...p} />,
enabled: (p: FieldRenderProps) => <EnabledField {...p} />,
enabled: (p: FieldRenderProps) => (
<TriState p={p} label={T.field.enabled} text={ENABLED_TEXT} setting={(v) => v.dual_check?.enabled} />
),
}
+6 -2
View File
@@ -10,7 +10,7 @@ import { NODE_DEFS, sourceHandles } from './nodeDefs'
import { DENSE_EXITS, NODE_WIDTH } from './routing'
import { LiveClock, stillClock, TeamMatrix, teamBrief, type TeamEnding } from './TeamMatrix'
import { edgeKey, topology } from '../run/derive'
import { exhaustedOf } from '../run/decode'
import { exhaustedOf, splitIssuanceGaps } from '../run/decode'
import { api } from '../api/client'
import { isComposing, StatusBadge, toast } from '../components/ui'
import { claimCountsOf, matchedSource } from '../lib/evidence'
@@ -898,10 +898,14 @@ function NodeCardImpl({ id, data, selected, isConnectable }: NodeProps<FlowNode>
const tier = view.at != null && issuedAt != null && view.at < issuedAt ? undefined : issuance?.tier
const tierClass = tier === 'formal' ? 'is-formal' : tier === 'degraded' ? 'is-degraded' : tier === 'withheld' ? 'is-withheld' : ''
const detail = issuanceDetail?.tier ? issuanceDetail : undefined
const gaps: string[] = Array.isArray(detail?.gaps) ? detail.gaps.map(String) : []
// 双盲复算、反方审稿报上来的缺口和「校验没跑全」分开说,再分查出了问题(两路不一致、结论被推翻)和没核成(无法复算)
const { failed: verifyFailed, unfinished: verifyUnfinished, other: gaps } =
splitIssuanceGaps(Array.isArray(detail?.gaps) ? detail.gaps.map(String) : [])
const stampTitle = tier ? [
`出具判定:${issuanceLabel(tier)}`,
detail ? `可追溯 ${detail.matched_numbers ?? 0} 个数字 / 核对 ${detail.metrics_checked ?? 0} 个指标` : '',
verifyFailed.length ? `${DUAL_CHECK_TEXT.verifyGaps.failed}:${verifyFailed.join(';')}` : '',
verifyUnfinished.length ? `${DUAL_CHECK_TEXT.verifyGaps.unfinished}:${verifyUnfinished.join(';')}` : '',
// 降档常常不是数字对不上,而是校验根本没跑全(叙述模板渲染为空、指标集为空):
// 不写出来,悬停在一个「降档出具」上看不到任何理由
gaps.length ? `校验未全部完成:${gaps.join(';')}` : '',
+132 -59
View File
@@ -1,19 +1,21 @@
import { useMemo } from 'react'
import type { Edge } from '@xyflow/react'
import { useEffect, useMemo, useState } from 'react'
import clsx from 'clsx'
import { api } from '../api/client'
import { useRadioGroup } from '../components/ui'
import { nodeTypeLabel } from '../lib/terms'
import { modelOptions, providerOfModel, useCatalog } from '../store/catalog'
import { useStudio, type FlowNode } from '../store/studio'
import type { NodeType } from '../types'
import { useStudio } from '../store/studio'
import type { NodeType, VerifySettings } from '../types'
import { fieldOfIssue } from './issues'
import type { FieldDef, FieldRenderProps } from './nodeDefs'
/**
* 核查类节点(反方审稿、双盲复算)检查器里的几样通用控件,nodeDefs 用下面的工厂函数拼进字段表:
* - nodePickField:从画布上挑本节点上游的某一类节点(要审的报告、要复算的口径卡),留空按缺省取上游的那一个;
* - triStateField:跟随设置 / 开启 / 关闭三态(配置里没有这一项、true、false);
* - verifyModelFields:核查模型的接入加模型,写法同结论句裁判的模型选择。
* 核查类节点(反方审稿、双盲复算)检查器里的几样通用控件,两个节点共用这一份(期 3 两个工作包各写过一份,期 4 合并):
* - NodePick / nodePickField:从画布上挑本节点上游的某一类节点(要审的报告、要复算的口径卡),留空按缺省取上游的那一个;
* - TriState / triStateField:跟随设置 / 开启 / 关闭三态(配置里没有这一项、true、false);
* - ProviderPick、ModelInput / verifyModelFields:核查模型的接入加模型,写法同结论句裁判的模型选择;
* - useVerifyDefaults:设置里「核查」一组的当前值(「跟随设置」后面写出现在是多少)。
* 双盲复算特有的(选指标、口径说明、相对误差)留在 DualCheckFields.tsx。
*
* 文案一律由调用方传进来(各节点自己那一块的 *_TEXT),控件里不写死任何一句话:两个节点说法不同(反方模型 / 盲算模型),
* 控件是同一个。读画布节点用 studio store,不往 FieldRenderProps 里加字段。
@@ -22,6 +24,10 @@ import type { FieldDef, FieldRenderProps } from './nodeDefs'
* 再画一句就是同一件事说两遍(同结论句裁判「校验也会报,报了就不重复说」)。校验没回来、校验失败时照画。
*/
/** 画布上的节点、连线只用得到这几项:检查器给的是 FlowNode / Edge,节点卡片的摘要给的是 NodeSummaryContext 里的 */
export interface CanvasNode { id: string; data: { nodeType: NodeType; label?: string; config?: Record<string, any> } }
export interface CanvasEdge { source: string; target: string }
/**
* 画布校验在这个节点的这一项上报了问题没有。认法和 Inspector 把问题挂到字段下面时一样(fieldOfIssue),
* 两边说的「这一项有问题」不会对不上
@@ -34,13 +40,13 @@ function useReported(nodeId: string, key: string): boolean {
}
/** 节点在下拉里的叫法:名字和 id 不同时把 id 带上(同 NodeRefsInput) */
function nodeLabel(n: FlowNode): string {
function nodeLabel(n: CanvasNode): string {
const label = String(n.data?.label || n.id)
return label === n.id ? label : `${label}(${n.id})`
}
/** 本节点的全部上游(沿连线往回找)。只认上游:下游的节点运行到这里时还没有产出 */
function upstreamOf(nodeId: string, edges: Edge[]): Set<string> {
/** 某个节点的全部上游(沿连线往回找),不含它自己。只认上游:下游的节点运行到这里时还没有产出 */
export function upstreamOf(nodeId: string, edges: readonly CanvasEdge[]): Set<string> {
const parents = new Map<string, string[]>()
for (const e of edges) parents.set(e.target, [...(parents.get(e.target) ?? []), e.source])
const seen = new Set<string>()
@@ -66,17 +72,17 @@ export type PickRule = 'upstream' | 'direct'
* 配置里那一项按服务端的认法落到哪个节点上:target 是定下来的那一个;其余几种是定不下来的原因——写了的节点不存在、
* 不是这一类、不在上游(先后同服务端),留空时上游一个都没有、不止一个
*/
export type PickState =
| { kind: 'target'; node: FlowNode }
export type PickState<N extends CanvasNode = CanvasNode> =
| { kind: 'target'; node: N }
| { kind: 'missing' }
| { kind: 'wrongType'; node: FlowNode }
| { kind: 'notUpstream'; node: FlowNode }
| { kind: 'wrongType'; node: N }
| { kind: 'notUpstream'; node: N }
| { kind: 'none' }
| { kind: 'many'; count: number }
export function resolvePick(
nodeId: string, chosen: unknown, type: NodeType, rule: PickRule, nodes: FlowNode[], edges: Edge[],
): PickState {
export function resolvePick<N extends CanvasNode>(
nodeId: string, chosen: unknown, type: NodeType, rule: PickRule, nodes: readonly N[], edges: readonly CanvasEdge[],
): PickState<N> {
const up = upstreamOf(nodeId, edges)
if (typeof chosen === 'string' && chosen) {
const node = nodes.find((n) => n.id === chosen)
@@ -95,20 +101,48 @@ export function resolvePick(
}
/** 这个节点实际要核查的是哪一个;定不下来(服务端这时报错、不核查)时返回 undefined */
export function targetNode(
nodeId: string, chosen: unknown, type: NodeType, rule: PickRule, nodes: FlowNode[], edges: Edge[],
): FlowNode | undefined {
export function targetNode<N extends CanvasNode>(
nodeId: string, chosen: unknown, type: NodeType, rule: PickRule, nodes: readonly N[], edges: readonly CanvasEdge[],
): N | undefined {
const pick = resolvePick(nodeId, chosen, type, rule, nodes, edges)
return pick.kind === 'target' ? pick.node : undefined
}
// ---------------------------------------------------------------- 设置里的核查一组
/**
* 设置里核查一组的值:「跟随设置」后面写出现在是开是关、相对误差的占位写出现在是多少。每次打开检查器都重取一次——去
* 设置页关掉双盲复算、改了误差再回到画布,这里得是新值(不同于检查器的运行默认值,核查开关是常改的)。先用上次取到的
* 画,免得闪一下;同一次打开里的几个字段共用一个请求;取不到就沿用上次的(没有就不写),不挡编辑
*/
let verifyPending: Promise<VerifySettings | null> | null = null
let verifyValue: VerifySettings | null | undefined
function fetchVerify(): Promise<VerifySettings | null> {
verifyPending ??= api.settings.get().then(
(s) => (verifyValue = s?.verify && typeof s.verify === 'object' ? s.verify as VerifySettings : null),
() => verifyValue ?? null,
).finally(() => { verifyPending = null })
return verifyPending
}
export function useVerifyDefaults(active = true): VerifySettings | null {
const [value, setValue] = useState<VerifySettings | null>(verifyValue ?? null)
useEffect(() => {
// 用不上设置的控件(反方审稿的启用不写当前值)不取,打开检查器不多发一个请求
if (!active) return
let alive = true
void fetchVerify().then((v) => { if (alive) setValue(v) })
return () => { alive = false }
}, [active])
return value
}
// ---------------------------------------------------------------- 选画布上的节点
export interface NodePickText {
/** 留空那一项:按缺省能认出是哪一个时给出它的名字 */
auto: (only: string | null) => string
/** 上游一个都没有 */
none: string
/** 留空那一项:按缺省能认出是哪一个时给出它的名字;count 是上游这一类节点有几个 */
auto: (only: string | null, count: number) => string
/** 上游一个都没有时下面那句提示;不给就不提示(留空那一项已经说了) */
none?: string
/** 上游不止一个、又没有选 */
many: (n: number) => string
/** 选中的节点已不在画布上(下拉里那一项的叫法) */
@@ -121,45 +155,69 @@ export interface NodePickText {
notUpstreamHint: string
/** type 是选中节点的类型名(「输入」) */
wrongTypeHint: (type: string) => string
/**
* 下拉里把上游的和画布上其余同类节点分两组列时,两组的标题(双盲复算的口径卡:选了不在上游的,提示把它连到上游)。
* 不给时只列上游的
*/
groups?: { upstream: string; other: string }
}
function NodePick({ p, fieldKey, nodeType, rule, text }: {
p: FieldRenderProps; fieldKey: string; nodeType: NodeType; rule: PickRule; text: NodePickText
}) {
export interface NodePickOptions {
fieldKey: string
nodeType: NodeType
rule: PickRule
text: NodePickText
/** 下拉里一个节点的叫法,缺省是「名字(id)」 */
optionLabel?: (n: CanvasNode) => string
/** 留空那一项里,按缺省认出的那一个的名字,缺省是节点名(没起名的用 id) */
nameOf?: (n: CanvasNode) => string
}
const nodeName = (n: CanvasNode): string => String(n.data?.label || n.id)
export function NodePick({ p, fieldKey, nodeType, rule, text, optionLabel = nodeLabel, nameOf = nodeName }: NodePickOptions & { p: FieldRenderProps }) {
const nodes = useStudio((s) => s.nodes)
const edges = useStudio((s) => s.edges)
const reported = useReported(p.nodeId, fieldKey)
const value = typeof p.value === 'string' ? p.value : ''
const options = useMemo(() => {
const { upstream, other } = useMemo(() => {
const up = upstreamOf(p.nodeId, edges)
return nodes.filter((n) => up.has(n.id) && n.data?.nodeType === nodeType)
const same = nodes.filter((n) => n.data?.nodeType === nodeType)
return { upstream: same.filter((n) => up.has(n.id)), other: same.filter((n) => !up.has(n.id) && n.id !== p.nodeId) }
}, [nodes, edges, p.nodeId, nodeType])
const pick = useMemo(
() => resolvePick(p.nodeId, value, nodeType, rule, nodes, edges), [p.nodeId, value, nodeType, rule, nodes, edges],
)
// 选中的节点被删了、不是这一类、挪到了下游:下拉里照实多列一项(选不回去),不让它看着像「未选择」。
// 校验已经报了的,这一项照样列(看得出选的是什么),只是下面那句提示不再说
const stale = pick.kind === 'missing' || pick.kind === 'wrongType' || pick.kind === 'notUpstream' ? pick : null
// 分组列出画布上其余同类节点时,不在上游的那个本来就在「其余」一组里,不再另列。校验已经报了的,这一项照样列
// (看得出选的是什么),只是下面那句提示不再说
const stale = pick.kind === 'missing' || pick.kind === 'wrongType' || (pick.kind === 'notUpstream' && !text.groups) ? pick : null
const hint = reported ? ''
: pick.kind === 'missing' ? text.missingHint
: pick.kind === 'wrongType' ? text.wrongTypeHint(nodeTypeLabel(pick.node.data?.nodeType))
: pick.kind === 'notUpstream' ? text.notUpstreamHint
: pick.kind === 'none' ? text.none
: pick.kind === 'none' ? text.none ?? ''
: pick.kind === 'many' ? text.many(pick.count) : ''
const hintId = `${p.id}-hint`
const only = !value && pick.kind === 'target' ? String(pick.node.data?.label || pick.node.id) : null
const only = !value && pick.kind === 'target' ? nameOf(pick.node) : null
const option = (n: CanvasNode) => <option key={n.id} value={n.id}>{optionLabel(n)}</option>
return (
<>
<select id={p.id} className="field" value={value} disabled={p.disabled} aria-invalid={p.invalid || undefined}
aria-describedby={[p.describedBy, hint ? hintId : ''].filter(Boolean).join(' ') || undefined}
style={p.invalid || stale ? { borderColor: p.invalid ? 'var(--err)' : 'var(--warn)' } : undefined}
onChange={(e) => p.onChange(e.target.value || undefined)}>
<option value="">{text.auto(only)}</option>
{options.map((n) => <option key={n.id} value={n.id}>{nodeLabel(n)}</option>)}
<option value="">{text.auto(only, upstream.length)}</option>
{text.groups ? (
<>
{upstream.length > 0 && <optgroup label={text.groups.upstream}>{upstream.map(option)}</optgroup>}
{other.length > 0 && <optgroup label={text.groups.other}>{other.map(option)}</optgroup>}
</>
) : upstream.map(option)}
{stale && (
<option value={value} disabled>
{stale.kind === 'missing' ? text.missing(value)
: stale.kind === 'wrongType' ? text.wrongType(nodeLabel(stale.node)) : text.notUpstream(nodeLabel(stale.node))}
: stale.kind === 'wrongType' ? text.wrongType(optionLabel(stale.node)) : text.notUpstream(optionLabel(stale.node))}
</option>
)}
</select>
@@ -177,10 +235,12 @@ function NodePick({ p, fieldKey, nodeType, rule, text }: {
*/
export function nodePickField(def: {
key: string; label: string; nodeType: NodeType; rule?: PickRule; text: NodePickText; help?: string; advanced?: boolean
optionLabel?: (n: CanvasNode) => string
}): FieldDef {
return {
key: def.key, label: def.label, type: 'select', help: def.help, advanced: def.advanced,
render: (p) => <NodePick p={p} fieldKey={def.key} nodeType={def.nodeType} rule={def.rule ?? 'upstream'} text={def.text} />,
render: (p) => <NodePick p={p} fieldKey={def.key} nodeType={def.nodeType} rule={def.rule ?? 'upstream'} text={def.text}
optionLabel={def.optionLabel} />,
}
}
@@ -190,43 +250,56 @@ export interface TriStateText {
follow: string
on: string
off: string
/** 选中各态时下面那句说明:跟随的是哪一项设置、关掉之后会怎样 */
hint: { follow: string; on: string; off: string }
/** 「跟随设置」那一项附上设置里现在是开是关(设置还没取到时 on 为 null / undefined)。不给就只写 follow */
followNow?: (on: boolean | null | undefined) => string
/** 选中各态时下面那句说明:跟随的是哪一项设置、关掉之后会怎样。不给就不写(说明在字段的帮助里) */
hint?: { follow: string; on: string; off: string }
}
type Tri = 'follow' | 'on' | 'off'
const TRI: readonly Tri[] = ['follow', 'on', 'off']
function TriState({ p, label, text }: { p: FieldRenderProps; label: string; text: TriStateText }) {
export function TriState({ p, label, text, setting }: {
p: FieldRenderProps; label: string; text: TriStateText
/** 从设置的核查一组里取这一项现在的开关:给了才在「跟随设置」后面写出来 */
setting?: (v: VerifySettings) => boolean | null | undefined
}) {
// 只认真正的布尔:手写的 "false"、0 不当成关闭,按跟随设置显示(服务端校验会报出来)
const state: Tri = p.value === true ? 'on' : p.value === false ? 'off' : 'follow'
// 跟随设置写回 undefined:配置里不留这一项,和没配过的节点一样
const set = (t: Tri) => p.onChange(t === 'on' ? true : t === 'off' ? false : undefined)
const radio = useRadioGroup(TRI, state, set)
const settings = useVerifyDefaults(!!setting)
const now = setting && settings ? setting(settings) : undefined
const hintId = `${p.id}-hint`
return (
<>
{/* 字段标签的 for 指不到一组按钮,组名另写在 aria-label 上 */}
<div id={p.id} role="radiogroup" aria-label={label} data-tri-state={state}
aria-describedby={[hintId, p.describedBy].filter(Boolean).join(' ')}
className="inline-flex max-w-full flex-wrap rounded-md border p-px">
aria-describedby={[text.hint ? hintId : '', p.describedBy].filter(Boolean).join(' ') || undefined}
className="inline-flex max-w-full flex-wrap gap-0.5 rounded-md border p-0.5">
{TRI.map((t) => (
<button key={t} type="button" {...radio(t)} disabled={p.disabled} data-tri={t} onClick={() => set(t)}
className={clsx('rounded px-2 py-0.5 text-2xs', state === t ? 'bg-accent-soft text-fg' : 'text-faint hover:text-dim')}>
{text[t]}
// 不折行:「跟随设置(当前开启)」比「开启」长得多,太窄时整段换到下一行
className={clsx('whitespace-nowrap rounded px-2 py-0.5 text-2xs transition-colors',
state === t ? 'bg-accent-soft font-medium text-fg' : 'text-dim hover:bg-hover')}>
{t === 'follow' && text.followNow ? text.followNow(now) : text[t]}
</button>
))}
</div>
<div id={hintId} className="mt-1 text-2xs leading-snug text-faint" data-tri-hint={state}>{text.hint[state]}</div>
{text.hint && <div id={hintId} className="mt-1 text-2xs leading-snug text-faint" data-tri-hint={state}>{text.hint[state]}</div>}
</>
)
}
/** 跟随设置 / 开启 / 关闭:配置里没有这一项(或 null)/ true / false */
export function triStateField(def: { key: string; label: string; text: TriStateText; advanced?: boolean }): FieldDef {
export function triStateField(def: {
key: string; label: string; text: TriStateText; advanced?: boolean; help?: string
setting?: (v: VerifySettings) => boolean | null | undefined
}): FieldDef {
return {
key: def.key, label: def.label, type: 'select', advanced: def.advanced,
render: (p) => <TriState p={p} label={def.label} text={def.text} />,
key: def.key, label: def.label, type: 'select', advanced: def.advanced, help: def.help,
render: (p) => <TriState p={p} label={def.label} text={def.text} setting={def.setting} />,
}
}
@@ -243,17 +316,17 @@ export interface VerifyModelText {
/** 模型框的占位:接入也没选 / 选了接入 */
modelFollow: string
modelDefault: string
/** 取值链的说明,常显在模型框下面 */
help: string
/** 取值链的说明,常显在模型框下面。不给就不写(说明在字段的帮助里) */
help?: string
byModel: (model: string, found: { name: string; enabled: boolean } | null | undefined, fallback: string | null | undefined) => string
/** 和被核查的模型是同一个 */
same: (model: string) => string
/** 和被核查的模型是同一个(给了 subject 时用) */
same?: (model: string) => string
}
/** 被核查的那个模型:节点上明确写着的模型名;说不准(没写、跟随默认)时为 null,不提醒 */
export type SubjectModel = (nodeId: string, config: Record<string, any>, graph: { nodes: FlowNode[]; edges: Edge[] }) => string | null
export type SubjectModel = (nodeId: string, config: Record<string, any>, graph: { nodes: readonly CanvasNode[]; edges: readonly CanvasEdge[] }) => string | null
function ProviderPick({ p, text }: { p: FieldRenderProps; text: VerifyModelText }) {
export function ProviderPick({ p, text }: { p: FieldRenderProps; text: VerifyModelText }) {
const providers = useCatalog((s) => s.providers)
const provider = typeof p.value === 'string' ? p.value : ''
const model = typeof p.config.model === 'string' ? p.config.model.trim() : ''
@@ -272,7 +345,7 @@ function ProviderPick({ p, text }: { p: FieldRenderProps; text: VerifyModelText
)
}
function ModelInput({ p, fieldKey, text, subject }: {
export function ModelInput({ p, fieldKey, text, subject }: {
p: FieldRenderProps; fieldKey: string; text: VerifyModelText; subject?: SubjectModel
}) {
const providers = useCatalog((s) => s.providers)
@@ -292,7 +365,7 @@ function ModelInput({ p, fieldKey, text, subject }: {
const fallback = enabled.find((x) => x.kind !== 'mock') ?? enabled[0]
const byModelHint = byModel && providers.length > 0
? text.byModel(name, owner && { name: owner.provider.name, enabled: owner.enabled }, fallback?.name) : ''
const same = !!name && !!against && name === against && !reported
const same = !!name && !!against && name === against && !reported && !!text.same
return (
<>
<input id={p.id} className="field mono text-xs" list={`${p.id}-models`} value={model} spellCheck={false}
@@ -309,10 +382,10 @@ function ModelInput({ p, fieldKey, text, subject }: {
)}
{same && (
<div className="mt-1 text-2xs leading-snug" style={{ color: 'var(--st-waiting)' }} data-verify-same-model="">
{text.same(name)}
{text.same!(name)}
</div>
)}
<div className="mt-1 text-2xs leading-snug text-faint">{text.help}</div>
{text.help && <div className="mt-1 text-2xs leading-snug text-faint">{text.help}</div>}
</>
)
}
+5 -1
View File
@@ -12,7 +12,11 @@
"exploreFlag": "run-chal-explore-flag",
"runfail": "run-chal-runfail",
"dup": "run-chal-dup",
"norecord": "run-chal-norecord"
"norecord": "run-chal-norecord",
"unreviewed": "run-chal-unreviewed",
"offpath": "run-chal-offpath",
"over": "run-chal-over",
"given": "run-chal-given"
},
"report": {
"node_id": "write",
+47 -5
View File
@@ -3,6 +3,7 @@ import { ReactFlow, ReactFlowProvider } from '@xyflow/react'
import { Inspector } from '../../canvas/Inspector'
import { NodeCard } from '../../canvas/NodeCard'
import { ApprovalCard } from '../../run/RunPanel'
import { ChallengeSummary } from '../../run/ChallengeSummary'
import { useCatalog } from '../../store/catalog'
import { useStudio } from '../../store/studio'
import type { Approval, ApprovalChallenge, ApprovalReport, Provider, Workflow } from '../../types'
@@ -22,7 +23,16 @@ import fx from './challenge.json'
* - ?syn=challenge-approval-dense:同第一个,摆在 360px 的右栏里
* - ?syn=challenge-approval-clear / -clear-flag:正式运行,没有被推翻的结论(降档 / 只标注),两种都不写降档、不写只标注
* - ?syn=challenge-approval-explore-flag:探索运行配只标注,同样不说任何和出具有关的话
* - ?syn=challenge-approval-runfail:运行类别取不到(检查脚本先答 500),说明并可重试
* - ?syn=challenge-approval-runfail:老服务端的审批(不带 run_class),运行类别也取不到(检查脚本先答 500):不说任何
* 和出具有关的话。审批带着运行类别时照它说、不另取,见 challenge-summary-given
* - ?syn=challenge-approval-unreviewed:正式运行,四句里有两句未能反查(unreviewed:被削弱、经受住的那两句换成数据源
* 已停用、记为无法判断,计数跟着改成无法判断 3 句;工件由检查脚本按同样的改法合成),被推翻的会降档(degrades)
* - ?syn=challenge-approval-unreviewed-over:服务端给的 unreviewed(5)比「无法判断」的句数(1)还多(不该出现):
* 卡上按「无法判断」的句数说,两个数不打架
* - ?syn=challenge-approval-offpath:正式运行,按降档处置,但反方审稿不在带出具契约的成果节点上游(degrades 为假)
* - ?syn=challenge-summary-given:反方审稿那一块单独画,审批自带的运行类别(正式运行)由调用方传进来;检查脚本让这次运行的
* GET 失败,卡上照样写「出具会降档」,也不另发这次请求。审批卡(RunPanel 的 ApprovalCard)把 approval.run_class
* 传给它之后,卡上走的就是这条路
* - ?syn=challenge-approval-dup:同 many,工件里补出来的一句和条目里的一句原文相同、unit 不同(工件由检查脚本合成)
* - ?syn=challenge-approval-norecord:同 many,审稿记录没存上(artifact 为 null)
*
@@ -37,12 +47,13 @@ import fx from './challenge.json'
const report = fx.report as unknown as ApprovalReport
const challenge = fx.challenge as unknown as ApprovalChallenge
function approvalOf(id: string, runId: string, runClass: 'formal' | 'exploratory', reviewed: ApprovalReport): Approval {
/** runClass 为 null:老服务端的审批,不带运行类别 */
function approvalOf(id: string, runId: string, runClass: 'formal' | 'exploratory' | null, reviewed: ApprovalReport): Approval {
return {
id, run_id: runId, node_id: 'review', mode: 'approve', title: '本月月报可以发出吗?', status: 'pending', response: {},
payload: { kind: 'human_node', message: '请审核本月月报。', reports: [reviewed] },
created_at: new Date(Date.now() - 300_000).toISOString().replace('Z', ''),
workflow_name: '月报', node_label: '主管审批', run_class: runClass,
workflow_name: '月报', node_label: '主管审批', ...(runClass ? { run_class: runClass } : {}),
}
}
@@ -57,13 +68,27 @@ function Card({ approval, name, dense = false }: { approval: Approval; name: str
}
const RUNS = fx.runs
const withChallenge = (c: Partial<ApprovalChallenge>): ApprovalReport => ({ ...report, challenge: { ...challenge, ...c } })
/** 期 4 起服务端另带的两项:unreviewed(没能反查的句数)、degrades(被推翻的会不会让出具降档) */
type Challenge = ApprovalChallenge & { unreviewed?: number; degrades?: boolean }
const withChallenge = (c: Partial<Challenge>): ApprovalReport => ({ ...report, challenge: { ...challenge, ...c } as ApprovalChallenge })
const many = fx.many as unknown as ApprovalChallenge
/** 没有被推翻的结论:同第一个用例去掉被推翻的那句,计数跟着改 */
const clear: Partial<ApprovalChallenge> = {
counts: { stands: 1, weakened: 1, refuted: 0, inconclusive: 1 },
items: challenge.items.filter((it) => it.verdict !== 'refuted'),
}
/**
* 有两句未能反查:被削弱(u5)、经受住(u8)的那两句换成数据源已停用、没查成,记为无法判断(服务端未能反查的每一句都
* 记为无法判断,unreviewed 不会多于 inconclusive)。原来无法判断的 u11 是查过了、数据不够,不算未能反查
*/
const UNREVIEWED_UNITS = ['u5', 'u8']
const unreviewed: Partial<Challenge> = {
counts: { stands: 0, weakened: 0, refuted: 1, inconclusive: 3 },
items: challenge.items.map((it) => (UNREVIEWED_UNITS.includes(it.unit) ? { ...it, verdict: 'inconclusive' } : it)),
artifact: 'f'.repeat(64),
unreviewed: 2,
degrades: true,
}
// ---------------------------------------------------------------- 检查器
@@ -197,7 +222,7 @@ export const cases: Record<string, () => JSX.Element> = {
approval={approvalOf('ap-chal-10', RUNS.exploreFlag, 'exploratory', withChallenge({ on_refuted: 'flag' }))} />
),
'challenge-approval-runfail': () => (
<Card name="challenge-approval-runfail" approval={approvalOf('ap-chal-11', RUNS.runfail, 'formal', withChallenge({}))} />
<Card name="challenge-approval-runfail" approval={approvalOf('ap-chal-11', RUNS.runfail, null, withChallenge({}))} />
),
'challenge-approval-dup': () => (
<Card name="challenge-approval-dup"
@@ -207,6 +232,23 @@ export const cases: Record<string, () => JSX.Element> = {
<Card name="challenge-approval-norecord"
approval={approvalOf('ap-chal-13', RUNS.norecord, 'formal', { ...report, challenge: { ...many, artifact: null } })} />
),
'challenge-approval-unreviewed': () => (
<Card name="challenge-approval-unreviewed"
approval={approvalOf('ap-chal-14', RUNS.unreviewed, 'formal', withChallenge(unreviewed))} />
),
'challenge-approval-unreviewed-over': () => (
<Card name="challenge-approval-unreviewed-over"
approval={approvalOf('ap-chal-16', RUNS.over, 'formal', withChallenge({ unreviewed: 5, degrades: true }))} />
),
'challenge-summary-given': () => (
<div className="mx-auto max-w-3xl p-4" data-fixture="challenge-summary-given">
<ChallengeSummary reports={[withChallenge({ degrades: true })]} runId={RUNS.given} runClass="formal" />
</div>
),
'challenge-approval-offpath': () => (
<Card name="challenge-approval-offpath"
approval={approvalOf('ap-chal-15', RUNS.offpath, 'formal', withChallenge({ on_refuted: 'degrade', degrades: false, unreviewed: 0 }))} />
),
'challenge-inspector': () => <InspectorCase name="challenge-inspector" workflow={WORKFLOW} />,
'challenge-inspector-chain': () => <InspectorCase name="challenge-inspector-chain" workflow={CHAIN} />,
}
+860 -4
View File
@@ -1,5 +1,5 @@
{
"_note": "双盲复算的预览用例和 scripts/check-verify.mjs 共用的夹具。表名、数字都是虚构的通用示例,不来自任何真实数据。各处的 diff(差异说明)是服务端 explain_sql_diff 对同一对 SQL 的真实输出(方言 sqlite),catalog_preview 和 variants、peers 里的 catalog(采用哪一边会往数据目录里写什么)是服务端写目录预告的真实输出,都由 backend/tests/test_dual_check_fixture.py 核对和重新生成,不要手改;merges 里的 written 是服务端按那几种选择真写一遍(record_choices)的结果,同一个测试核对,它要建临时数据源才算得出,不重新生成,报不一致时照报出的实际结果改。variants 是另几对 SQL 及其差异说明,检查脚本拿来换掉「销售额」那个指标,看不同的差异下卡上怎么说;peers 换掉「退款率」对不上的那个输入,和「销售额」落到数据目录的同一项上,merges 是检查脚本看的几种组合(同一次裁决里几个指标说法不同、要合写时卡上怎么说)",
"_note": "双盲复算的预览用例和 scripts/check-verify.mjs 共用的夹具。表名、数字都是虚构的通用示例,不来自任何真实数据。各处的 diff(差异说明)是服务端 explain_sql_diff 对同一对 SQL 的真实输出(方言 sqlite),catalog_preview 和 variants、peers 里的 catalog(采用哪一边会往数据目录里写什么)、catalog_blocked(目录里已有人工确认的业务日期时「销售额」的预告)、merges 里的 catalog 和 joint(几个指标落到同一项上时服务端算好的合并预告)是服务端写目录预告的真实输出,都由 backend/tests/test_dual_check_fixture.py 核对和重新生成,不要手改;merges 里的 written 是服务端按那几种选择真写一遍(record_choices)的结果,同一个测试核对,它要建临时数据源才算得出,不重新生成,报不一致时照报出的实际结果改。variants 是另几对 SQL 及其差异说明,检查脚本拿来换掉「销售额」那个指标,看不同的差异下卡上怎么说;peers 换掉「退款率」对不上的那个输入,和「销售额」落到数据目录的同一项上,merges 是检查脚本看的几种组合(notes 是那一组合发起审批时的目录,不写就是空目录)。card 里「销售额」盲算一边的 rationale_doc 是核查 agent 组装理由文档的真实输出(evidence.compose_doc,含一个没有出处的数字),「退款率」的几个输入没有这一项(同老工件)",
"approval": {
"id": "ap-dc-0001",
"run_id": "run-dc-0001",
@@ -76,7 +76,164 @@
"sql": "SELECT SUM(amount) AS gmv\nFROM orders\nWHERE created_at >= '2026-09-01'\n AND created_at < '2026-09-08'",
"source": "shop",
"alias": "B1",
"rationale": "销售额按下单时间统计本周全部订单金额之和"
"rationale": "销售额按下单时间 created_at 归属到当周,本周全部订单金额之和是 51,388.3,比上周多 1200。",
"rationale_doc": {
"schema": "agentlab.report/1",
"entity_syntax": 2,
"provenance": 1,
"run_id": "run-dc-0001",
"node_id": "dc",
"markdown": "销售额按下单时间 created_at 归属到当周,本周全部订单金额之和是 51,388.3,比上周多 1200。",
"source": "销售额按下单时间 created_at 归属到当周,本周全部订单金额之和是 [[v:Q1.r0.gmv]],比上周多 1200。[[see:Q1]]",
"catalog": {
"Q1": {
"alias": "Q1",
"kind": "query",
"eid": "ev:query:b615a51b194e1ba1",
"locator": {},
"node_id": "dc",
"exec": 1,
"artifact": "72a1a5e4698968eb90c3af92928aed35ea4e302a88607b7ead29022cb33bb867",
"call_id": "blind-1",
"tool": "db_query__shop",
"source": "shop",
"columns": [
"gmv"
],
"rows": 1,
"truncated": false,
"label": "db_query__shop · 1 行"
}
},
"blocks": [
{
"type": "paragraph",
"units": [
{
"id": "u0",
"kind": "claim",
"span": [
0,
57
],
"cites": [
"Q1"
],
"see": [
{
"ref": "Q1",
"role": "support",
"alias": "Q1",
"kind": "query",
"status": "resolved",
"eid": "ev:query:b615a51b194e1ba1",
"locator": {}
}
],
"segments": [
{
"kind": "text",
"text": "销售额按下单时间 created_at 归属到当周,本周全部订单金额之和是 ",
"state": "neutral",
"span": [
0,
38
],
"id": "s0"
},
{
"kind": "number",
"text": "51,388.3",
"ref": "v:Q1.r0.gmv",
"cite": {
"ref": "Q1.r0.gmv",
"alias": "Q1",
"locator": {
"row": 0,
"column": "gmv"
},
"eid": "ev:cell:5a48378137ed04ed",
"kind": "cell",
"role": "value",
"status": "resolved",
"value": 51388.3,
"rendered": "51,388.3"
},
"state": "deterministic",
"span": [
38,
46
],
"id": "s1"
},
{
"kind": "text",
"text": ",比上周多 ",
"span": [
46,
52
],
"state": "neutral",
"id": "s2"
},
{
"kind": "number",
"text": "1200",
"span": [
52,
56
],
"state": "none",
"issue": "uncited_number",
"id": "s3"
},
{
"kind": "text",
"text": "。",
"span": [
56,
57
],
"state": "neutral",
"id": "s4"
}
]
}
],
"id": "b0"
}
],
"stats": {
"units": 1,
"segments": 5,
"claims": 1,
"connective": 0,
"headings": 0,
"numbers": 2,
"numbers_cited": 1,
"values": 0,
"uncited_numbers": 1,
"unresolved": 0,
"see": 1,
"uncited_claims": 0,
"violations": 1
},
"violations": [
{
"code": "uncited_number",
"message": "数字「1200」没有出处:报告中直接写出了数字,系统无法核对",
"for_model": "数字「1200」没有出处:要写成引用标记(比如 [[m:指标id]]),不能直接写数字",
"span": [
52,
56
],
"text": "1200",
"context": "之和是 51,388.3,比上周多 1200。",
"segment": "s3",
"unit": "u0"
}
]
}
}
]
},
@@ -778,7 +935,159 @@
"gmv": "a",
"refund_rate": "b"
},
"written": []
"written": [],
"catalog": {
"gmv": {
"a": {
"write": true,
"source": "shop",
"table": "orders",
"item": "business_date",
"value": {
"column": "paid_at"
}
},
"b": {
"write": true,
"source": "shop",
"table": "orders",
"item": "business_date",
"value": {
"column": "created_at"
}
}
},
"refund_rate": {
"a": {
"write": true,
"source": "shop",
"table": "orders",
"item": "business_date",
"value": {
"column": "paid_at"
}
},
"b": {
"write": true,
"source": "shop",
"table": "orders",
"item": "business_date",
"value": {
"column": "created_at"
}
}
}
},
"joint": [
{
"source": "shop",
"table": "orders",
"item": "business_date",
"members": [
{
"metric_id": "gmv",
"choice": "a"
},
{
"metric_id": "refund_rate",
"choice": "a"
}
],
"outcomes": {
"gmv": {
"write": true,
"value": {
"column": "paid_at"
}
},
"refund_rate": {
"write": true,
"value": {
"column": "paid_at"
}
}
}
},
{
"source": "shop",
"table": "orders",
"item": "business_date",
"members": [
{
"metric_id": "gmv",
"choice": "a"
},
{
"metric_id": "refund_rate",
"choice": "b"
}
],
"outcomes": {
"gmv": {
"write": false,
"reason": "同一次裁决里对「orders」的业务日期给出了不同的说法(指标「销售额」采纳的是「paid_at」;指标「退款率」采纳的是「created_at」),无法确定哪一个是数据事实,都未写入数据目录"
},
"refund_rate": {
"write": false,
"reason": "同一次裁决里对「orders」的业务日期给出了不同的说法(指标「销售额」采纳的是「paid_at」;指标「退款率」采纳的是「created_at」),无法确定哪一个是数据事实,都未写入数据目录"
}
}
},
{
"source": "shop",
"table": "orders",
"item": "business_date",
"members": [
{
"metric_id": "gmv",
"choice": "b"
},
{
"metric_id": "refund_rate",
"choice": "a"
}
],
"outcomes": {
"gmv": {
"write": false,
"reason": "同一次裁决里对「orders」的业务日期给出了不同的说法(指标「销售额」采纳的是「created_at」;指标「退款率」采纳的是「paid_at」),无法确定哪一个是数据事实,都未写入数据目录"
},
"refund_rate": {
"write": false,
"reason": "同一次裁决里对「orders」的业务日期给出了不同的说法(指标「销售额」采纳的是「created_at」;指标「退款率」采纳的是「paid_at」),无法确定哪一个是数据事实,都未写入数据目录"
}
}
},
{
"source": "shop",
"table": "orders",
"item": "business_date",
"members": [
{
"metric_id": "gmv",
"choice": "b"
},
{
"metric_id": "refund_rate",
"choice": "b"
}
],
"outcomes": {
"gmv": {
"write": true,
"value": {
"column": "created_at"
}
},
"refund_rate": {
"write": true,
"value": {
"column": "created_at"
}
}
}
}
]
},
"time_same": {
"gmv": null,
@@ -795,6 +1104,158 @@
"column": "paid_at"
}
}
],
"catalog": {
"gmv": {
"a": {
"write": true,
"source": "shop",
"table": "orders",
"item": "business_date",
"value": {
"column": "paid_at"
}
},
"b": {
"write": true,
"source": "shop",
"table": "orders",
"item": "business_date",
"value": {
"column": "created_at"
}
}
},
"refund_rate": {
"a": {
"write": true,
"source": "shop",
"table": "orders",
"item": "business_date",
"value": {
"column": "paid_at"
}
},
"b": {
"write": true,
"source": "shop",
"table": "orders",
"item": "business_date",
"value": {
"column": "created_at"
}
}
}
},
"joint": [
{
"source": "shop",
"table": "orders",
"item": "business_date",
"members": [
{
"metric_id": "gmv",
"choice": "a"
},
{
"metric_id": "refund_rate",
"choice": "a"
}
],
"outcomes": {
"gmv": {
"write": true,
"value": {
"column": "paid_at"
}
},
"refund_rate": {
"write": true,
"value": {
"column": "paid_at"
}
}
}
},
{
"source": "shop",
"table": "orders",
"item": "business_date",
"members": [
{
"metric_id": "gmv",
"choice": "a"
},
{
"metric_id": "refund_rate",
"choice": "b"
}
],
"outcomes": {
"gmv": {
"write": false,
"reason": "同一次裁决里对「orders」的业务日期给出了不同的说法(指标「销售额」采纳的是「paid_at」;指标「退款率」采纳的是「created_at」),无法确定哪一个是数据事实,都未写入数据目录"
},
"refund_rate": {
"write": false,
"reason": "同一次裁决里对「orders」的业务日期给出了不同的说法(指标「销售额」采纳的是「paid_at」;指标「退款率」采纳的是「created_at」),无法确定哪一个是数据事实,都未写入数据目录"
}
}
},
{
"source": "shop",
"table": "orders",
"item": "business_date",
"members": [
{
"metric_id": "gmv",
"choice": "b"
},
{
"metric_id": "refund_rate",
"choice": "a"
}
],
"outcomes": {
"gmv": {
"write": false,
"reason": "同一次裁决里对「orders」的业务日期给出了不同的说法(指标「销售额」采纳的是「created_at」;指标「退款率」采纳的是「paid_at」),无法确定哪一个是数据事实,都未写入数据目录"
},
"refund_rate": {
"write": false,
"reason": "同一次裁决里对「orders」的业务日期给出了不同的说法(指标「销售额」采纳的是「created_at」;指标「退款率」采纳的是「paid_at」),无法确定哪一个是数据事实,都未写入数据目录"
}
}
},
{
"source": "shop",
"table": "orders",
"item": "business_date",
"members": [
{
"metric_id": "gmv",
"choice": "b"
},
{
"metric_id": "refund_rate",
"choice": "b"
}
],
"outcomes": {
"gmv": {
"write": true,
"value": {
"column": "created_at"
}
},
"refund_rate": {
"write": true,
"value": {
"column": "created_at"
}
}
}
}
]
},
"dedup_columns": {
@@ -804,7 +1265,62 @@
"gmv": "a",
"refund_rate": "a"
},
"written": []
"written": [],
"catalog": {
"gmv": {
"a": {
"write": true,
"source": "shop",
"table": "orders",
"item": "dedup",
"value": "对 user_id 计数时去重"
},
"b": {
"write": false,
"reason": "指标「销售额」被采纳的盲算没有去重:不去重是这个指标自己的算法,不是表的去重规则,不写入数据目录"
}
},
"refund_rate": {
"a": {
"write": true,
"source": "shop",
"table": "orders",
"item": "dedup",
"value": "对 id 计数时去重"
},
"b": {
"write": false,
"reason": "指标「退款率」被采纳的盲算没有去重:不去重是这个指标自己的算法,不是表的去重规则,不写入数据目录"
}
}
},
"joint": [
{
"source": "shop",
"table": "orders",
"item": "dedup",
"members": [
{
"metric_id": "gmv",
"choice": "a"
},
{
"metric_id": "refund_rate",
"choice": "a"
}
],
"outcomes": {
"gmv": {
"write": false,
"reason": "同一次裁决里对「orders」的去重规则给出了不同的说法(指标「销售额」采纳的是「对 user_id 计数时去重」;指标「退款率」采纳的是「对 id 计数时去重」),无法确定哪一个是数据事实,都未写入数据目录"
},
"refund_rate": {
"write": false,
"reason": "同一次裁决里对「orders」的去重规则给出了不同的说法(指标「销售额」采纳的是「对 user_id 计数时去重」;指标「退款率」采纳的是「对 id 计数时去重」),无法确定哪一个是数据事实,都未写入数据目录"
}
}
}
]
},
"filters": {
"gmv": "filter_extra",
@@ -819,7 +1335,347 @@
"item": "valid_filter",
"value": "status <> 'test' AND status <> 'cancelled'"
}
],
"catalog": {
"gmv": {
"a": {
"write": true,
"source": "shop",
"table": "orders",
"item": "valid_filter",
"value": "status <> 'test'"
},
"b": {
"write": false,
"reason": "指标「销售额」多出筛选条件的是原流程,被采纳的盲算没有这个条件,不写入数据目录"
}
},
"refund_rate": {
"a": {
"write": true,
"source": "shop",
"table": "orders",
"item": "valid_filter",
"value": "status <> 'cancelled'"
},
"b": {
"write": false,
"reason": "指标「退款率」多出筛选条件的是原流程,被采纳的盲算没有这个条件,不写入数据目录"
}
}
},
"joint": [
{
"source": "shop",
"table": "orders",
"item": "valid_filter",
"members": [
{
"metric_id": "gmv",
"choice": "a"
},
{
"metric_id": "refund_rate",
"choice": "a"
}
],
"outcomes": {
"gmv": {
"write": true,
"value": "status <> 'test' AND status <> 'cancelled'"
},
"refund_rate": {
"write": true,
"value": "status <> 'test' AND status <> 'cancelled'"
}
}
}
]
},
"filters_rejected": {
"gmv": "filter_extra",
"refund_rate": "filter",
"choices": {
"gmv": "a",
"refund_rate": "a"
},
"notes": {
"orders": {
"valid_filter": {
"value": "status <> 'test'",
"source": "llm",
"status": "rejected"
}
}
},
"written": [
{
"table": "orders",
"item": "valid_filter",
"value": "status <> 'cancelled'"
}
],
"catalog": {
"gmv": {
"a": {
"write": false,
"source": "shop",
"table": "orders",
"item": "valid_filter",
"value": "status <> 'test'",
"reason": "「orders」的有效记录条件「status <> 'test'」曾被人工驳回,与这次指标「销售额」的选择相反,未写入。如需更改,请到数据目录中修改"
},
"b": {
"write": false,
"reason": "指标「销售额」多出筛选条件的是原流程,被采纳的盲算没有这个条件,不写入数据目录"
}
},
"refund_rate": {
"a": {
"write": true,
"source": "shop",
"table": "orders",
"item": "valid_filter",
"value": "status <> 'cancelled'"
},
"b": {
"write": false,
"reason": "指标「退款率」多出筛选条件的是原流程,被采纳的盲算没有这个条件,不写入数据目录"
}
}
},
"joint": [
{
"source": "shop",
"table": "orders",
"item": "valid_filter",
"members": [
{
"metric_id": "gmv",
"choice": "a"
},
{
"metric_id": "refund_rate",
"choice": "a"
}
],
"outcomes": {
"gmv": {
"write": false,
"reason": "「orders」的有效记录条件「status <> 'test'」曾被人工驳回,与这次指标「销售额」的选择相反,未写入。如需更改,请到数据目录中修改"
},
"refund_rate": {
"write": true,
"value": "status <> 'cancelled'"
}
}
}
]
},
"time_rejected": {
"gmv": null,
"refund_rate": "time",
"choices": {
"gmv": "a",
"refund_rate": "b"
},
"notes": {
"orders": {
"business_date": {
"value": {
"column": "created_at"
},
"source": "llm",
"status": "rejected"
}
}
},
"written": [],
"catalog": {
"gmv": {
"a": {
"write": true,
"source": "shop",
"table": "orders",
"item": "business_date",
"value": {
"column": "paid_at"
}
},
"b": {
"write": false,
"source": "shop",
"table": "orders",
"item": "business_date",
"value": {
"column": "created_at"
},
"reason": "「orders」的业务日期「created_at」曾被人工驳回,与这次指标「销售额」的选择相反,未写入。如需更改,请到数据目录中修改"
}
},
"refund_rate": {
"a": {
"write": true,
"source": "shop",
"table": "orders",
"item": "business_date",
"value": {
"column": "paid_at"
}
},
"b": {
"write": false,
"source": "shop",
"table": "orders",
"item": "business_date",
"value": {
"column": "created_at"
},
"reason": "「orders」的业务日期「created_at」曾被人工驳回,与这次指标「退款率」的选择相反,未写入。如需更改,请到数据目录中修改"
}
}
},
"joint": [
{
"source": "shop",
"table": "orders",
"item": "business_date",
"members": [
{
"metric_id": "gmv",
"choice": "a"
},
{
"metric_id": "refund_rate",
"choice": "a"
}
],
"outcomes": {
"gmv": {
"write": true,
"value": {
"column": "paid_at"
}
},
"refund_rate": {
"write": true,
"value": {
"column": "paid_at"
}
}
}
},
{
"source": "shop",
"table": "orders",
"item": "business_date",
"members": [
{
"metric_id": "gmv",
"choice": "a"
},
{
"metric_id": "refund_rate",
"choice": "b"
}
],
"outcomes": {
"gmv": {
"write": false,
"reason": "同一次裁决里对「orders」的业务日期给出了不同的说法(指标「销售额」采纳的是「paid_at」;指标「退款率」采纳的是「created_at」),无法确定哪一个是数据事实,都未写入数据目录"
},
"refund_rate": {
"write": false,
"reason": "同一次裁决里对「orders」的业务日期给出了不同的说法(指标「销售额」采纳的是「paid_at」;指标「退款率」采纳的是「created_at」),无法确定哪一个是数据事实,都未写入数据目录"
}
}
},
{
"source": "shop",
"table": "orders",
"item": "business_date",
"members": [
{
"metric_id": "gmv",
"choice": "b"
},
{
"metric_id": "refund_rate",
"choice": "a"
}
],
"outcomes": {
"gmv": {
"write": false,
"reason": "同一次裁决里对「orders」的业务日期给出了不同的说法(指标「销售额」采纳的是「created_at」;指标「退款率」采纳的是「paid_at」),无法确定哪一个是数据事实,都未写入数据目录"
},
"refund_rate": {
"write": false,
"reason": "同一次裁决里对「orders」的业务日期给出了不同的说法(指标「销售额」采纳的是「created_at」;指标「退款率」采纳的是「paid_at」),无法确定哪一个是数据事实,都未写入数据目录"
}
}
},
{
"source": "shop",
"table": "orders",
"item": "business_date",
"members": [
{
"metric_id": "gmv",
"choice": "b"
},
{
"metric_id": "refund_rate",
"choice": "b"
}
],
"outcomes": {
"gmv": {
"write": false,
"reason": "「orders」的业务日期「created_at」曾被人工驳回,与这次指标「销售额」、「退款率」的选择相反,未写入。如需更改,请到数据目录中修改"
},
"refund_rate": {
"write": false,
"reason": "「orders」的业务日期「created_at」曾被人工驳回,与这次指标「销售额」、「退款率」的选择相反,未写入。如需更改,请到数据目录中修改"
}
}
}
]
}
},
"catalog_blocked": {
"notes": {
"orders": {
"business_date": {
"value": {
"column": "paid_at"
},
"source": "human",
"status": "confirmed"
}
}
},
"catalog": {
"a": {
"write": false,
"source": "shop",
"table": "orders",
"item": "business_date",
"value": {
"column": "paid_at"
},
"reason": "「orders」的业务日期已是人工确认过的「paid_at」,无需重复写入"
},
"b": {
"write": false,
"source": "shop",
"table": "orders",
"item": "business_date",
"value": {
"column": "created_at"
},
"reason": "「orders」的业务日期已有人工确认过的说法「paid_at」,与这次指标「销售额」采纳的「created_at」不同,未覆盖。如需更改,请到数据目录中修改"
}
}
}
}
+81 -2
View File
@@ -4,9 +4,10 @@ import { ReactFlow, ReactFlowProvider } from '@xyflow/react'
import { ApprovalCard } from '../../run/RunPanel'
import { Inspector } from '../../canvas/Inspector'
import { NodeCard } from '../../canvas/NodeCard'
import { EvidencePane } from '../../pages/runs/EvidencePane'
import { toFlow, useStudio } from '../../store/studio'
import { useCatalog } from '../../store/catalog'
import type { Approval, GraphSpec, Provider } from '../../types'
import type { Approval, GraphSpec, Provider, Run, RunEvent } from '../../types'
import data from './dual_check.json'
/**
@@ -28,8 +29,15 @@ import data from './dual_check.json'
* - peer=<名字>:「退款率」的摘要同样换成 peers 里那一对 SQL 的。peers 和「销售额」(或换上的变体)落到数据目录的
* 同一项上,看同一次裁决里几个指标说法不同、要合写时卡上怎么说(夹具的 merges)
* - catalog=1:摘要里每个指标带上服务端预告的「采用哪一边会往数据目录里写什么」(catalog_preview;换了变体、peers 的
* 指标用它们自己的 catalog)。catalog=bad:「销售额」带一份认不出的预告
* 指标用它们自己的 catalog)。catalog=bad:「销售额」带一份认不出的预告。catalog=blocked:「销售额」带目录里已有人工
* 确认的业务日期时的预告(catalog_blocked:两边都被挡下,各带写到哪和原因)
* - merge=<名字>:两个指标的预告换成 merges 里那一种组合按它的目录算的(catalog;和 variant、peer 一起用,换上的 SQL
* 照它的 gmv、refund_rate 写)。合起来的预告(joint)在完整对照里,由检查脚本按同一种组合伪造工件
* - on_reject=<值>:payload 带上节点实际生效的「未采用原流程时」
*
* ?syn=verify-gaps:出具缺口里有双盲复算、反方审稿报上来的几条(两路结果不一致、结论被推翻、指标无法复算)和一条
* 校验没做完的。上面是运行详情的证据页(真的 EvidencePane:证据图、审计接口由检查脚本伪造),下面是同一次运行的成果
* 节点卡片(出具印章的悬停说明):两处都把核查的缺口另起「核查未通过」「核查未完成」两组,不放在「校验未全部完成」下
*/
const approval = (patch: Partial<Approval> = {}): Approval => ({
...(data.approval as unknown as Approval),
@@ -44,6 +52,7 @@ function approvalOf(search: string): Approval {
const variant = (data.variants as unknown as Record<string, Variant>)[q.get('variant') ?? '']
const peer = (data.peers as unknown as Record<string, Variant>)[q.get('peer') ?? '']
const catalog = q.get('catalog')
const merge = (data.merges as unknown as Record<string, { catalog?: Record<string, unknown> }>)[q.get('merge') ?? '']
const onReject = q.get('on_reject')
const previews = data.catalog_preview as unknown as Record<string, unknown>
const summary = data.approval.payload.summary.map((s) => {
@@ -54,6 +63,8 @@ function approvalOf(search: string): Approval {
...(items ? { diff: items.slice(0, 3).map((i) => i.text), fallback: !items.some((i) => i.aspect !== 'other' && i.aspect !== 'parse') } : {}),
...(catalog === '1' ? { catalog: swapped ? swapped.catalog : previews[s.metric_id] } : {}),
...(catalog === 'bad' && s.metric_id === 'gmv' ? { catalog: { a: { write: true, table: 'orders' }, b: { write: false } } } : {}),
...(catalog === 'blocked' && s.metric_id === 'gmv' ? { catalog: data.catalog_blocked.catalog } : {}),
...(merge?.catalog?.[s.metric_id] ? { catalog: merge.catalog[s.metric_id] } : {}),
}
})
return approval({ payload: { ...data.approval.payload, summary, ...(onReject ? { on_reject: onReject } : {}) } })
@@ -97,6 +108,73 @@ function InspectorCase() {
)
}
/** verify-gaps 用例的运行和出具明细(库、指标、地名都是虚构的) */
const VERIFY_GAPS = {
run: 'run-verify-gaps',
gaps: {
failed: ['双盲复算「复核周报口径」:指标「销售额」两路结果不一致,审核人选择了盲算结果', '反方审稿:推翻了 1 句结论:「东区增长主要来自新客」'],
unfinished: ['双盲复算「复核周报口径」:指标「订单数」无法复算:输入来自合并查询,无法单独复算'],
other: ['叙述模板渲染为空(路径可能有误)'],
},
}
const GAPS = VERIFY_GAPS.gaps
const GAPS_ISSUANCE = {
tier: 'degraded', matched_numbers: 3, metrics_checked: 2, missing_required: [], missing_expected: [], unmatched_numbers: [],
// 缺口的先后照服务端(出具契约按上游节点的先后收):核查的和别的混在一起,分组靠前缀认
gaps: [GAPS.failed[0], GAPS.other[0], GAPS.unfinished[0], GAPS.failed[1]],
}
const GAPS_RUN: Run = {
id: VERIFY_GAPS.run, workflow_id: null, workflow_name: '周报(预览)', status: 'succeeded', input: {},
output: { _issuance: GAPS_ISSUANCE }, error: null, usage: {} as Run['usage'], run_class: 'formal',
}
const GAPS_GRAPH = {
nodes: [
{ id: 'dc', type: 'dual_check', position: { x: 0, y: 40 }, data: { label: '复核周报口径', config: {} } },
{ id: 'done', type: 'output', position: { x: 300, y: 40 }, data: { label: '成果', config: {} } },
],
edges: [{ id: 'g1', source: 'dc', target: 'done' }],
} as unknown as GraphSpec
/**
* 证据页和成果节点卡片:图放进 studio store,再按一次运行的事件灌进去(出具事件带着完整的明细,卡片的印章按它画、
* 悬停说明按它写)。只在这个用例渲染时改 store
*/
function VerifyGapsCase() {
useState(() => {
const { nodes, edges } = toFlow(GAPS_GRAPH)
const st = useStudio.getState()
st.clearRun()
useStudio.setState({ nodes, edges, selectedId: null, run: { ...GAPS_RUN, status: 'running', output: {} }, runSnapshot: null })
const at = Date.now() / 1000 - 5
const events: RunEvent[] = [
{ seq: 1, type: 'run.started', node_id: null, ts: at, data: { nodes: 2 } },
{ seq: 2, type: 'node.started', node_id: 'dc', ts: at + 0.1, data: {} },
{ seq: 3, type: 'node.finished', node_id: 'dc', ts: at + 1, data: { duration_ms: 900 } },
{ seq: 4, type: 'node.started', node_id: 'done', ts: at + 1.1, data: {} },
{ seq: 5, type: 'issuance', node_id: 'done', ts: at + 1.2, data: { ...GAPS_ISSUANCE, unmatched: 0 } },
{ seq: 6, type: 'node.finished', node_id: 'done', ts: at + 1.3, data: { duration_ms: 200 } },
{ seq: 7, type: 'run.finished', node_id: null, ts: at + 1.4, data: { output: { _issuance: GAPS_ISSUANCE }, duration_ms: 1400 } },
]
for (const e of events) useStudio.getState().applyEvent(e)
return true
})
const nodes = useStudio((s) => s.nodes)
const edges = useStudio((s) => s.edges)
return (
<div className="flex min-h-screen max-w-full flex-col" data-fixture="verify-gaps">
<div className="h-[520px] min-h-0 border-b" data-verify-gaps-evidence="">
<EvidencePane run={GAPS_RUN} output={GAPS_RUN.output} labelOf={() => undefined} refreshKey="" />
</div>
<div className="h-64 min-h-0 min-w-0" data-verify-gaps-canvas="">
<ReactFlowProvider>
<ReactFlow nodes={nodes} edges={edges} nodeTypes={nodeTypes} fitView nodesDraggable={false} nodesConnectable={false}
proOptions={{ hideAttribution: true }} />
</ReactFlowProvider>
</div>
</div>
)
}
export const cases: Record<string, () => JSX.Element> = {
'dual-check-approval': () => (
<div className="mx-auto max-w-3xl p-4 text-sm" data-fixture="dual-check-approval"><Card value={approvalOf(location.search)} /></div>
@@ -117,4 +195,5 @@ export const cases: Record<string, () => JSX.Element> = {
</div>
),
'dual-check-inspector': () => <InspectorCase />,
'verify-gaps': () => <VerifyGapsCase />,
}
+110 -42
View File
@@ -3429,7 +3429,9 @@ export const WHATIF_TEXT = {
}
/**
* 双盲复算:节点库说明、检查器、节点卡片摘要、两边对不上时的审批卡,以及时间线上双盲复算和反方审稿的日志。
* 双盲复算:节点库说明、检查器、节点卡片摘要、两边对不上时的审批卡,以及时间线上双盲复算的日志。核查的上限叫法
* (limitLabel)和出具缺口里「核查未通过」「核查未完成」那两组(verifyGaps)反方审稿也用,放在这里一处;反方审稿自己的
* 时间线说法在 CHALLENGE_TEXT.log。
*
* 两边的叫法固定为「原流程」「盲算」(服务端 explain_sql_diff 的 labels 也是这两个词),审核人的三个选择固定为
* 「采用原流程的结果」「采用盲算的结果」「两边都不对」。选「采用盲算的结果」不会替换报告里的数,只记缺口,
@@ -3442,9 +3444,8 @@ export const DUAL_CHECK_TEXT = {
// ---- 检查器(nodeDefs 的 dual_check、canvas/DualCheckFields.tsx)
/**
* 字段名,键就是配置键。服务端校验和报错引用的是同一套叫法(schema.py 的 DUAL_CHECK_FIELD_LABEL,check-verify 在
* 服务端合入后逐项比对):问题挂在字段下面、出现在问题面板里时,人才找得到是哪一项。模型两项照「裁判模型 · 接入」
* 「裁判模型」的写法
* 字段名,键就是配置键。服务端校验和报错引用的是同一套叫法(engine/labels.py 的 DUAL_CHECK_FIELD_LABEL,check-verify
* 逐项比对):问题挂在字段下面、出现在问题面板里时,人才找得到是哪一项。模型两项照「裁判模型 · 接入」「裁判模型」的写法
*/
field: {
card: '口径卡',
@@ -3480,7 +3481,10 @@ export const DUAL_CHECK_TEXT = {
cardOption: (label: string, caliber?: string | null) => (caliber && caliber !== label ? `${label}(${caliber})` : label),
cardGone: (id: string) => `${id}(不在画布上)`,
cardNotUpstream: '所选口径卡不在本节点上游,运行到本节点时还没有它的结果。请把它连接到本节点之前',
cardMissing: (id: string) => `口径卡「${id}」不在画布上,请重新选择`,
cardMissingHint: '所选口径卡已不在画布上,请重新选择',
/** 选中的节点在画布上,但不是口径卡(助手改图、导入 JSON 会写出这种配置):下拉里那一项、下面那句提示 */
cardWrongType: (label: string) => `${label}(不是口径卡)`,
cardWrongTypeHint: (type: string) => `所选节点是「${type}」节点,不是口径卡,请重新选择`,
metricsAll: '全部指标',
metricsDefault: '未指定:复算全部输入来自查询的指标',
metricsPicked: (n: number, total: number) => `已选 ${n} / ${total} 个指标`,
@@ -3514,7 +3518,7 @@ export const DUAL_CHECK_TEXT = {
},
tolerancePlaceholder: (v: number | null | undefined) => (v == null ? '跟随设置' : `跟随设置(${v})`),
toleranceInvalid: '请填写不小于 0 的数',
/** 选项以服务端报错里的短说法(schema.py 的 DUAL_CHECK_ON_REJECT_LABEL)开头,后面可以带一句用途 */
/** 选项以服务端报错里的短说法(engine/labels.py 的 DUAL_CHECK_ON_REJECT_LABEL)开头,后面可以带一句用途 */
onReject: { degrade: '计入缺口、出具降档(默认)', fail: '判为失败,运行终止' } as Record<string, string>,
onRejectUnknown: (v: string) => `${v}:无法识别的值,请从上方选项中选择`,
enabled: { follow: '跟随设置', on: '开启', off: '关闭' },
@@ -3555,6 +3559,8 @@ export const DUAL_CHECK_TEXT = {
textDiff: '规范化后不同的行',
textDiffNone: '这一边没有不同的行',
rationale: '盲算的说明',
/** 理由文档里有没有出处的数字时,理由下面那一句提醒 */
rationaleBare: '理由中标出的数字没有引用盲算自己的查询结果,无法核对出处',
/**
* 服务端没有预告(老服务端,见 catalogPreview)、两边又只差一处时,提交前说清选择可能被记进数据目录。卡上只看得到
* 差异的方面,看不到服务端写目录的其余条件(dual_check_facts.derive:只有一边按时间筛的不记,多出的条件得在排除
@@ -3573,31 +3579,50 @@ export const DUAL_CHECK_TEXT = {
tail: '。写入的项记为人工确认的事实;选「两边都不对」时不记,数据目录中已有人工确认的不同说法时不覆盖,是否记入以时间线上的记录为准',
},
/**
* 服务端预告了采用哪一边会往数据目录里写什么(payload.summary[].catalog)时照它说:三个选择各一句,写的说哪张表的
* 哪一项记成什么,不写的只说不记(原因在裁决后的时间线上)。两边都不写时卡上不提数据目录。卡上是
* 「head + 三句(;分隔)+ tail」,审核人当前选的那一句加重。
* 服务端预告了采用哪一边会往数据目录里写什么(payload.summary[].catalog)时照它说:三个选择逐条一句,会写的说哪张表
* 的哪一项会记为什么,不写的说不会记入和原因(服务端的原话,和裁决后时间线上跳过的原因一字不差)。两边都认不出
* 可记的事实(都没有写到哪)时卡上不提数据目录。卡上是「head + 三条 + tail」,审核人当前选的那一条加重。
*
* 预告是每个指标单独算的,服务端写目录前却把同一次裁决里落到同一张表同一项上的说法归拢(dual_check_facts._merged):
* 业务日期、去重规则说法不同的一项都不写(conflict),有效记录条件用 AND 合成一句写(joined)。卡上按其余指标当前的
* 选择补上这一层,tail 里说明预告是按当前的选择算的
* 同一次裁决里几个指标按当前的选择落到同一张表同一项上时,服务端写目录前把它们归拢(dual_check_facts._merged):
* 说法相同的写一次,有效记录条件用 AND 合成一句,业务日期、去重规则说法不同的都不写,驳回过的拿出来不写。对照工件
* 里有服务端把每种组合算好的结果(catalog_joint)时照它说:会写的是合起来的那个值,并写明和哪几个指标一起记
* (together);没有时(老服务端、组合太多、工件还没取到)按其余指标当前的选择推(conflict、joined、pending),
* 被目录挡下的同项指标也算进来,推不准的(pending)只说可能,结尾换成 tailInferred:推出来的不是服务端算好的结果,
* 不能和 tail 一样只在「审批期间目录有改动」时才不准
*/
catalogPreview: {
head: '记入数据目录:',
/** where 同时间线(log.catalogItem):「orders」(shop)的业务日期;value 是要写进去的说法 */
write: (choice: string, where: string, value: string) => `${choice}时,${where}记为「${value}」`,
write: (choice: string, where: string, value: string) => `${choice}时,${where}会记为「${value}」`,
/** 两边写的是同一张表的同一项、只差取值时,后一边省掉「哪张表的哪一项」 */
writeSame: (choice: string, value: string) => `${choice}时记为「${value}」`,
writeSame: (choice: string, value: string) => `${choice}时会记为「${value}」`,
/** reason 是服务端的原话 */
blocked: (choice: string, reason: string) => `${choice}时不会记入:${reason}`,
skip: (choice: string) => `${choice}时不记`,
/** 接在 write / writeSame 后面:和这些指标按当前的选择一起记入同一项(服务端算好的结果) */
together: (metrics: string) => `,与${metrics}的选择一起记入`,
/** metrics 是 metricNames 写好的、和这一边说法不同的指标(按它们当前的选择) */
conflict: (choice: string, where: string, metrics: string) => `${choice}时,${where}与${metrics}的选择说法不同,都不记`,
/** 同 writeSame:两边写的是同一项时,后一边省掉「哪张表的哪一项」 */
conflictSame: (choice: string, metrics: string) => `${choice}时与${metrics}的选择说法不同,都不记`,
/** 有效记录条件接在 write / writeSame 后面:和这些指标当前采用的条件合成一句写 */
joined: (metrics: string) => `,与${metrics}采用的条件用 AND 合成一句`,
/**
* 没有算好的合并结果、同一项上又有被目录挡下的指标(有效记录条件):挡下的原因卡上认不出(驳回过的会被拿掉,
* 别的原因会连这一边一起挡下),写不写说不准,只说可能。value 同 write
*/
pending: (choice: string, where: string, value: string, metrics: string) =>
`${choice}时,${where}可能记为「${value}」,也可能不记:要与${metrics}的选择合起来才能确定`,
/** 同 writeSame:两边写的是同一项时,后一边省掉「哪张表的哪一项」 */
pendingSame: (choice: string, value: string, metrics: string) =>
`${choice}时可能记为「${value}」,也可能不记:要与${metrics}的选择合起来才能确定`,
/** 「退款率」、「订单数」;多于 3 个只列前 3 个 */
metricNames: (names: string[]) => names.slice(0, 3).map((n) => `「${n}」`).join('、')
+ (names.length > 3 ? `等 ${names.length} 个指标` : ''),
tail: '。写入的项记为人工确认的事实;以上按发起审批时的数据目录和各指标当前的选择预告,实际写入以时间线上的记录为准',
tail: '写入的项记为人工确认的事实。以上按发起审批时的数据目录和各指标当前的选择预告,审批期间数据目录有改动时,以时间线上的记录为准',
/** 有一条是按其余指标当前的选择推出来的(没有算好的合并结果):推断不一定准,实际写入一律以时间线为准 */
tailInferred: '写入的项记为人工确认的事实。几个指标落到同一项上时,以上是按各指标当前的选择推断的结果,'
+ '实际写入以时间线上的记录为准',
},
choices: { a: '采用原流程的结果', b: '采用盲算的结果', neither: '两边都不对' } as Record<'a' | 'b' | 'neither', string>,
choiceGroup: (name: string) => `「${name}」采用哪一边的结果`,
@@ -3664,39 +3689,38 @@ export const DUAL_CHECK_TEXT = {
const where = table ? `「${table}」${source ? `(${source})` : ''}` : ''
return where && item ? `${where}的${item}` : where || item || ''
},
/** 写进数据目录的一项连同写进去的值:「orders」(shop)的业务日期记为「paid_date」 */
catalogValue: (where: string, value: string) => `${where}记为「${value}」`,
catalogSkipped: (n: number) => `${formatNumber(n)} 项未写入`,
catalogNext: '可在「数据 → 数据目录」中查看或修改',
/** metric 是指标 ID(服务端日志只带 ID,中文名在原话里),不当名字加引号 */
limit: (label: string, metric?: string) => (metric ? `指标 ${metric} 的盲算已达${label},按无法复算处理` : `双盲复算已达${label}`),
limitNext: '请在「设置 → 偏好设置 → 核查」中调高双盲复算的上限',
/**
* dual_check_unchecked:盲算触顶、出错、交不出数,或者输入本身没法单独复算(合并查询、遮罩列)。只说记为缺口,
* 不说出具:探索运行不出具,节点接在侧枝上时缺口也进不了出具,降不降档由出具那一行说(同 gaps)
*/
unchecked: (n?: number) => (n ? `双盲复算有 ${formatNumber(n)} 个指标无法复算,已记为缺口`
: '双盲复算有指标无法复算,已记为缺口'),
uncheckedNext: '无法复算的原因见展开内容。来自合并查询、遮罩列的输入无法单独复算;盲算触顶、出错的,可调高「设置 → 偏好设置 → 核查」中的上限后重新运行',
},
/** 反方审稿日志的时间线说法:时间线解读统一在这里做,反方审稿的工作包不另写一份 */
challengeLog: {
skippedDisabled: '反方审稿未启用,已跳过',
skippedDisabledNext: '如需审稿,请在节点中开启,或在「设置 → 偏好设置 → 核查」中启用反方审稿',
// no_report:要审的报告节点找得到(找不到时节点直接报错,到不了这里),但它的报告文档读不出来——没有写出、
// 保存失败,或者它在这次没有执行到的分支上
skippedNoReport: '要审的报告没有可读取的报告文档,已跳过反方审稿',
skippedNoReportNext: '请确认报告撰写节点是否执行成功、是否写出了报告;它位于条件分支上时,确认本次运行执行到了它',
skippedNoClaims: '报告中没有需要审的关键结论,已跳过反方审稿',
skipped: '反方审稿已跳过',
sameModel: (model?: string) => (model ? `反方审稿模型与报告撰写模型同为「${model}」,审稿缺乏独立性`
: '反方审稿模型与报告撰写模型相同,审稿缺乏独立性'),
sameModelNext: '请在节点中指定其他审稿模型,或在「设置 → 偏好设置 → 核查」中修改核查模型',
done: (n?: number) => (n ? `反方审稿完成:审阅了 ${formatNumber(n)} 句结论` : '反方审稿完成'),
verdict: { stands: '经受住', weakened: '被削弱', refuted: '被推翻', inconclusive: '无法判断' } as Record<string, string>,
refuted: (n?: number) => (n ? `反方审稿推翻了 ${formatNumber(n)} 句结论` : '反方审稿推翻了报告中的结论'),
refutedNext: '请在证据中对照反方审稿的查询和理由,核实这些结论',
limit: (label: string, skipped?: number) => (skipped ? `反方审稿已达${label},${formatNumber(skipped)} 句结论未审` : `反方审稿已达${label}`),
limitNext: '请在节点或「设置 → 偏好设置 → 核查」中调高反方审稿的上限',
/**
* 出具缺口里双盲复算、反方审稿报上来的那几条(缺口以「双盲复算「节点名」:」「反方审稿:」开头):时间线、成果卡片、
* 证据页把它们另起,不和「校验没跑全」混在一起,再按是查出了问题还是没核成分两组(run/decode.ts 的 splitIssuanceGaps):
* failed 是核查查出来的问题(两路结果不一致、结论被推翻),unfinished 是没核成的(指标无法复算:合并查询、遮罩列的
* 输入做不了复算,盲算触顶、出错)——没核过的数不能说成「未通过」,读的人会以为这个数被查出了错
*/
verifyGaps: {
failed: '核查未通过',
unfinished: '核查未完成',
},
}
/**
* 反方审稿节点:节点库说明、检查器、节点卡片摘要,以及审批卡上的反方审稿(run/ChallengeSummary.tsx)。
* 四种判断全站只有这一种叫法:经受住、被削弱、被推翻、无法判断。判断由反方模型给出,不是系统核对。
* 「出具会降档」只在正式运行、有被推翻的结论、按降档处理时才说;探索运行不出具,不说任何和出具有关的话;
* 运行类别取不到时照实说取不到
* 反方审稿节点:节点库说明、检查器、节点卡片摘要、审批卡上的反方审稿(run/ChallengeSummary.tsx),以及时间线上反方
* 审稿的日志(log)。四种判断全站只有这一种叫法:经受住、被削弱、被推翻、无法判断。判断由反方模型给出,不是系统核对。
* 「出具会降档」只在正式运行、有被推翻的结论、被推翻的真会让出具降档(服务端的 degrades;老服务端没给时按「没写只标注」
* 算)时才说;探索运行不出具、运行类别取不到时,不说任何和出具有关的话
*/
export const CHALLENGE_TEXT = {
description: '从反方立场复核上游报告的关键结论:另一个模型只读查库,逐句判断经受住、被削弱、被推翻还是无法判断',
@@ -3727,8 +3751,9 @@ export const CHALLENGE_TEXT = {
max_claims: '每份报告最多挑几句关键结论来审。留空则使用「设置 → 偏好设置 → 核查」中的值',
max_queries: '复核每句结论时最多执行几次查询。留空则使用「设置 → 偏好设置 → 核查」中的值',
timeout_s: '复核每句结论的时长上限,到时按已查到的结果给出判断。留空则使用「设置 → 偏好设置 → 核查」中的值',
on_refuted: '降档:被推翻的结论计入出具缺口,正式运行降档出具;只标注:在审批卡和运行记录中标出,不影响出具;'
+ '报错:本节点失败,运行停止',
// 选项名照下拉里的写(「出具降档」「只标注」「报错并停止运行」),和服务端报错里点的选项名一致
on_refuted: '出具降档:被推翻的结论计入出具缺口,正式运行降档出具;只标注:在审批卡和运行记录中标出,不影响出具;'
+ '报错并停止运行:本节点失败,运行停止',
},
onRefuted: { degrade: '出具降档(默认)', flag: '只标注', fail: '报错并停止运行' },
unknownValue: (v: string) => `${v}:无法识别的值,请从上方选项中选择`,
@@ -3777,8 +3802,17 @@ export const CHALLENGE_TEXT = {
degrade: '出具会降档',
degradeHint: '被推翻的结论计入出具缺口,本次正式运行将降档出具',
flagNote: '按节点设置,被推翻的结论只做标注,不影响出具档位',
/** 运行类别没取到:不知道是不是正式运行,照实说,并写出正式运行时的后果(旁边给重试) */
runClassFailed: '暂时无法确认运行类别;如为正式运行,被推翻的结论会使出具降档',
/**
* 按降档处置,但反方审稿节点不在带出具契约的成果节点上游(服务端的 degrades 为假):缺口进不了出具。这句画在人工审批
* 的卡上(画布上也会在审批节点旁弹出),主语写明是反方审稿节点,不说「本节点」——那里的本节点是审批节点
*/
degradeOff: '反方审稿节点没有接在带出具契约的成果节点上游,被推翻的结论不计入出具缺口,不影响出具档位',
/**
* 服务端的 unreviewed:反查没有完成的句数(核查模型不可用、触顶没给出结论、数据源已不存在或已停用、报告没有引用
* 数据库查询……),都记为无法判断。触顶的可能已经查过几次,不能说成「没有查询数据」;不会多于「无法判断」的句数
*/
unreviewed: (n: number) => `${formatNumber(n)} 句未能反查,已记为无法判断`,
unreviewedHint: '反查没有完成:可能是核查模型不可用、达到上限、数据源已不存在或已停用,或报告未引用数据库查询,原因见运行时间线',
/** 审批里没带工件(服务端保存审稿记录失败):每句都看不了理由和查询,整块说一次 */
noRecord: '反方审稿记录未保存,无法查看理由和查询',
more: (n: number) => `另有 ${formatNumber(n)} 句未列出`,
@@ -3797,6 +3831,40 @@ export const CHALLENGE_TEXT = {
truncated: '结果已截断,数据库中还有更多数据',
/** 理由里有出处的数字:读屏听到的是「数字,出处:查询 Q2 · 第 1 行 · amount」,点一下跳到那次查询 */
cited: (text: string, source: string) => `${text},出处:${source},跳到这次查询`,
/** 同上,没有可跳的查询时(双盲复算的理由)只念出处 */
citedPlain: (source: string) => `(出处:${source})`,
// ---- 时间线(run/decode.ts explainLog):按日志的 code 和结构化字段说,不从原话里认
log: {
skippedDisabled: '反方审稿未启用,已跳过',
skippedDisabledNext: '如需审稿,请在节点中开启,或在「设置 → 偏好设置 → 核查」中启用反方审稿',
// no_report:要审的报告节点找得到(找不到时节点直接报错,到不了这里),但它的报告文档读不出来——没有写出、
// 保存失败,或者它在这次没有执行到的分支上
skippedNoReport: '要审的报告没有可读取的报告文档,已跳过反方审稿',
skippedNoReportNext: '请确认报告撰写节点是否执行成功、是否写出了报告;它位于条件分支上时,确认本次运行执行到了它',
skippedNoClaims: '报告中没有需要审的关键结论,已跳过反方审稿',
skipped: '反方审稿已跳过',
sameModel: (model?: string) => (model ? `反方审稿模型与报告撰写模型同为「${model}」,审稿缺乏独立性`
: '反方审稿模型与报告撰写模型相同,审稿缺乏独立性'),
sameModelNext: '请在节点中指定其他审稿模型,或在「设置 → 偏好设置 → 核查」中修改核查模型',
done: (n?: number) => (n ? `反方审稿完成:审阅了 ${formatNumber(n)} 句结论` : '反方审稿完成'),
verdict: { stands: '经受住', weakened: '被削弱', refuted: '被推翻', inconclusive: '无法判断' } as Record<string, string>,
refuted: (n?: number) => (n ? `反方审稿推翻了 ${formatNumber(n)} 句结论` : '反方审稿推翻了报告中的结论'),
refutedNext: '请在证据中对照反方审稿的查询和理由,核实这些结论',
limit: (label: string, skipped?: number) => (skipped ? `反方审稿已达${label},${formatNumber(skipped)} 句结论未审` : `反方审稿已达${label}`),
limitNext: '请在节点或「设置 → 偏好设置 → 核查」中调高反方审稿的上限',
/**
* challenge_unreviewed:有句子未能反查(核查模型不可用、整理证据出错、报告没有引用数据库查询、数据源不在了、一条
* 查询都没执行成功),记为无法判断。触顶的不在这里(由 challenge_limit 说),所以建议里不提调高上限
*/
unreviewed: (n?: number) => (n ? `反方审稿有 ${formatNumber(n)} 句结论未能反查,已记为无法判断`
: '反方审稿有结论未能反查,已记为无法判断'),
unreviewedNext: '原因见展开内容。请检查核查模型和数据源是否可用,修正后重新运行;报告未引用数据库查询的结论无法反查',
/** challenge_sources_lost:反查了,但该查的数据源有停用了的,判断不含它们的数据 */
sourcesLost: (n?: number) => (n ? `反方审稿有 ${formatNumber(n)} 句结论只查了部分数据源` : '反方审稿有结论只查了部分数据源'),
sourcesLostSub: (names: string[]) => `未能查询:${names.map((x) => `「${x}」`).join('、')}(已不存在或已停用),判断不含其中的数据`,
sourcesLostNext: '请在「数据」页确认这些数据源是否应启用,启用后重新运行',
},
}
/**
+35 -6
View File
@@ -12,8 +12,9 @@ import {
issuanceMarks, segmentState, unitVerdict, verdictState, type AuditFilter, type AuditGroup, type AuditRow,
} from '../../lib/evidence'
import { formatNumber } from '../../lib/format'
import { EVIDENCE_AUDIT_TEXT as T, UPGRADE_TEXT } from '../../lib/terms'
import { DUAL_CHECK_TEXT, EVIDENCE_AUDIT_TEXT as T, UPGRADE_TEXT } from '../../lib/terms'
import { IssuanceBanner } from '../../run/AssistantStream'
import { splitIssuanceGaps } from '../../run/decode'
import { EvidenceDoc, type EvidenceDocHandle } from '../../run/EvidenceDoc'
import { EvidenceGuessView } from '../../run/EvidenceGuess'
import { Markdown, inlineStyles } from '../../run/Markdown'
@@ -145,11 +146,7 @@ export function EvidencePane({ run, output, labelOf, refreshKey }: {
<UpgradeBanner run={run} mode={mode} />
{/* 出具档位和降档原因写在报告上方:降档时只在侧栏小标签里写「SQL 检查未通过」,报告上却是绿色的
「10 个数字都有出处」,读的人会以为一切正常。SQL 检查导致的降档在横幅里单列一块 */}
{!!output?._issuance?.tier && (
<div data-evidence-issuance="">
<IssuanceBanner issuance={output._issuance} runClass={run.run_class} />
</div>
)}
{!!output?._issuance?.tier && <IssuanceWithChecks issuance={output._issuance} runClass={run.run_class} />}
{mode === 'cited' && reports.map((r) => {
const doc = docOf(r.node_id)
@@ -314,6 +311,38 @@ function useAudit(runId: string, key: string): AuditState {
return state
}
/**
* 出具横幅,外加双盲复算、反方审稿报上来的缺口另起的两组:「核查未通过」(两路结果不一致、结论被推翻)、「核查未完成」
* (指标无法复算)。横幅把缺口都列在「校验未全部完成」下,读起来像是校验没做完:这里从横幅里拿出来,紧跟在它下面单列,
* 颜色和横幅里的缺口一样(分组见 run/decode.ts 的 splitIssuanceGaps)。导出给预览用例(dev/fixtures/dual_check.tsx)
*/
export function IssuanceWithChecks({ issuance, runClass }: { issuance: Record<string, any>; runClass?: string }) {
const { failed, unfinished, other } = useMemo(
() => splitIssuanceGaps(Array.isArray(issuance.gaps) ? issuance.gaps.map(String) : []), [issuance])
const verify = failed.length + unfinished.length > 0
const shown = useMemo(() => (verify ? { ...issuance, gaps: other } : issuance), [issuance, verify, other])
const group = (kind: 'failed' | 'unfinished', gaps: string[]) => gaps.length > 0 && (
<div data-evidence-verify-group={kind}>
<div className="font-medium">{DUAL_CHECK_TEXT.verifyGaps[kind]}</div>
<ul className="mt-0.5 space-y-0.5 pl-2 [overflow-wrap:anywhere]">
{gaps.map((g) => <li key={g}>· {g}</li>)}
</ul>
</div>
)
return (
<div className="space-y-1.5" data-evidence-issuance="">
<IssuanceBanner issuance={shown} runClass={runClass} />
{verify && (
<div className="space-y-1 rounded-lg border px-2 py-1.5 text-2xs leading-relaxed"
style={{ borderColor: 'var(--st-waiting)', color: 'var(--st-waiting)' }} data-evidence-verify-gaps="">
{group('failed', failed)}
{group('unfinished', unfinished)}
</div>
)}
</div>
)
}
/** 顶上一行:这次运行按哪种方式展示证据、封存核对的结果、每份报告文档的哈希 */
function SummaryBar({ mode, seal, message, reports, labelOf }: {
mode?: string
+7
View File
@@ -332,6 +332,8 @@ export const ARTIFACT_KIND_LABEL: Record<string, string> = {
metric_set: '口径卡指标集',
report_doc: '报告文档',
schema_snapshot: '表结构快照',
dual_check: '双盲复算对照',
challenge: '反方审稿记录',
}
export const artifactKindLabel = (kind: string): string => ARTIFACT_KIND_LABEL[kind] ?? kind
@@ -349,6 +351,11 @@ export function artifactDescription(kind: string, meta?: Record<string, any> | n
// 查库时冻结的表结构(工件行的 meta 里有 {source, tables: 表数量}):报告里的表名、字段名按它核对
case 'schema_snapshot': return meta?.source
? `表结构:数据源「${meta.source}」${typeof meta.tables === 'number' ? ` · ${meta.tables} 张表` : ''}` : '查询时保存的表结构'
// 两路结果对不上时交给审核人的完整对照(工件行的 meta 里有 {metrics: 指标个数})
case 'dual_check': return typeof meta?.metrics === 'number'
? `双盲复算:${meta.metrics} 个指标两边的 SQL、取值与差异说明` : '双盲复算:两边的 SQL、取值与差异说明'
// 反方审稿的完整记录(工件行的 meta 里有 {report: 审的报告节点})
case 'challenge': return '反方审稿:每句结论的判断、理由和反方执行的查询'
default: return '工件'
}
}
+81 -61
View File
@@ -14,32 +14,50 @@ export interface ChallengeSummaryProps {
/** 这张审批卡审的报告(payload.reports,和 ApprovalReports 拿到的是同一份) */
reports: ApprovalReport[]
runId: string
/**
* 这次运行的类别(审批自带的 approval.run_class,同 ApprovalReports 的 runClass)。给了就照它说、不再另取;没给
* (老服务端的审批没有这一项)才按运行 id 取一次
*/
runClass?: string | null
}
/**
* 审批卡里反方审稿的摘要,紧跟在报告核对概况(ApprovalReports)后面:一行概况(四种判断各几句),逐句列出结论原文和判断,
* 点开一句再按 challenge_artifact 取完整内容,看反方的理由和它执行过的查询。审稿记录没存上(没有工件)时只列判断、
* 不能点开,整块说一次。
* 审批卡里反方审稿的摘要,紧跟在报告核对概况(ApprovalReports)后面:一行概况(四种判断各几句),出具相关的那一句,
* 有句子反查没完成时再说一行「N 句未能反查」,逐句列出结论原文和判断,点开一句再按 challenge_artifact 取完整内容,看反方
* 的理由和它执行过的查询。审稿记录没存上(没有工件)时只列判断、不能点开,整块说一次。
*
* 判断是反方模型给的,不是系统核对:颜色照结论句裁判的那一套,「经受住」也不用确定性的绿。
* 「出具会降档」只在正式运行、有被推翻的结论、按降档处理时才写——只标注的不写降档,探索运行不出具,和出具有关的话一句不说。
* 运行类别不由审批卡传进来,按运行 id 从证据 store 取(loadRunClass),取到之前不说;取不到时照实说取不到,可重试。
* 「出具会降档」只在正式运行、有被推翻的结论、被推翻的真会让出具降档时才写:服务端给了 degrades 就照它(按降档处置、又接
* 在带出具契约的成果节点上游才为真),老服务端没给时按「没写只标注」算。只标注的写一句不影响出具,按降档处置却不在出具
* 路径上的写一句为什么不影响;探索运行不出具,和出具有关的话一句不说。运行类别照审批卡给的(runClass,审批自带的那一项,
* 卡顶写的也是它);没给时按运行 id 从证据 store 取(loadRunClass),取到之前、取不到时都不说和出具有关的话(窗口重新
* 拿到焦点时再取)。
*
* 审的报告都没有经过反方审稿时什么都不画,也不发任何请求,卡片和以前一样。
*/
export function ChallengeSummary({ reports, runId }: ChallengeSummaryProps) {
/**
* 审批卡上的反方审稿概况,约定之外服务端另带两项(期 4):unreviewed 未能反查的句数,degrades 被推翻的会不会让出具降档。
* 老服务端都不给
*/
type Challenge = ApprovalChallenge & { unreviewed?: number; degrades?: boolean }
type RunClass = 'formal' | 'exploratory'
const runClassOf = (v: unknown): RunClass | null => (v === 'formal' || v === 'exploratory' ? v : null)
export function ChallengeSummary({ reports, runId, runClass }: ChallengeSummaryProps) {
const reviewed = useMemo(() => reports.flatMap((r) => {
const challenge = challengeOf(r)
return challenge ? [{ report: r, challenge }] : []
}), [reports])
if (!reviewed.length) return null
return <ChallengeList reviewed={reviewed} runId={runId} />
return <ChallengeList reviewed={reviewed} runId={runId} given={runClassOf(runClass)} />
}
function ChallengeList({ reviewed, runId }: {
reviewed: { report: ApprovalReport; challenge: ApprovalChallenge }[]; runId: string
function ChallengeList({ reviewed, runId, given }: {
reviewed: { report: ApprovalReport; challenge: Challenge }[]; runId: string; given: RunClass | null
}) {
const run = useRunClass(runId)
// 审批卡给了运行类别就照它,不另取:另取的那一次失败了,正式运行里的「出具会降档」会无端消失,而卡顶照样写着正式运行
const fetched = useRunClass(given ? '' : runId)
const run = given ?? fetched
return (
<>
{reviewed.map(({ report, challenge }) => (
@@ -74,7 +92,7 @@ const count = (v: unknown) => (typeof v === 'number' && Number.isFinite(v) && v
* payload.reports[i].challenge 认不认得:要么有计数、要么有条目。计数缺了按条目数(条目最多 10 条,计数才是全部);
* 条目缺了 unit 的留空(行的键带序号,区分得开),不补假的:补出来的键会被当成真的 unit 去和工件里的句子比
*/
function challengeOf(report: ApprovalReport): ApprovalChallenge | null {
function challengeOf(report: ApprovalReport): Challenge | null {
const raw = report.challenge as unknown
if (!raw || typeof raw !== 'object') return null
const c = raw as Record<string, unknown>
@@ -86,41 +104,32 @@ function challengeOf(report: ApprovalReport): ApprovalChallenge | null {
const counts = Object.fromEntries(VERDICTS.map((v) => [v, given
? count(given[v]) : items.filter((it) => it.verdict === v).length])) as ChallengeCounts
if (!given && !items.length) return null
const unreviewed = typeof c.unreviewed === 'number' && Number.isFinite(c.unreviewed) ? count(c.unreviewed) : undefined
return {
counts, items, artifact: typeof c.artifact === 'string' && c.artifact ? c.artifact : null,
on_refuted: typeof c.on_refuted === 'string' ? c.on_refuted : undefined,
...(unreviewed !== undefined ? { unreviewed } : {}),
...(typeof c.degrades === 'boolean' ? { degrades: c.degrades } : {}),
}
}
interface RunClass {
runClass: 'formal' | 'exploratory' | null
/** 取失败了、还没取到(重取期间也算:那一行和焦点所在的重试按钮不跟着闪掉) */
failed: boolean
retry: () => void
}
function useRunClass(runId: string): RunClass {
/**
* 这次运行的类别(审批卡没给时才取,runId 为空就不取):取到之前、取不到时为 null——不知道是不是正式运行,就一句和出具
* 有关的话都不说。取失败了不就此作罢:窗口重新拿到焦点时再取一次(store 对出错的槽会重发),取到了正式运行,降档的提示
* 随之出现
*/
function useRunClass(runId: string): RunClass | null {
const slot = useEvidence((s) => (runId ? s.runClasses[runId] : undefined))
const load = useEvidence((s) => s.loadRunClass)
useEffect(() => { if (runId) void load(runId) }, [runId, load])
const status = slot?.status
const [hadError, setHadError] = useState(false)
useEffect(() => {
if (status === 'error') setHadError(true)
else if (status === 'ok') setHadError(false)
}, [status])
const failed = status === 'error' || (hadError && status === 'loading')
// 取失败了不就此作罢:窗口重新拿到焦点时再取一次(store 对出错的槽会重发)。只取一次就放弃的话,一次网络抖动
// 会让「出具会降档」一直不出现,而卡顶按审批自带的运行类别照样写着正式运行
useEffect(() => {
if (status !== 'error' || !runId) return
const again = () => { void load(runId) }
window.addEventListener('focus', again)
return () => window.removeEventListener('focus', again)
}, [status, runId, load])
const retry = useCallback(() => { if (runId) void load(runId) }, [runId, load])
const runClass = status === 'ok' && (slot?.data === 'formal' || slot?.data === 'exploratory') ? slot.data : null
return { runClass, failed, retry }
return status === 'ok' ? runClassOf(slot?.data) : null
}
// ---------------------------------------------------------------- 取工件
@@ -213,7 +222,7 @@ const focusLost = () => !document.activeElement || document.activeElement === do
// ---------------------------------------------------------------- 卡片
function ChallengeBlock({ report, challenge, run }: {
report: ApprovalReport; challenge: ApprovalChallenge; run: RunClass
report: ApprovalReport; challenge: Challenge; run: RunClass | null
}) {
const [open, setOpen] = useState<Set<string>>(() => new Set())
const [all, setAll] = useState(false)
@@ -222,9 +231,13 @@ function ChallengeBlock({ report, challenge, run }: {
const total = VERDICTS.reduce((n, v) => n + counts[v], 0)
// 审批里没带工件:服务端保存审稿记录失败了。每句都看不了理由和查询,不画成能点开的样子,整块说一次
const noRecord = !challenge.artifact
const refuted = counts.refuted > 0 && run.runClass === 'formal'
const refuted = counts.refuted > 0 && run === 'formal'
// 没给 on_refuted(老服务端)按降档;报错的节点到不了审批,不会是 fail
const flagged = challenge.on_refuted === 'flag'
// 被推翻的真会让出具降档:服务端给了就照它,老服务端没给时按「不是只标注」算
const degrades = challenge.degrades ?? !flagged
// 未能反查的每一句都记为无法判断(服务端的约定),不会多于概况里的「无法判断」:对不上时按概况的数说,两个数不打架
const unreviewed = Math.min(challenge.unreviewed ?? 0, counts.inconclusive)
// 条目之外的几句(条目最多 10 条):要看全部时从工件里补上,排在后面,顺序照工件
const extra = all && detail.data ? detail.data.claims.filter((c) => !items.some((it) => sameClaim(c, it))) : []
const rows: ChallengeItem[] = [...items, ...extra]
@@ -256,24 +269,13 @@ function ChallengeBlock({ report, challenge, run }: {
const showAll = () => { focusMore.current = true; setAll(true) }
const retryAll = () => { focusMore.current = true; detail.retry?.() }
// 运行类别重取成功后,「暂时无法确认」那一行(连同焦点所在的重试按钮)换成降档说明:焦点接到概况那一行上
const countsRef = useRef<HTMLDivElement>(null)
const runRetried = useRef(false)
useEffect(() => {
if (run.failed || !runRetried.current) return
runRetried.current = false
if (focusLost()) countsRef.current?.focus()
}, [run.failed])
const retryRun = () => { runRetried.current = true; run.retry() }
return (
<div ref={blockRef} className="mb-2 rounded border bg-bg p-2" data-challenge={report.node_id}>
<div className="mb-1 flex items-center gap-1 text-2xs font-medium text-faint">
<ShieldAlert size={11} aria-hidden /> {CHALLENGE_TEXT.head(report.label || report.node_id)}
</div>
{total > 0 || items.length ? (
<div ref={countsRef} tabIndex={-1} className={`tnum flex flex-wrap items-center gap-x-1.5 gap-y-1 text-2xs ${FOCUS_RING}`}
data-challenge-counts="">
<div className="tnum flex flex-wrap items-center gap-x-1.5 gap-y-1 text-2xs" data-challenge-counts="">
{VERDICTS.map((v, i) => (
<Fragment key={v}>
{i > 0 && <span className="text-faint" aria-hidden>·</span>}
@@ -282,7 +284,7 @@ function ChallengeBlock({ report, challenge, run }: {
</span>
</Fragment>
))}
{refuted && !flagged && (
{refuted && !flagged && degrades && (
<span className="chip shrink-0 font-semibold" data-challenge-degrade=""
style={{ color: 'var(--st-failed)', borderColor: 'var(--st-failed)' }}>
<AlertTriangle size={11} aria-hidden /> {CHALLENGE_TEXT.degrade}
@@ -292,19 +294,23 @@ function ChallengeBlock({ report, challenge, run }: {
) : (
<div className="text-2xs text-dim" data-challenge-empty="">{CHALLENGE_TEXT.none}</div>
)}
{/* 降档的原因常显,不放在悬停提示里:触屏、键盘用户也得看得到为什么、会怎样(只标注那一档同样常显一行) */}
{refuted && !flagged && (
{/* 降档的原因常显,不放在悬停提示里:触屏、键盘用户也得看得到为什么、会怎样(只标注那一档同样常显一行)。
紧跟在概况那一行(「出具会降档」的标记)下面,中间不插别的话 */}
{refuted && !flagged && degrades && (
<div className="mt-0.5 text-2xs leading-relaxed text-dim" data-challenge-degrade-note="">{CHALLENGE_TEXT.degradeHint}</div>
)}
{refuted && !flagged && !degrades && (
<div className="mt-0.5 text-2xs leading-relaxed text-dim" data-challenge-degrade-off="">{CHALLENGE_TEXT.degradeOff}</div>
)}
{refuted && flagged && (
<div className="mt-0.5 text-2xs leading-relaxed text-dim" data-challenge-flag="">{CHALLENGE_TEXT.flagNote}</div>
)}
{/* 运行类别取不到:不知道是不是正式运行,不能装作没事(卡顶按审批自带的运行类别照样写着正式运行),照实说并可重试 */}
{counts.refuted > 0 && !flagged && run.failed && (
<div className="mt-0.5 flex flex-wrap items-center gap-x-2 gap-y-1 text-2xs leading-relaxed" data-challenge-runclass="failed">
<span style={{ color: 'var(--st-waiting)' }}>{CHALLENGE_TEXT.runClassFailed}</span>
<button type="button" className="btn btn-xs" onClick={retryRun}>{CHALLENGE_TEXT.retry}</button>
</div>
{/* 反查没完成的几句:「无法判断」里分不出查了数据不够和反查没做完,单独说一次 */}
{unreviewed > 0 && (
<p className="mt-0.5 text-2xs leading-relaxed" data-challenge-unreviewed={unreviewed}>
<span className="font-medium" style={{ color: 'var(--st-waiting)' }}>{CHALLENGE_TEXT.unreviewed(unreviewed)}</span>
<span className="text-dim">。{CHALLENGE_TEXT.unreviewedHint}</span>
</p>
)}
{rows.length > 0 && (
<ul className="mt-1.5 space-y-0.5" data-challenge-items="">
@@ -525,7 +531,11 @@ function Rationale({ claim, onJump }: { claim: ChallengeClaim; onJump: (alias: s
/** 列表项从哪一个片段开始:同 EvidenceDoc(行首的「- 」「1. 」是结构片段) */
const ITEM_START = /(^|\n)[ \t]*([-*+]|\d+[.)])[ \t]+$/
function RationaleDoc({ doc, onJump }: { doc: EvidenceDocData; onJump: (alias: string) => void }) {
/**
* 核查 agent 的理由文档(evidence.compose_doc 组装的,数字带出处、裸数字被标出)。反方审稿、双盲复算的审批卡共用:
* onJump 给了的(反方审稿,旁边列着它的查询)有出处的数字是按钮,点一下跳到那次查询;没给的(双盲复算)只画出处
*/
export function RationaleDoc({ doc, onJump }: { doc: EvidenceDocData; onJump?: (alias: string) => void }) {
return (
<div className="min-w-0 space-y-1.5 text-[11.5px] leading-relaxed" data-challenge-doc="">
{doc.blocks.map((block, b) => <RationaleBlock key={block.id ?? b} block={block} doc={doc} onJump={onJump} />)}
@@ -534,7 +544,7 @@ function RationaleDoc({ doc, onJump }: { doc: EvidenceDocData; onJump: (alias: s
}
/** 一块:外观借 Markdown 的 BlockView,和报告文档、普通答案长得一样(块的分法同 EvidenceDoc 的 DocBlock) */
function RationaleBlock({ block, doc, onJump }: { block: EvidenceBlock; doc: EvidenceDocData; onJump: (alias: string) => void }) {
function RationaleBlock({ block, doc, onJump }: { block: EvidenceBlock; doc: EvidenceDocData; onJump?: (alias: string) => void }) {
const units = block.units ?? []
const unit = (u: EvidenceUnit, code = false) => <RationaleUnit key={u.id} unit={u} doc={doc} code={code} onJump={onJump} />
switch (block.type) {
@@ -605,11 +615,12 @@ function cellAlias(seg: EvidenceSegment, doc: EvidenceDocData): string | null {
}
/**
* 一句话:文字按行内 Markdown 渲染(整句算一次样式,同 EvidenceDoc 的 UnitView)。有出处的数字是按钮,后面挂查询编号;
* 裸数字、疑似不存在的名称画点状线,句末挂「无证据」「疑似不存在的名称」。别的片段(表名、字段名的链接)照普通文字
* 一句话:文字按行内 Markdown 渲染(整句算一次样式,同 EvidenceDoc 的 UnitView)。有出处的数字画实线、后面挂查询编号,
* 给了 onJump 时是按钮;裸数字、疑似不存在的名称画点状线,句末挂「无证据」「疑似不存在的名称」。别的片段(表名、字段名的
* 链接)照普通文字
*/
function RationaleUnit({ unit, doc, code, onJump }: {
unit: EvidenceUnit; doc: EvidenceDocData; code: boolean; onJump: (alias: string) => void
unit: EvidenceUnit; doc: EvidenceDocData; code: boolean; onJump?: (alias: string) => void
}) {
const segs = (unit.segments ?? []).filter((s) => s.kind !== 'structural')
const whole = segs.map((s) => s.text).join('')
@@ -624,13 +635,22 @@ function RationaleUnit({ unit, doc, code, onJump }: {
const body = styles ? <StyledSlice text={whole} styles={styles} from={from} to={pos} links={!state} /> : s.text
if (alias) {
const source = sourceOf(s, doc)
// inline-block:不吃上面那条下划线
const tag = <sup className="mono ml-px inline-block select-none text-[9px] font-semibold text-faint" aria-hidden>{alias}</sup>
if (!onJump) {
return (
// 不是按钮:.ev-seg 的手形光标换成问号,悬停看出处
<span key={s.id} className="ev-seg" data-ev-state="deterministic" data-ev-line="solid" data-challenge-cite={alias}
style={{ ...evStyle('deterministic'), cursor: 'help' }} title={source}>
{body}{tag}<span className="sr-only">{CHALLENGE_TEXT.citedPlain(source)}</span>
</span>
)
}
return (
<button key={s.id} type="button" className="ev-seg" data-ev-state="deterministic" data-ev-line="solid"
data-challenge-cite={alias} style={evStyle('deterministic')} title={source}
aria-label={CHALLENGE_TEXT.cited(s.text, source)} onClick={() => onJump(alias)}>
{body}
{/* inline-block:不吃上面那条下划线 */}
<sup className="mono ml-px inline-block select-none text-[9px] font-semibold text-faint" aria-hidden>{alias}</sup>
{body}{tag}
</button>
)
}
+240 -109
View File
@@ -1,17 +1,20 @@
import { Fragment, useEffect, useId, useMemo, useState } from 'react'
import { useEffect, useId, useMemo, useState } from 'react'
import type { CSSProperties } from 'react'
import { AlertTriangle, Ban, Check, ChevronRight } from 'lucide-react'
import clsx from 'clsx'
import { api } from '../api/client'
import { useCatalog } from '../store/catalog'
import { asDoc } from '../store/evidence'
import { useStudio } from '../store/studio'
import { Spinner, useToast } from '../components/ui'
import { segmentState } from '../lib/evidence'
import { NONE } from '../lib/format'
import { CATALOG_TABLE_FIELD_LABEL, DUAL_CHECK_TEXT } from '../lib/terms'
import { patchValueText } from './catalogPatch'
import { RationaleDoc } from './ChallengeSummary'
import type {
Approval, DualCheckBlindInput, DualCheckCard, DualCheckChoice, DualCheckInput, DualCheckMetric, DualCheckReply,
DualCheckSummaryItem,
DualCheckSummaryItem, EvidenceDocData,
} from '../types'
const T = DUAL_CHECK_TEXT.approval
@@ -59,24 +62,36 @@ interface MetricView {
full: DualCheckMetric | null
}
/** 盲算一边的输入,约定之外服务端另带核查 agent 组装的理由文档(期 4;老工件没有) */
type BlindInput = DualCheckBlindInput & { rationale_doc?: unknown }
/** 完整对照,约定之外服务端另带几个指标落到同一项上时每种选择组合的预告(期 4;老工件没有) */
type Card = DualCheckCard & { catalog_joint?: unknown }
/**
* 服务端预告的一边:写的话写到哪(where 是 「orders」(shop)的业务日期 这样的说法)、写成什么(value 是给人看的
* 写法,raw 是原样的取值,和别的指标的说法比是不是同一个时用)
* 写到数据目录的哪一项:数据源、表、目录项(business_date / valid_filter / dedup)。服务端写目录前按这三样归拢同一次
* 裁决里的几个指标;where 是给人看的说法(「orders」(shop)的业务日期)
*/
interface Target { table: string; source: string | null; item: string; where: string }
/**
* 服务端预告的一边。写的:写到哪、写成什么(value 是给人看的写法,raw 是原样的取值,和别的指标的说法比是不是同一个时
* 用)。不写的:reason 是服务端的原话;认出了事实、只是被目录挡下的(已确认、驳回过、和已有条件合不起来)另带 target
* 和本来要写的 raw——服务端照样会把它和落到同一项上的别的指标归拢,卡上据此认同一项上有谁
*/
type PreviewSide =
| { write: true; table: string; source: string | null; item: string; where: string; value: string; raw: unknown }
| { write: false }
type WritingSide = Extract<PreviewSide, { write: true }>
| { write: true; target: Target; value: string; raw: unknown }
| { write: false; target: Target | null; reason: string | null; raw?: unknown }
interface CatalogPreview { a: PreviewSide; b: PreviewSide }
/**
* 同一次裁决里,别的指标按当前的选择落到同一项上(同一数据源、同一张表、同一项)的:differ 是说法和这一边不同的指标名
* ——业务日期、去重规则说法不同时服务端一项都不写;joined 是条件和这一边不同的指标名——有效记录条件用 AND 合成一句写
* 对照工件里的 catalog_joint(dual_check_facts.preview_joint):几个指标按各自的选择落到同一项上时,服务端按真写的办法
* 算好的每个指标的结果。members 是落到这一项上的指标和各自的选择,outcomes 按指标 id 给结果
*/
interface Peers { differ: string[]; joined: string[] }
type PreviewPeers = Partial<Record<'a' | 'b', Peers>>
interface JointOutcome { write: boolean; raw?: unknown; reason?: string | null }
interface JointEntry { source: string | null; table: string; item: string; members: Map<string, DualCheckChoice>; outcomes: Map<string, JointOutcome> }
const str = (v: unknown): string | undefined => (typeof v === 'string' && v ? v : undefined)
const isRecord = (v: unknown): v is Record<string, unknown> => !!v && typeof v === 'object' && !Array.isArray(v)
const num = (v: unknown): number | undefined => (typeof v === 'number' && Number.isFinite(v) ? v : undefined)
const hasSql = (v: unknown): boolean => typeof v === 'string' && !!v.trim()
@@ -88,9 +103,9 @@ function summaryOf(raw: unknown): DualCheckSummaryItem[] {
}
/** 工件内容像不像一份对照:至少得有 metrics 数组,里面的项带 metric_id */
function cardOf(content: unknown): DualCheckCard | null {
if (!content || typeof content !== 'object' || !Array.isArray((content as DualCheckCard).metrics)) return null
const card = content as DualCheckCard
function cardOf(content: unknown): Card | null {
if (!content || typeof content !== 'object' || !Array.isArray((content as Card).metrics)) return null
const card = content as Card
return { ...card, metrics: card.metrics.filter((m) => !!m && typeof m === 'object' && typeof m.metric_id === 'string') }
}
@@ -117,22 +132,23 @@ function catalogOf(metric: DualCheckMetric, items: { aspect: string; text: strin
return CATALOG_ASPECTS.has(items[0].aspect) ? items[0].aspect as CatalogAspect : null
}
/** 预告的一边:写的得有表、认得出的目录项和取值;认不出返回 undefined */
function previewSideOf(raw: unknown): PreviewSide | undefined {
if (!raw || typeof raw !== 'object') return undefined
const s = raw as Record<string, unknown>
if (s.write === false) return { write: false }
/** 预告里写到哪:得有表、认得出的目录项;认不出为 null */
function targetOf(s: Record<string, unknown>): Target | null {
const table = str(s.table)
const item = str(s.item)
if (s.write !== true || !table || !item || !Object.hasOwn(CATALOG_TABLE_FIELD_LABEL, item) || s.value == null || s.value === '') {
return undefined
}
if (!table || !item || !Object.hasOwn(CATALOG_TABLE_FIELD_LABEL, item)) return null
const source = str(s.source) ?? null
const label = CATALOG_TABLE_FIELD_LABEL[item as keyof typeof CATALOG_TABLE_FIELD_LABEL]
return {
write: true, table, source, item,
where: DUAL_CHECK_TEXT.log.catalogItem(table, source ?? undefined, label), value: patchValueText(item, s.value), raw: s.value,
}
return { table, source, item, where: DUAL_CHECK_TEXT.log.catalogItem(table, source ?? undefined, label) }
}
/** 预告的一边:写的得有写到哪和取值;不写的有没有写到哪都认(老服务端只给原因);认不出返回 undefined */
function previewSideOf(raw: unknown): PreviewSide | undefined {
if (!isRecord(raw)) return undefined
if (raw.write === false) return { write: false, target: targetOf(raw), reason: str(raw.reason) ?? null, raw: raw.value }
const target = targetOf(raw)
if (raw.write !== true || !target || raw.value == null || raw.value === '') return undefined
return { write: true, target, value: patchValueText(target.item, raw.value), raw: raw.value }
}
/**
@@ -146,11 +162,37 @@ function previewOf(raw: unknown): CatalogPreview | null {
return a && b ? { a, b } : null
}
/** 两边写的是不是同一个数据源、同一张表的同一项(服务端写目录前按这三样归拢) */
const sameTarget = (a: PreviewSide, b: PreviewSide): boolean =>
a.write && b.write && a.table === b.table && a.source === b.source && a.item === b.item
/** 是不是同一个数据源、同一张表的同一项(服务端写目录前按这三样归拢) */
const sameTarget = (a: Pick<Target, 'table' | 'source' | 'item'> | null | undefined,
b: Pick<Target, 'table' | 'source' | 'item'> | null | undefined): boolean =>
!!a && !!b && a.table === b.table && a.source === b.source && a.item === b.item
const isRecord = (v: unknown): v is Record<string, unknown> => !!v && typeof v === 'object' && !Array.isArray(v)
/**
* 对照工件里的 catalog_joint:认不出的条目跳过(宁可这一项回到有条件地说,不替服务端编)。每条要有写到哪、至少两个
* 成员、每个成员都有结果
*/
function jointOf(card: Card | null): JointEntry[] {
const raw = card?.catalog_joint
if (!Array.isArray(raw)) return []
const out: JointEntry[] = []
for (const e of raw) {
if (!isRecord(e) || !Array.isArray(e.members) || !isRecord(e.outcomes)) continue
const table = str(e.table)
const item = str(e.item)
if (!table || !item) continue
const members = new Map<string, DualCheckChoice>()
for (const m of e.members) {
if (isRecord(m) && str(m.metric_id) && (m.choice === 'a' || m.choice === 'b')) members.set(m.metric_id as string, m.choice)
}
const outcomes = new Map<string, JointOutcome>()
for (const [id, o] of Object.entries(e.outcomes)) {
if (isRecord(o) && typeof o.write === 'boolean') outcomes.set(id, { write: o.write, raw: o.value, reason: str(o.reason) ?? null })
}
if (members.size < 2 || [...members.keys()].some((id) => !outcomes.has(id))) continue
out.push({ source: str(e.source) ?? null, table, item, members, outcomes })
}
return out
}
/** 同一项的两个说法是不是同一个(同服务端的 _same_fact):业务日期只看哪一列,其余是文字、压掉多余的空白比 */
function sameFact(item: string, a: unknown, b: unknown): boolean {
if (item === 'business_date') return isRecord(a) && isRecord(b) && a.column === b.column
@@ -158,36 +200,110 @@ function sameFact(item: string, a: unknown, b: unknown): boolean {
return typeof a === 'string' && typeof b === 'string' && flat(a) === flat(b)
}
/** 预告里的一条:说什么、这一选会不会写,以及是怎么说出来的(data-* 标记,检查脚本据此核对) */
interface Clause {
side: DualCheckChoice
text: string
write: boolean
/** 句子里写明了是哪张表的哪一项:同一项的下一条可以省掉 */
where: boolean
/** 服务端说不写、给了原因 */
reason: boolean
/** 照服务端算好的合并结果说(catalog_joint) */
joint: boolean
/** 合并结果里和别的指标一起记入 */
together: boolean
/**
* 没有算好的合并结果、按其余指标当前的选择推的:说法不同都不记(conflict)、有效记录条件合写(joined)、同一项上有被
* 目录挡下的指标,写不写说不准、只说可能(pending)。inferred:这一条是推出来的(以上几种,以及推的路上照单个指标的
* 预告说的),结尾换成「以时间线上的记录为准」的一般说法
*/
conflict: boolean
joined: boolean
pending: boolean
inferred: boolean
}
/**
* 每个指标的预告是单独算的,服务端写目录前却把同一次裁决里落到同一张表同一项上的说法归拢成一项
* (dual_check_facts._merged):业务日期一张表只有一个、去重规则说的未必是同一件事,说法不同就一项都不写;有效记录
* 条件都在排除无效记录,用 AND 合成一句写。这里按其余指标当前的选择,给每个指标的两种选择各找出落到同一项上的指标
* (见 Peers),卡上照它说。只看预告会写的一边:选「两边都不对」、还没选的,服务端不会并进来;预告说不写的,多半是
* 差异对不上目录项,服务端同样不并。少数是因为目录里已有的说法才不写,服务端仍会把它并进来、可能让这一项都不写,
* 可预告里没有它落到哪一项,卡上看不出,所以结尾说以时间线上的记录为准
* 每个指标三个选择各一条预告。预告是每个指标单独算的,服务端写目录前却把同一次裁决里落到同一张表同一项上的说法归拢成
* 一项(dual_check_facts._merged、_screen、_plan)。按其余指标当前的选择,找出这一选落到同一项上的指标(选了 a、b,
* 那一边认出了写到哪的;被目录挡下的也算——服务端照样并进来):
* - 只有它自己:照它自己的预告说,会写的说会记为什么,不写的说原因;
* - 还有别的:照对照工件里服务端为这几个成员算好的那一条(catalog_joint)说,会写的是合起来的值、写明和谁一起记,
* 不写的照原因说;工件里没有(老服务端、组合太多、工件还没取到)时照服务端归拢的先后推(inferred),被目录挡下的
* 同项指标也算进来——服务端先归拢、后对目录:
* - 业务日期、去重规则:有一个说法不同(不论它会不会被目录挡下),归拢就失败,都不记;说法都一样时结果和单个指标
* 一样(同一个说法对同一份目录),照自己的预告说;
* - 有效记录条件:自己被挡下的,合起来也写不进去(驳回过的会被拿掉,别的原因连合起来的整句一起挡下),照自己的原因说;
* 同项上有别的指标被挡下时说不准(挡下它的若是驳回,拿掉它照写;若是别的原因,这一边也一起挡下),只说可能;
* 都会写、条件不同的说合成一句
* 推出来的不是服务端算好的结果,结尾换成以时间线上的记录为准的一般说法
*/
function peersOf(views: MetricView[], choices: Record<string, DualCheckChoice>): Map<string, PreviewPeers> {
const adopted: { id: string; name: string; side: WritingSide }[] = []
for (const v of views) {
const c = choices[v.id]
const side = c === 'a' || c === 'b' ? v.preview?.[c] : undefined
if (side?.write) adopted.push({ id: v.id, name: v.name, side })
function clausesOf(view: MetricView, views: MetricView[], choices: Record<string, DualCheckChoice>, joint: JointEntry[]): Clause[] {
const P = T.catalogPreview
const blank = {
write: false, where: false, reason: false, joint: false, together: false, conflict: false, joined: false, pending: false, inferred: false,
}
const out = new Map<string, PreviewPeers>()
for (const v of views) {
const peers: PreviewPeers = {}
for (const c of ['a', 'b'] as const) {
const mine = v.preview?.[c]
if (!mine?.write) continue
// 说法和这一边不同的指标:业务日期、去重规则让整组都不写,有效记录条件要合成一句
const names = [...new Set(adopted
.filter((o) => o.id !== v.id && sameTarget(o.side, mine) && !sameFact(mine.item, o.side.raw, mine.raw))
.map((o) => o.name))]
if (!names.length) continue
peers[c] = mine.item === 'valid_filter' ? { differ: [], joined: names } : { differ: names, joined: [] }
const skip = (side: DualCheckChoice): Clause => ({ side, text: P.skip(T.choices[side]), ...blank })
const out: Clause[] = []
for (const side of ['a', 'b'] as const) {
const mine = view.preview?.[side]
if (!mine) { out.push(skip(side)); continue }
const blocked = (reason: string | null | undefined): Clause =>
(reason ? { side, text: P.blocked(T.choices[side], reason), ...blank, reason: true } : skip(side))
// 前一条已经写明了是哪张表的哪一项,这一条省掉
const short = side === 'b' && !!out[0]?.where && sameTarget(view.preview?.a.target, mine.target)
const writing = (value: string, extra: Partial<Clause> = {}, tail = ''): Clause => ({
side, ...blank, write: true, where: !short, ...extra,
text: (short ? P.writeSame(T.choices[side], value) : P.write(T.choices[side], mine.target!.where, value)) + tail,
})
const peers = mine.target ? views.filter((o) => {
const c = choices[o.id]
return o.id !== view.id && (c === 'a' || c === 'b') && sameTarget(o.preview?.[c]?.target, mine.target)
}) : []
if (!peers.length) {
out.push(mine.write ? writing(mine.value) : blocked(mine.reason))
continue
}
out.set(v.id, peers)
const members = new Map<string, DualCheckChoice>([[view.id, side], ...peers.map((o) => [o.id, choices[o.id]] as [string, DualCheckChoice])])
const entry = joint.find((e) => sameTarget(e, mine.target)
&& e.members.size === members.size && [...members].every(([id, c]) => e.members.get(id) === c))
const outcome = entry?.outcomes.get(view.id)
if (entry && outcome) {
if (!outcome.write || outcome.raw == null || outcome.raw === '') {
out.push({ ...blocked(outcome.reason), joint: true })
continue
}
// 一起记入的:结果也是写的那几个成员(拿掉驳回的、没写进去的不算)
const with_ = peers.filter((o) => entry.outcomes.get(o.id)?.write).map((o) => o.name)
out.push(writing(patchValueText(entry.item, outcome.raw), { joint: true, together: with_.length > 0 },
with_.length ? P.together(P.metricNames(with_)) : ''))
continue
}
// 没有算好的合并结果:照服务端归拢的先后推。同项上的指标不论会写还是被挡下都带着本来要写的说法(raw),一起算
const item = mine.target!.item
const theirs = peers.map((o) => ({ name: o.name, side: o.preview![choices[o.id] as 'a' | 'b']! }))
// 认不出本来要写什么(没带 raw)的不算说法不同:说不准,落到下面的「可能」里
const differ = [...new Set(theirs.filter((t) => t.side.raw != null && !sameFact(item, t.side.raw, mine.raw)).map((t) => t.name))]
const held = [...new Set(theirs.filter((t) => !t.side.write).map((t) => t.name))]
const inferred = { inferred: true }
if (differ.length && item !== 'valid_filter') {
// 业务日期、去重规则说法不同:归拢这一步就不写了,轮不到对目录,挡下的那个也一样
const names = P.metricNames(differ)
out.push({ side, ...blank, ...inferred, conflict: true, where: !short,
text: short ? P.conflictSame(T.choices.b, names) : P.conflict(T.choices[side], mine.target!.where, names) })
continue
}
if (!mine.write) { out.push({ ...blocked(mine.reason), ...inferred }); continue }
if (held.length) {
const names = P.metricNames(held)
out.push({ side, ...blank, ...inferred, pending: true, where: !short,
text: short ? P.pendingSame(T.choices[side], mine.value, names) : P.pending(T.choices[side], mine.target!.where, mine.value, names) })
continue
}
out.push(differ.length ? writing(mine.value, { ...inferred, joined: true }, P.joined(P.metricNames(differ))) : writing(mine.value, inferred))
}
out.push(skip('neither'))
return out
}
@@ -302,7 +418,7 @@ export function DualCheckApproval({ approval, onResolved }: DualCheckApprovalPro
const cardId = str(payload.card_artifact) ?? ''
const onReject = useOnReject(approval.run_id, str(payload.node_id) ?? str(approval.node_id), payload.on_reject)
const [card, setCard] = useState<{ id: string; data?: DualCheckCard | null } | null>(null)
const [card, setCard] = useState<{ id: string; data?: Card | null } | null>(null)
useEffect(() => {
if (!cardId) return
let alive = true
@@ -324,8 +440,10 @@ export function DualCheckApproval({ approval, onResolved }: DualCheckApprovalPro
const [note, setNote] = useState('')
const [busy, setBusy] = useState(false)
const pending = views.filter((v) => !choices[v.id]).length
// 预告要按其余指标当前的选择补上「同一项上说法不同」「合成一句」:选择一变,各块的说法跟着变
const peers = useMemo(() => peersOf(views, choices), [views, choices])
// 预告要按其余指标当前的选择算:几个指标落到同一项上时照完整对照里服务端算好的合并结果说,选择一变,各块跟着变
const joint = useMemo(() => jointOf(data), [data])
const clauses = useMemo(() => new Map(views.map((v) => [v.id, clausesOf(v, views, choices, joint)])),
[views, choices, joint])
/** 提交裁决(approved 为真,value 是 {choices, note})或驳回(认不出指标时的出口) */
const send = async (approved: boolean) => {
@@ -397,7 +515,7 @@ export function DualCheckApproval({ approval, onResolved }: DualCheckApprovalPro
) : (
<>
{views.map((v) => (
<MetricBlock key={v.id} view={v} name={`${uid}-${v.id}`} choice={choices[v.id]} peers={peers.get(v.id)}
<MetricBlock key={v.id} view={v} name={`${uid}-${v.id}`} choice={choices[v.id]} clauses={clauses.get(v.id) ?? []}
onChoose={(c) => setChoices((cur) => ({ ...cur, [v.id]: c }))} />
))}
@@ -423,8 +541,8 @@ export function DualCheckApproval({ approval, onResolved }: DualCheckApprovalPro
}
/** 一个不一致的指标:名字、两个值、相差多少、差异说明、对照两条 SQL、三选一 */
function MetricBlock({ view, name, choice, peers, onChoose }: {
view: MetricView; name: string; choice?: DualCheckChoice; peers?: PreviewPeers; onChoose: (c: DualCheckChoice) => void
function MetricBlock({ view, name, choice, clauses, onChoose }: {
view: MetricView; name: string; choice?: DualCheckChoice; clauses: Clause[]; onChoose: (c: DualCheckChoice) => void
}) {
const uid = useId()
// 只有兜底说明(或只有解析失败)时默认展开:一条具体说法都没有,审核人只能对照原文判断
@@ -484,7 +602,8 @@ function MetricBlock({ view, name, choice, peers, onChoose }: {
{expanded && view.full && <Compare id={`${uid}-cmp`} metric={view.full} />}
{view.preview ? (
// 服务端预告了:两边都不写就不提数据目录
(view.preview.a.write || view.preview.b.write) && <CatalogPreviewNote preview={view.preview} peers={peers} choice={choice} />
// 服务端预告了:两边都认不出可记的事实(都没有写到哪)就不提数据目录
(view.preview.a.target || view.preview.b.target) && <CatalogPreviewNote clauses={clauses} choice={choice} />
) : view.catalog && (
<p className="mt-1.5 text-2xs leading-relaxed text-dim" data-dual-catalog={view.catalog}>{T.catalog[view.catalog]}{T.catalog.tail}</p>
)}
@@ -509,50 +628,30 @@ function MetricBlock({ view, name, choice, peers, onChoose }: {
)
}
/** 预告里的一句:说什么、这一选会不会写(说法不同、都不写的不算)、是不是说法不同、是不是要和别的条件合写 */
interface Clause { side: DualCheckChoice; text: string; write: boolean; conflict: boolean; joined: boolean }
/**
* 服务端预告的「记入数据目录」:三个选择各一句,审核人当前选的那一句加重——选之前三句都看得到,选了之后一眼看出这一选
* 会往目录里写什么。两边写的是同一项(只差取值,比如业务日期按哪一列)时,后一句省掉「哪张表的哪一项」。
* peers 是同一次裁决里别的指标按当前的选择落到同一项上的(peersOf):说法不同的这一句改说都不记,有效记录条件补一句
* 合写;选择变了跟着变
* 服务端预告的「记入数据目录」:三个选择逐条一句(clausesOf),审核人当前选的那一条加重——选之前三条都看得到,选了之后
* 一眼看出这一选会往目录里写什么、不写的为什么。不写的原因是服务端的原话,往往不短,逐条分行写,不挤在一句里。有一条
* 是推出来的(没有算好的合并结果)时,结尾换成「实际写入以时间线上的记录为准」的一般说法
*/
function CatalogPreviewNote({ preview, peers, choice }: { preview: CatalogPreview; peers?: PreviewPeers; choice?: DualCheckChoice }) {
function CatalogPreviewNote({ clauses, choice }: { clauses: Clause[]; choice?: DualCheckChoice }) {
const P = T.catalogPreview
const skip = (side: DualCheckChoice): Clause => ({ side, text: P.skip(T.choices[side]), write: false, conflict: false, joined: false })
const clause = (side: 'a' | 'b'): Clause => {
const s = preview[side]
if (!s.write) return skip(side)
// 前一句已经写明了是哪张表的哪一项(说法不同的那句也写),这一句省掉
const short = side === 'b' && sameTarget(preview.a, s)
const { differ = [], joined = [] } = peers?.[side] ?? {}
if (differ.length) {
const names = P.metricNames(differ)
const text = short ? P.conflictSame(T.choices.b, names) : P.conflict(T.choices[side], s.where, names)
return { side, text, write: false, conflict: true, joined: false }
}
const text = short ? P.writeSame(T.choices.b, s.value) : P.write(T.choices[side], s.where, s.value)
return joined.length
? { side, text: text + P.joined(P.metricNames(joined)), write: true, conflict: false, joined: true }
: { side, text, write: true, conflict: false, joined: false }
}
const clauses = [clause('a'), clause('b'), skip('neither')]
const inferred = clauses.some((c) => c.inferred)
return (
<p className="mt-1.5 text-2xs leading-relaxed text-dim [overflow-wrap:anywhere]" data-dual-catalog="preview">
{P.head}
{clauses.map(({ side, text, write, conflict, joined }, i) => (
<Fragment key={side}>
{i > 0 && ';'}
<span className={clsx(choice === side && 'font-medium')} style={choice === side ? { color: 'var(--text)' } : undefined}
data-dual-catalog-side={side} data-write={write ? '' : undefined} data-current={choice === side ? '' : undefined}
data-conflict={conflict ? '' : undefined} data-joined={joined ? '' : undefined}>
{text}
</span>
</Fragment>
))}
{P.tail}
</p>
<div className="mt-1.5 text-2xs leading-relaxed text-dim [overflow-wrap:anywhere]" data-dual-catalog="preview">
<div>{P.head}</div>
<ul className="mt-0.5 list-disc space-y-0.5 pl-4">
{clauses.map((c) => (
<li key={c.side} className={clsx(choice === c.side && 'font-medium')} style={choice === c.side ? { color: 'var(--text)' } : undefined}
data-dual-catalog-side={c.side} data-write={c.write ? '' : undefined} data-current={choice === c.side ? '' : undefined}
data-reason={c.reason ? '' : undefined} data-joint={c.joint ? '' : undefined} data-together={c.together ? '' : undefined}
data-conflict={c.conflict ? '' : undefined} data-joined={c.joined ? '' : undefined}
data-pending={c.pending ? '' : undefined} data-inferred={c.inferred ? '' : undefined}>
{c.text}
</li>
))}
</ul>
<p className="mt-0.5" data-dual-catalog-tail={inferred ? 'inferred' : 'exact'}>{inferred ? P.tailInferred : P.tail}</p>
</div>
)
}
@@ -560,7 +659,7 @@ function CatalogPreviewNote({ preview, peers, choice }: { preview: CatalogPrevie
interface Pair {
path: string
original?: DualCheckInput
blind?: DualCheckBlindInput
blind?: BlindInput
source: string | null
/** SQL 或取到的值不同 */
differs: boolean
@@ -576,7 +675,7 @@ const sameValue = (a: unknown, b: unknown): boolean => {
}
function pairsOf(metric: DualCheckMetric): Pair[] {
const byPath = new Map<string, { original?: DualCheckInput; blind?: DualCheckBlindInput }>()
const byPath = new Map<string, { original?: DualCheckInput; blind?: BlindInput }>()
const valid = (i: unknown): i is DualCheckInput => !!i && typeof i === 'object' && typeof (i as DualCheckInput).path === 'string'
for (const i of (Array.isArray(metric.original?.inputs) ? metric.original.inputs : []).filter(valid)) {
byPath.set(i.path, { ...byPath.get(i.path), original: i })
@@ -710,15 +809,47 @@ function PairSql({ pair }: { pair: Pair }) {
<SqlPane side="original" label={T.sqlOriginal} lines={a} marks={diff?.a} />
<SqlPane side="blind" label={T.sqlBlind} lines={b} marks={diff?.b} />
</div>
{str(pair.blind?.rationale) && (
<p className="mt-1 text-2xs leading-relaxed text-dim [overflow-wrap:anywhere]" data-dual-rationale="">
<span className="text-faint">{T.rationale}:</span>{pair.blind!.rationale}
</p>
)}
<BlindRationale input={pair.blind} />
</div>
)
}
/** 理由文档里有没有没出处的数字(evidence.compose_doc 标出的裸数字,状态是「无证据」) */
const hasBare = (doc: EvidenceDocData): boolean =>
(doc.blocks ?? []).some((b) => (b.units ?? []).some((u) => (u.segments ?? []).some((seg) => segmentState(seg) === 'none')))
/**
* 盲算的说明。工件带了核查 agent 组装的理由文档(rationale_doc)时按文档画,和反方审稿的理由同一种画法:数字有出处的
* 画实线、挂盲算自己的查询编号(悬停看出处),裸数字画点状线、句末挂「无证据」,下面再醒目地说一句。老工件只有渲染后的
* 正文,照旧显示纯文本
*/
function BlindRationale({ input }: { input?: BlindInput }) {
const doc = useMemo(() => {
const raw = input?.rationale_doc
const parsed = raw && typeof raw === 'object' ? asDoc(raw) : null
return parsed && (parsed.blocks ?? []).length ? parsed : null
}, [input?.rationale_doc])
if (doc) {
return (
<div className="mt-1 min-w-0 text-2xs leading-relaxed text-dim [overflow-wrap:anywhere]" data-dual-rationale="doc">
<div className="text-faint">{T.rationale}</div>
<RationaleDoc doc={doc} />
{hasBare(doc) && (
<p className="mt-0.5 flex items-start gap-1 font-medium" style={{ color: 'var(--st-waiting)' }} data-dual-rationale-bare="">
<AlertTriangle size={11} aria-hidden className="mt-[3px] shrink-0" /> {T.rationaleBare}
</p>
)}
</div>
)
}
if (!str(input?.rationale)) return null
return (
<p className="mt-1 text-2xs leading-relaxed text-dim [overflow-wrap:anywhere]" data-dual-rationale="text">
<span className="text-faint">{T.rationale}:</span>{input!.rationale}
</p>
)
}
/** 一条 SQL 原文:逐行画,marks 里的行(按行比出的不同行)高亮;空白行不标 */
function SqlPane({ side, label, lines, marks }: { side: 'original' | 'blind'; label: string; lines: string[] | null; marks?: Set<number> }) {
return (
+76 -12
View File
@@ -3,7 +3,7 @@ import type { NodeState, RunPhase } from './trace'
import { formatDuration, formatNumber } from '../lib/format'
import {
ABSENCE_CLAIM_TEXT, CATALOG_DRIFT_TEXT, CATALOG_PATCH_TEXT, COPILOT_CONTEXT_TEXT, JUDGE_TEXT, MERGE_TEXT, RUN_SQL_CHECK_TEXT, SCHEMA_PARTIAL_TEXT, SQL_CHECK_TEXT, TYPE_LABEL,
CATALOG_TABLE_FIELD_LABEL, DUAL_CHECK_TEXT,
CATALOG_TABLE_FIELD_LABEL, CHALLENGE_TEXT, DUAL_CHECK_TEXT, NODE_TYPE_LABEL,
claimTally,
evidenceTally, issuanceLabel, nodeTypeLabel,
} from '../lib/terms'
@@ -717,16 +717,41 @@ function gateTitle(tool: string, verdict: 'allow' | 'escalate' | 'team', reason:
/**
* 双盲复算、反方审稿的日志代码(期 3 前后端共用的约定)。这几条按 code 和结构化字段解读,不看原话;后端发成 info 的
* (一致、裁决、记入数据目录、审稿完成)也上时间线,不然这两种节点就是一个跑了几十秒、什么都没说的黑盒
* (一致、裁决、记入数据目录、审稿完成)也上时间线,不然这两种节点就是一个跑了几十秒、什么都没说的黑盒。
* 无法复算(dual_check_unchecked)、未能反查(challenge_unreviewed)、只查了部分数据源(challenge_sources_lost)是
* 期 4 补上的:以前认不得,只能照原话显示
*/
const VERIFY_LOG_CODES = new Set([
'dual_check_skipped', 'dual_check_same_model', 'dual_check_agreed', 'dual_check_disagreed', 'dual_check_resolved',
'dual_check_catalog', 'dual_check_limit',
'dual_check_catalog', 'dual_check_limit', 'dual_check_unchecked',
'challenge_skipped', 'challenge_same_model', 'challenge_done', 'challenge_refuted', 'challenge_limit',
'challenge_unreviewed', 'challenge_sources_lost',
])
const DC = DUAL_CHECK_TEXT
const CL = DUAL_CHECK_TEXT.challengeLog
const CL = CHALLENGE_TEXT.log
/**
* 出具缺口里哪几条是双盲复算、反方审稿报上来的:出具契约给上游节点报的缺口加了「节点类型「节点名」:」的前缀
* (nodes/io.py 的 _upstream_issuance_gaps,节点名就是类型叫法时只写「节点类型:」),按这两种节点类型的叫法认。
* 时间线、成果卡片、证据页把它们另起,不和「校验没跑全」的缺口混在一起,再分两组(叫法在 DUAL_CHECK_TEXT.verifyGaps):
* - failed「核查未通过」:核查查出来的问题——两路结果不一致(审核人选了盲算、两边都不对、没作出选择),结论被推翻;
* - unfinished「核查未完成」:没核成的——指标无法复算(nodes/dual_check.py 的 GAP_UNCHECKED「指标「X」无法复算:原因」)。
* 合并查询、遮罩列的输入做不了复算,盲算触顶、出错的也没核过,说成「未通过」读的人会以为这个数被查出了错。
* 其余的照旧
*/
const VERIFY_GAP_KINDS = [NODE_TYPE_LABEL.dual_check, NODE_TYPE_LABEL.challenge]
const escapeRe = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
/** 双盲复算报的「无法复算」:前缀(节点名可有可无)之后紧跟 GAP_UNCHECKED 的开头 */
const UNCHECKED_GAP = new RegExp(`^${escapeRe(NODE_TYPE_LABEL.dual_check)}(?:「.*?」)?:指标「.+?」无法复算:`)
export function splitIssuanceGaps(gaps: readonly string[]): { failed: string[]; unfinished: string[]; other: string[] } {
const out = { failed: [] as string[], unfinished: [] as string[], other: [] as string[] }
for (const g of gaps) {
const verify = VERIFY_GAP_KINDS.some((kind) => g.startsWith(`${kind}「`) || g.startsWith(`${kind}:`))
;(!verify ? out.other : UNCHECKED_GAP.test(g) ? out.unfinished : out.failed).push(g)
}
return out
}
const isRecord = (v: unknown): v is Record<string, any> => !!v && typeof v === 'object' && !Array.isArray(v)
/** 老日志、别的服务端版本可能给的是一句中文原因而不是代码:中文的照写,认不得的代码不往界面上放 */
const cjkText = (v: unknown): string | undefined => (typeof v === 'string' && /[㐀-鿿]/.test(v) ? v : undefined)
@@ -1034,16 +1059,18 @@ function explainLog(code: string | undefined, message: string, d: Record<string,
return { title: DC.log.resolved(parts), sub: gaps != null ? DC.log.gaps(gaps) : undefined, level: warn ? 'warn' : 'info' }
}
case 'dual_check_catalog': {
// written:[{source, table, item}] 写进数据目录的已确认事实;skipped:[{reason}] 没写的(已有已确认的不覆盖……)。
// written:[{source, table, item, value}] 写进数据目录的已确认事实;skipped:[{reason}] 没写的(已有已确认的不覆盖……)。
// item 是表级目录项的键(business_date / valid_filter / dedup),按数据目录页的叫法写;认不出的键不往界面上放,
// 只写表;老版本给的一句中文照写
// 只写表;老版本给的一句中文照写。value 是写进去的说法(期 4 起带),写法同审批卡上的「会记为」,两处一字不差
const written = Array.isArray(d.written) ? d.written.filter(isRecord) : []
const skipped = Array.isArray(d.skipped) ? d.skipped.filter(isRecord) : []
const what = written.map((w) => {
const key = str(w.item)
const item = key && Object.hasOwn(CATALOG_TABLE_FIELD_LABEL, key)
? CATALOG_TABLE_FIELD_LABEL[key as keyof typeof CATALOG_TABLE_FIELD_LABEL] : cjkText(key)
return DC.log.catalogItem(str(w.table), str(w.source), item)
const known = !!key && Object.hasOwn(CATALOG_TABLE_FIELD_LABEL, key)
const item = known ? CATALOG_TABLE_FIELD_LABEL[key as keyof typeof CATALOG_TABLE_FIELD_LABEL] : cjkText(key)
const where = DC.log.catalogItem(str(w.table), str(w.source), item)
const value = known && w.value != null && w.value !== '' ? patchValueText(key, w.value) : ''
return where && value ? DC.log.catalogValue(where, value) : where
}).filter(Boolean)
const why = skipped.map((s) => str(s.reason)).filter((r): r is string => !!r)
const rest = skipped.length ? `${DC.log.catalogSkipped(skipped.length)}${why.length ? `:${why.join(';')}` : ''}` : ''
@@ -1062,7 +1089,22 @@ function explainLog(code: string | undefined, message: string, d: Record<string,
level: 'warn',
}
}
// ---- 反方审稿:同上,文案在 DUAL_CHECK_TEXT.challengeLog(时间线的解读统一在这里做)
case 'dual_check_unchecked': {
// metrics 是 [{id, name, reason}]:副标题点名、说原因(没起名字的写 id)
const list = Array.isArray(d.metrics) ? d.metrics.filter(isRecord) : []
const parts = list.map((m) => {
const name = str(m.name) ?? str(m.id)
const why = cjkText(m.reason)
return name ? `「${name}」${why ? `:${why}` : ''}` : ''
}).filter(Boolean)
return {
title: DC.log.unchecked(list.length || undefined),
sub: parts.length ? parts.join(';') : undefined,
next: DC.log.uncheckedNext,
level: 'warn',
}
}
// ---- 反方审稿:同上,文案在 CHALLENGE_TEXT.log(时间线的解读统一在这里做)
case 'challenge_skipped': {
const reason = str(d.reason)
if (reason === 'disabled') {
@@ -1107,6 +1149,25 @@ function explainLog(code: string | undefined, message: string, d: Record<string,
level: 'warn',
}
}
case 'challenge_unreviewed': {
// claims_skipped:未能反查的句数;reason:第一句未能反查的原因(一句中文)
return {
title: CL.unreviewed(countOf(d.claims_skipped) || undefined),
sub: cjkText(d.reason),
next: CL.unreviewedNext,
level: 'warn',
}
}
case 'challenge_sources_lost': {
// claims:只查了部分数据源的句数;sources:没查成的数据源名
const names = strs(d.sources)
return {
title: CL.sourcesLost(countOf(d.claims) || undefined),
sub: names.length ? CL.sourcesLostSub(names) : undefined,
next: CL.sourcesLostNext,
level: 'warn',
}
}
default:
return null
}
@@ -2051,8 +2112,11 @@ export function decodeRun(events: RunEvent[], final?: RunFinal, opts?: DecodeOpt
if (d.missing_expected?.length) gaps.push(`缺少期望指标:${d.missing_expected.join('、')}`)
if (num(d.unmatched)) gaps.push(`${d.unmatched} 个数字无法追溯到指标集`)
// 校验本身没跑全(叙述渲染为空、指标集为空)也会降档。不写出来的话,
// 时间线上就是一个光秃秃的「降档出具」,看起来和"全部通过"只差一个字
const notRun: string[] = Array.isArray(d.gaps) ? d.gaps.map(String) : []
// 时间线上就是一个光秃秃的「降档出具」,看起来和"全部通过"只差一个字。
// 双盲复算、反方审稿报上来的缺口另起,按查出了问题、没核成分成两组,不归在「校验不完整」下
const { failed, unfinished, other: notRun } = splitIssuanceGaps(Array.isArray(d.gaps) ? d.gaps.map(String) : [])
if (failed.length) gaps.push(`${DC.verifyGaps.failed}:${failed.join(';')}`)
if (unfinished.length) gaps.push(`${DC.verifyGaps.unfinished}:${unfinished.join(';')}`)
if (notRun.length) gaps.push(`校验不完整:${notRun.join(';')}`)
const checked = [
num(d.metrics_checked) != null ? `核对 ${d.metrics_checked} 个指标` : '',