合入期 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
+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} 个指标` : '',