diff --git a/backend/app/api/evidence.py b/backend/app/api/evidence.py index 1ae739d8..a67d4e20 100644 --- a/backend/app/api/evidence.py +++ b/backend/app/api/evidence.py @@ -23,6 +23,8 @@ options.mask_columns 里的列换成「已遮罩」——在有身份体系之 期 4 的核查状态同样只读封存范围内的东西：指标步骤带双盲复算的结果（_dual_check_of，读双盲复算节点的产出和台账 条目），句子带反方审稿的判断（_challenge_of，读反方审稿节点的产出和审稿记录）。它们是核查，不是证据：没有就不带这两个键。 +证据图的每份报告另带一张被反方审过的句子 → 判断的表（_challenge_verdicts，和 _challenge_of 同一个读法），正文据此挂 +句末标记，不用逐句请求片段接口。 结论句的判定（四期）是模型给的，不是证据：正式运行的判定在报告文档里、随文档封存；探索运行 按需裁判（POST …/evidence/judge），判定作为 evidence.judged 事件追加在封存之后，只填补没判过的 @@ -38,7 +40,7 @@ import logging import re import sqlite3 from collections import OrderedDict -from collections.abc import Callable +from collections.abc import Callable, Iterator from dataclasses import asdict, dataclass, field, replace from pathlib import Path from typing import Any, get_args @@ -362,11 +364,14 @@ async def evidence_graph(run_id: str) -> dict[str, Any]: inputs = _input_payloads(sealed) for report in reports: + # 期 4：被反方审过的句子 → 判断，正文据此给它们挂句末标记。文档读不出来的不给；一句都没审的没有这个键 + marks = _challenge_verdicts(sealed, report) if report.doc is not None else {} body["reports"].append({ "node_id": report.node_id, "doc_artifact": report.doc_artifact, "doc_sealed": sealed.trusted, "hash_ok": report.hash_ok, "ok": report.ok, "repairs": report.repairs, "fields": report.fields, "stats": report.stats, **_judgement_of(report, sealed), + **({"challenge_verdicts": marks} if marks else {}), }) if report.doc is not None: evidence, edges = _graph_of(report, sealed, inputs) @@ -1151,32 +1156,29 @@ def _dual_status(node_id: str, output: dict[str, Any], entry: dict[str, Any] | N _CHALLENGE_VERDICTS = ("stands", "weakened", "refuted", "inconclusive") -def _challenge_of(sealed: _Sealed, report: _Report, unit_id: str) -> dict[str, Any] | None: - """这一句的反方审稿判断：{verdict, node_id, artifact, on_refuted, report_label, counts, unreviewed?}。没审到这一句的 - 是 None。 +def _reviews(sealed: _Sealed, report: _Report + ) -> Iterator[tuple[str, dict[str, Any], str | None, list[dict[str, Any]]]]: + """审的就是正文这一份报告文档的每一次反方审稿，按跑完的先后：(节点, 产出, 审稿记录工件, 逐句的判断)。逐句判断的 + 每一项至少是个 dict，unit、verdict 认不认得由调用方看。片段接口的 unit.challenge（_challenge_of）和证据图的 + challenge_verdicts（_challenge_verdicts）都从这里读，两边说的一定是同一次审稿。 - 只认审的就是正文这一份报告文档的：审稿记录（challenge_artifact）里记着它审的报告节点和文档工件，和这份对上才算—— + 只认审的就是这一份文档的：审稿记录（challenge_artifact）里记着它审的报告节点和文档工件，和这份对上才算—— 报告在审稿之后又重写了（循环、接着跑），同一个句子编号在新的一稿里说的可能是另一句话。记录没存上（产出里的 challenge_artifact 为空）或读不出来时，按画布上它审的报告、和它跑完之前那份报告最后一次自查记下的文档认，判断取 - 产出里列的那几句（最多 10 句，被推翻、被削弱的排在前面），artifact 照产出写（没存上的为空）。几个反方审稿审了同一 - 份文档时取最后跑完、审到了这一句的那个。on_refuted 是实际生效的处置，report_label 是报告节点的名字。 - - counts 是这次审稿四种判断各几句——整份报告的，取节点产出里的那一份；unreviewed 是没能反查的句数，产出里有才带。 - 证据面板借审批卡上的展示画这一句，那一块的概况得是这份报告真实的数，不能凭这一句拼出一个「被推翻 0 句」。 + 产出里列的那几句（最多 10 句，被推翻、被削弱的排在前面），审稿记录工件照产出写（没存上的为空）。 节点设为「报错并停止运行」、又有句子被推翻时，节点报错、没有 node.finished：审完那一刻的 challenge_done 日志记着 - 审稿记录和计数，按它认（只认审稿记录存上了的），on_refuted 为 fail。运行因此失败了，被推翻的是哪几句、反方凭什么， - 证据面板里照样看得到。 + 审稿记录和计数，按它认（只认审稿记录存上了的），产出拼成 {challenge_artifact, counts, on_refuted: fail}。运行因此 + 失败了，被推翻的是哪几句、反方凭什么，证据面板里照样看得到。 """ reviewers = set(sealed.nodes_of("challenge")) - if not reviewers or not unit_id: - return None + if not reviewers: + return spec: GraphSpec | None = None #: 报告节点 → 到这一刻为止它最后一次自查记下的文档 drafts: dict[str, str] = {} #: 反方审稿节点 → 这一次执行里审完时的日志：节点报错时它就是审稿结果 done: dict[str, dict[str, Any]] = {} - found: dict[str, Any] | None = None for _, etype, node_id, data in sealed.events: if not node_id or not isinstance(data, dict): continue @@ -1218,9 +1220,30 @@ def _challenge_of(sealed: _Sealed, report: _Report, unit_id: str) -> dict[str, A if target != report.node_id or drafts.get(target) != report.doc_artifact: continue claims = output.get("items") - claims = [c for c in claims or [] if isinstance(c, dict)] - verdict = next((c.get("verdict") for c in claims if c.get("unit") == unit_id), None) - if not isinstance(verdict, str) or not verdict: + yield node_id, output, artifact, [c for c in claims or [] if isinstance(c, dict)] + + +def _verdict_in(claims: list[dict[str, Any]], unit_id: str) -> str | None: + """一次审稿里这一句的判断：取列着这一句的第一条，判断不是一个词（缺了、空的、不是字符串）时这次审稿不算审到它。""" + verdict = next((c.get("verdict") for c in claims if c.get("unit") == unit_id), None) + return verdict if isinstance(verdict, str) and verdict else None + + +def _challenge_of(sealed: _Sealed, report: _Report, unit_id: str) -> dict[str, Any] | None: + """这一句的反方审稿判断：{verdict, node_id, artifact, on_refuted, report_label, counts, unreviewed?}。没审到这一句的 + 是 None。认哪一次审稿见 _reviews；几个反方审稿审了同一份文档时取最后跑完、审到了这一句的那个。artifact 是审稿记录 + （没存上的为空），on_refuted 是实际生效的处置（节点报错停止运行的是 fail），report_label 是报告节点的名字。 + + counts 是这次审稿四种判断各几句——整份报告的，取节点产出里的那一份；unreviewed 是没能反查的句数，产出里有才带。 + 证据面板单句展示时不画报告级的计数，可「无法判断」是不是因为反查没完成，得拿这两个数对一下。 + """ + if not unit_id: + return None + found: dict[str, Any] | None = None + spec: GraphSpec | None = None + for node_id, output, artifact, claims in _reviews(sealed, report): + verdict = _verdict_in(claims, unit_id) + if verdict is None: continue spec = spec or _spec_of(sealed) writer = spec.node_map().get(report.node_id) if spec else None @@ -1234,6 +1257,20 @@ def _challenge_of(sealed: _Sealed, report: _Report, unit_id: str) -> dict[str, A return found +def _challenge_verdicts(sealed: _Sealed, report: _Report) -> dict[str, str]: + """这份报告里被反方审过的句子 → 判断（证据图 reports[] 的 challenge_verdicts）。正文据此给被审过的句子挂句末标记、 + 点开整句面板：有的被审句子既没有可点的片段、也没有裁判判定，不靠这张表就打不开；也不用为了认出它们逐句请求片段接口。 + + 读法和 _challenge_of 一字不差（同一个 _reviews、同一个 _verdict_in）：每一句取最后跑完、审到了它的那次审稿，所以表里 + 每一句的判断就是点开它时片段接口答的 unit.challenge.verdict。只有被审过的句子；一句都没审的是空表。 + """ + out: dict[str, str] = {} + for _, _, _, claims in _reviews(sealed, report): + units = dict.fromkeys(c.get("unit") for c in claims if isinstance(c.get("unit"), str) and c.get("unit")) + out.update({uid: verdict for uid in units if (verdict := _verdict_in(claims, uid)) is not None}) + return out + + def _challenge_counts(raw: Any, claims: list[dict[str, Any]]) -> dict[str, int]: """四种判断各几句：取节点产出（或审完时的日志）里的计数；一个数都认不出来时按认得的句子数（审稿记录里的是全部， 记录没存上时只有产出里列的那几句）。""" diff --git a/backend/tests/test_evidence_challenge_marks.py b/backend/tests/test_evidence_challenge_marks.py new file mode 100644 index 00000000..79bf33ff --- /dev/null +++ b/backend/tests/test_evidence_challenge_marks.py @@ -0,0 +1,343 @@ +"""证据图上的反方审稿标记（期 4 整合 J3）：GET /api/runs/{id}/evidence 的 reports[] 带 challenge_verdicts（{句子: 判断}）。 + +正文（前端 EvidenceDoc）据此给被反方审过的句子挂句末标记、点开整句面板，不逐句请求片段接口。有的被审句子既没有可点的 +片段、也没有裁判判定（没开裁判的报告里一句纯文字的结论），不靠这张表，正文里就打不开它的整句面板。 + +- 只含被反方审过的句子；读法和片段接口的 unit.challenge（_challenge_of）是同一个来源：审稿记录里记着审的哪份报告文档， + 和这一份对上才算；记录没存上时按画布上审的报告、和它跑完之前那份报告最后一次自查的文档认，判断取产出里列的那几句； + 节点「报错并停止运行」时按审完那一刻的日志认。几个反方审稿审了同一份文档时，每一句取最后跑完、审到了它的那个 +- 每一句的判断和点开它时片段接口答的 unit.challenge.verdict 一字不差 +- 没有反方审稿（或者它直通了、一句都没审）的报告没有这个键，老运行和以前一字不差 + +反方审稿真跑一遍图（虚构的 SQLite 库，模型是 MockChatModel 剧本）；认「哪一次」的边界情形用手写的封存事件。 +""" +from __future__ import annotations + +import asyncio +import json +import sqlite3 +import uuid + +import pytest +from httpx import ASGITransport, AsyncClient +from langchain_core.messages import AIMessage, ToolMessage +from sqlalchemy import delete + +from app.api import evidence +from app.core import artifact_store +from app.core.artifact_store import put_json +from app.data import introspect +from app.data.engine import engines +from app.db.base import SessionLocal +from app.db.models import DataSource, Run, Setting +from app.engine import spend, verify_agent +from app.engine.evidence import iter_units +from app.engine.judge import SPEND_KEY as JUDGE_SPEND_KEY +from app.engine.nodes import challenge as challenge_mod +from app.engine.runner import run_manager +from app.main import app +from app.providers.mock_model import MockChatModel + + +@pytest.fixture(autouse=True) +async def engine_up(): + await run_manager.setup() + + async def clear() -> None: + async with SessionLocal() as session: + await session.execute(delete(Setting).where(Setting.key.in_( + ["verify", "judge", spend.SPEND_KEY, JUDGE_SPEND_KEY]))) + await session.commit() + + await clear() + yield + await clear() + await run_manager.shutdown() + + +@pytest.fixture +async def client(): + async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as c: + yield c + + +def node(nid, ntype, label=None, **config): + return {"id": nid, "type": ntype, "position": {"x": 0, "y": 0}, "data": {"label": label or nid, "config": config}} + + +def chain(*nodes): + return {"nodes": list(nodes), "edges": [{"source": a["id"], "target": b["id"]} for a, b in zip(nodes, nodes[1:])]} + + +async def start(spec: dict) -> Run: + run_id = (await run_manager.start(graph=spec, input_payload={}, run_class="formal")).id + for _ in range(600): + await asyncio.sleep(0.05) + async with SessionLocal() as session: + row = await session.get(Run, run_id) + if row.status in ("succeeded", "failed") and row.manifest_seq is not None: + await run_manager.wait_idle(run_id) + return row + raise AssertionError(f"运行 {run_id} 停在 {row.status}：{row.error}") + + +# -------------------------------------------------------------------------- +# 真跑：虚构的区域月报 +# -------------------------------------------------------------------------- + +PRICED = "claude-sonnet-5" +#: 各区销售额（含退款）：北区 1600、南区 700、西区 300 +QUERY = "SELECT region AS 区域, SUM(amount) AS 销售额 FROM sales GROUP BY region ORDER BY 销售额 DESC" +NET = "SELECT region AS 区域, SUM(amount) AS 净销售额 FROM sales WHERE refunded = 0 GROUP BY region ORDER BY 净销售额 DESC" +REFUNDS = "SELECT COUNT(*) AS 退款笔数 FROM sales WHERE refunded = 1" +#: 标题、一句有依据的结论、一句预埋的错误结论（南区其实低于北区）。后一句只有文字：没有可点的片段 +TEXT = "## 区域月报\n\n北区销售额 [[v:Q1.r0.销售额]]，居各区之首。[[see:Q1]]南区销售额超过北区。[[see:Q1]]" +NORTH, SOUTH = "北区销售额 1,600，居各区之首。", "南区销售额超过北区。" +PLAYS = { + "南区销售额超过北区": ([NET], "refuted", "扣除退款后南区为 [[v:Q1.r1.净销售额]]，仍低于北区的 [[v:Q1.r0.净销售额]]。[[see:Q1]]"), + "居各区之首": ([REFUNDS], "weakened", "北区含 [[v:Q1.r0.退款笔数]] 笔退款，扣除后仍居首，但销售额被高估。"), +} + + +@pytest.fixture +async def sales(tmp_path): + path = tmp_path / f"{uuid.uuid4().hex[:8]}.db" + db = sqlite3.connect(path) + db.executescript( + "CREATE TABLE sales (id INTEGER PRIMARY KEY, region TEXT, amount INTEGER, refunded INTEGER);" + "INSERT INTO sales VALUES (1, '北区', 1250, 0), (2, '北区', 350, 1), (3, '南区', 700, 0), (4, '西区', 300, 0);") + db.commit() + db.close() + name = f"months_{uuid.uuid4().hex[:8]}" + async with SessionLocal() as session: + row = DataSource(name=name, kind="sqlite", database=str(path), readonly=True, enabled=True, options={}) + session.add(row) + await session.flush() + row.schema_cache = await introspect.introspect(row) + await session.commit() + source_id = row.id + yield name + await engines.invalidate(source_id) + + +def reviewer(monkeypatch, source: str) -> None: + """写作者交 TEXT；反方 agent 按任务里的结论认出是哪一句，照 PLAYS 查询、交结论和理由。""" + + def decide(model, messages): + if challenge_mod.CHALLENGE_SYSTEM not in str(messages[0].content): + return AIMessage(content=TEXT) + task = str(messages[1].content) if len(messages) > 1 else "" + queries, verdict, rationale = next((p for k, p in PLAYS.items() if k in task), ([], "stands", "没有找到反例。")) + if model.response_format: + return AIMessage(content=json.dumps({"verdict": verdict, "rationale": rationale}, ensure_ascii=False)) + done = sum(1 for m in messages if isinstance(m, ToolMessage)) + if done < len(queries): + call = {"name": f"db_query__{source}", "args": {"sql": queries[done]}, + "id": f"q{done}-{uuid.uuid4().hex[:6]}"} + return AIMessage(content="查一下。", tool_calls=[call]) + return AIMessage(content="查完了。") + + monkeypatch.setattr(MockChatModel, "_decide", decide) + + async def verify_model(session, spec): + return MockChatModel(model_name=PRICED, latency=0.0), PRICED + + monkeypatch.setattr(verify_agent, "get_chat_model", verify_model) + + +def challenge_graph(source: str, *, challenge: bool = True, **config) -> dict: + return chain( + node("start", "input"), + node("fetch", "tool", tool=f"db_query__{source}", args={"sql": QUERY}), + node("write", "report", "写月报", instructions="写月报"), + *([node("chal", "challenge", "审稿", report="write", **config)] if challenge else []), + node("out", "output", fields=[{"name": "月报", "value": "{{ nodes.write.text }}"}], + contract={"report_from": "write"}), + ) + + +async def graph_report(client, run_id: str) -> dict: + res = await client.get(f"/api/runs/{run_id}/evidence") + assert res.status_code == 200, res.text + [report] = res.json()["reports"] + return report + + +def units_of(doc: dict) -> dict[str, dict]: + """句子编号 → (原文, 第一个不是结构性的片段)：点开整句时前端请求的就是这个片段。""" + md = doc["markdown"] + out = {} + for _, unit in iter_units(doc): + first = next((s for s in unit.get("segments") or [] if s.get("kind") != "structural"), None) + start, end = unit["span"] + out[unit["id"]] = {"text": md[start:end].strip(), "kind": unit.get("kind"), "first": first} + return out + + +async def same_as_segments(client, run_id: str, report: dict) -> dict[str, str]: + """每一句的标记和片段接口答的 unit.challenge.verdict 一字不差（没审到的两边都没有）。返回 原文 → 判断。""" + doc = artifact_store.load(report["doc_artifact"]) + marks = report.get("challenge_verdicts", {}) + said = {} + for uid, unit in units_of(doc).items(): + if unit["first"] is None: + continue + res = await client.get(f"/api/runs/{run_id}/evidence/segments/{unit['first']['id']}") + assert res.status_code == 200, res.text + verdict = (res.json()["unit"].get("challenge") or {}).get("verdict") + assert marks.get(uid) == verdict, f"{unit['text']}：证据图 {marks.get(uid)!r} ≠ 片段接口 {verdict!r}" + if verdict: + said[unit["text"]] = verdict + assert set(marks) <= set(units_of(doc)), "证据图标了文档里没有的句子" + return said + + +async def test_the_graph_marks_every_challenged_sentence(client, monkeypatch, sales): + reviewer(monkeypatch, sales) + run = await start(challenge_graph(sales)) + assert run.status == "succeeded", run.error + report = await graph_report(client, run.id) + doc = artifact_store.load(report["doc_artifact"]) + units = units_of(doc) + by_text = {u["text"]: uid for uid, u in units.items()} + # 只含被审过的两句：标题、没被挑来审的句子不在里面 + assert report["challenge_verdicts"] == {by_text[NORTH]: "weakened", by_text[SOUTH]: "refuted"} + heading = next(uid for uid, u in units.items() if u["kind"] == "heading") + assert heading not in report["challenge_verdicts"] + # 被推翻的那句只有文字：没有一个可点的片段，正文要靠这张表才挂得出入口 + south = next(u for b in doc["blocks"] for u in b["units"] if u["id"] == by_text[SOUTH]) + assert all(seg["kind"] in ("text", "structural") for seg in south["segments"]) + assert await same_as_segments(client, run.id, report) == {NORTH: "weakened", SOUTH: "refuted"} + + +async def test_a_lost_review_record_marks_the_listed_sentences(client, monkeypatch, sales): + """审稿记录没存上：按产出里列的那几句标，和片段接口同一个来源。""" + async def lost(self, record): + return None + + monkeypatch.setattr(challenge_mod._Review, "_store", lost) + reviewer(monkeypatch, sales) + run = await start(challenge_graph(sales)) + assert run.status == "succeeded", run.error + report = await graph_report(client, run.id) + assert sorted(report["challenge_verdicts"].values()) == ["refuted", "weakened"] + assert await same_as_segments(client, run.id, report) == {NORTH: "weakened", SOUTH: "refuted"} + + +async def test_a_review_that_stopped_the_run_still_marks(client, monkeypatch, sales): + """「结论被推翻时」设为报错并停止运行：节点报错、运行失败，按审完那一刻的日志认审稿记录，被审的句子照样有标记。""" + reviewer(monkeypatch, sales) + run = await start(challenge_graph(sales, on_refuted="fail")) + assert run.status == "failed" and "推翻" in (run.error or ""), run.error + report = await graph_report(client, run.id) + assert await same_as_segments(client, run.id, report) == {NORTH: "weakened", SOUTH: "refuted"} + + +@pytest.mark.parametrize("challenge", [False, True]) +async def test_reports_nobody_reviewed_have_no_marks(client, monkeypatch, sales, challenge): + """没有反方审稿、或者反方审稿关着（直通，一句都没审）：没有这个键，和以前一字不差。""" + reviewer(monkeypatch, sales) + run = await start(challenge_graph(sales, challenge=challenge, **({"enabled": False} if challenge else {}))) + assert run.status == "succeeded", run.error + assert "challenge_verdicts" not in await graph_report(client, run.id) + + +# -------------------------------------------------------------------------- +# 认「哪一次」：手写的封存事件 +# -------------------------------------------------------------------------- + + +def sealed_of(graph: dict, events: list[tuple]) -> evidence._Sealed: + return evidence._Sealed(run_id="syn-run", graph=graph, events=events, + seal={"sealed": True, "ok": True, "manifest_seq": events[-1][0], "legacy": False}) + + +def report(doc_artifact: str) -> evidence._Report: + return evidence._Report(node_id="write", doc_artifact=doc_artifact, ok=True, repairs=0, stats=None, doc=None, + hash_ok=True, fields=[]) + + +def claim(unit, verdict, text="一句结论。"): + return {"unit": unit, "text": text, "verdict": verdict, "rationale": "", "rationale_doc": None, "queries": []} + + +async def review(doc: str, claims: list[dict], *, saved: bool = True, on_refuted: str = "degrade") -> str: + """一次反方审稿的产出工件（审稿记录存上了的带 challenge_artifact）。""" + record = await put_json({"report": "write", "doc_artifact": doc, "model": "mock", "claims": claims}, + kind="challenge") if saved else None + counts = {v: sum(1 for c in claims if c["verdict"] == v) for v in ("stands", "weakened", "refuted", "inconclusive")} + items = [{k: c[k] for k in ("unit", "text", "verdict")} for c in claims] + return await put_json({"challenge_artifact": record, "counts": counts, "on_refuted": on_refuted, "items": items}, + kind="node_output") + + +def consistent(sealed: evidence._Sealed, doc: str, units: list[str]) -> dict[str, str]: + """标记表和逐句的 _challenge_of 一致：每一句的判断相同，没审到的两边都没有。""" + marks = evidence._challenge_verdicts(sealed, report(doc)) + for uid in units: + one = evidence._challenge_of(sealed, report(doc), uid) + assert marks.get(uid) == (one or {}).get("verdict"), f"{uid}：{marks.get(uid)!r} ≠ {one!r}" + return marks + + +@pytest.mark.parametrize("saved", [True, False]) +async def test_a_review_of_an_earlier_draft_does_not_mark_the_rewritten_report(saved): + """报告在反方审稿之后又重写了一次：审的是前一稿，新的一稿上同一个句子编号说的可能是另一句话，不标。""" + draft = await put_json({"markdown": "第一稿", "n": 11}, kind="report_doc") + final = await put_json({"markdown": "第二稿", "n": 12}, kind="report_doc") + out = await review(draft, [claim("u1", "refuted"), claim("u2", "stands")], saved=saved) + graph = chain(node("write", "report", "写月报"), node("chal", "challenge", "审稿", report="write")) + events = [ + (1, "report.checked", "write", {"doc_artifact": draft, "ok": True}), + (2, "node.finished", "write", {}), + (3, "node.finished", "chal", {"artifact": out}), + (4, "report.checked", "write", {"doc_artifact": final, "ok": True}), + ] + sealed = sealed_of(graph, events) + assert consistent(sealed, draft, ["u1", "u2", "u3"]) == {"u1": "refuted", "u2": "stands"} + assert consistent(sealed, final, ["u1", "u2"]) == {} + + +async def test_each_sentence_takes_the_last_review_that_reached_it(): + """两个反方审稿审了同一份文档：每一句取最后跑完、审到了它的那个（同片段接口）；只有前一个审到的句子照样标。""" + doc = await put_json({"markdown": "月报", "n": 13}, kind="report_doc") + first = await review(doc, [claim("u1", "refuted"), claim("u2", "stands")]) + second = await review(doc, [claim("u2", "weakened"), claim("u3", "inconclusive")]) + graph = chain(node("write", "report", "写月报"), node("chal1", "challenge", "审稿一", report="write"), + node("chal2", "challenge", "审稿二", report="write")) + events = [ + (1, "report.checked", "write", {"doc_artifact": doc, "ok": True}), + (2, "node.finished", "chal1", {"artifact": first}), + (3, "node.finished", "chal2", {"artifact": second}), + ] + marks = consistent(sealed_of(graph, events), doc, ["u1", "u2", "u3", "u4"]) + assert marks == {"u1": "refuted", "u2": "weakened", "u3": "inconclusive"} + + +async def test_a_review_that_failed_the_node_marks_from_its_record(): + """节点报错：按审完那一刻的日志认审稿记录；重跑之后没再审完的不算，日志里没有审稿记录的认不出审的是哪一稿，也不算。""" + doc = await put_json({"markdown": "月报", "n": 14}, kind="report_doc") + record = await put_json({"report": "write", "doc_artifact": doc, "model": "mock", + "claims": [claim("u1", "refuted"), claim("u2", "weakened")]}, kind="challenge") + graph = chain(node("write", "report", "写月报"), node("chal", "challenge", "审稿", report="write", + on_refuted="fail")) + counts = {"stands": 0, "weakened": 1, "refuted": 1, "inconclusive": 0} + head = [(1, "report.checked", "write", {"doc_artifact": doc, "ok": True}), (2, "node.started", "chal", {})] + done = (3, "log", "chal", {"code": "challenge_done", "counts": counts, "artifact": record}) + failed = (4, "node.failed", "chal", {"error": "反方审稿推翻了 1 句结论"}) + assert consistent(sealed_of(graph, [*head, done, failed]), doc, ["u1", "u2"]) == {"u1": "refuted", "u2": "weakened"} + retried = [*head, done, (4, "node.started", "chal", {}), (5, "node.failed", "chal", {"error": "模型不可用"})] + assert consistent(sealed_of(graph, retried), doc, ["u1", "u2"]) == {} + lost = [*head, (3, "log", "chal", {"code": "challenge_done", "counts": counts, "artifact": None}), failed] + assert consistent(sealed_of(graph, lost), doc, ["u1", "u2"]) == {} + + +async def test_unreadable_verdicts_are_left_out(): + """判断不是一个词的（缺了、空的、不是字符串）不标；同一次审稿里一句列了两遍时取前一条（同片段接口）。""" + doc = await put_json({"markdown": "月报", "n": 15}, kind="report_doc") + out = await review(doc, [claim("u1", None), claim("u2", ""), claim("u3", 3), claim("u4", "stands"), + claim("u4", "refuted"), claim("", "refuted"), claim(None, "refuted")]) + graph = chain(node("write", "report", "写月报"), node("chal", "challenge", "审稿", report="write")) + events = [(1, "report.checked", "write", {"doc_artifact": doc, "ok": True}), + (2, "node.finished", "chal", {"artifact": out})] + assert consistent(sealed_of(graph, events), doc, ["u1", "u2", "u3", "u4", ""]) == {"u4": "stands"} diff --git a/frontend/src/dev/fixtures/challenge.tsx b/frontend/src/dev/fixtures/challenge.tsx index 5e8a4ffe..b2947d90 100644 --- a/frontend/src/dev/fixtures/challenge.tsx +++ b/frontend/src/dev/fixtures/challenge.tsx @@ -31,11 +31,16 @@ import fx from './challenge.json' * 卡上按「无法判断」的句数说，两个数不打架 * - ?syn=challenge-approval-offpath：正式运行，按降档处置，但反方审稿不在带出具契约的成果节点上游（degrades 为假） * - ?syn=challenge-summary-given：反方审稿那一块单独画，审批自带的运行类别（正式运行）由调用方传进来；检查脚本让这次运行的 - * GET 失败，卡上照样写「出具会降档」，也不另发这次请求。审批卡（RunPanel 的 ApprovalCard）把 approval.run_class - * 传给它之后，卡上走的就是这条路 + * GET 失败（500），卡上照样写「出具会降档」，也不另发这次请求 + * - ?syn=challenge-approval-given：同一次运行（GET 同样 500），整张审批卡（RunPanel 的 ApprovalCard）：审批带着 + * run_class，卡把它传给反方审稿那一块，照它说出具、不另取 * - ?syn=challenge-approval-dup：同 many，工件里补出来的一句和条目里的一句原文相同、unit 不同（工件由检查脚本合成） * - ?syn=challenge-approval-norecord：同 many，审稿记录没存上（artifact 为 null） * + * 证据面板的单句展示（scope="claim"）： + * - ?syn=challenge-claim-quiet：被推翻的那一句，「不谈出具」（issuance={false}）。给了正式运行、运行 id，服务端也说被推翻的 + * 会降档（degrades）——审批卡上这几样凑齐就写「出具会降档」；这里一句和出具有关的话都不说，也不为此取运行类别 + * * 运行类别（GET /api/runs/{id}）、工件（GET /api/artifacts/{id}）都由检查脚本用 page.route 伪造；直接打开时取不到， * 卡上照实不说降档、点开一句说无法获取。 * @@ -68,9 +73,8 @@ function Card({ approval, name, dense = false }: { approval: Approval; name: str } const RUNS = fx.runs -/** 期 4 起服务端另带的两项：unreviewed（没能反查的句数）、degrades（被推翻的会不会让出具降档） */ -type Challenge = ApprovalChallenge & { unreviewed?: number; degrades?: boolean } -const withChallenge = (c: Partial): ApprovalReport => ({ ...report, challenge: { ...challenge, ...c } as ApprovalChallenge }) +/** 期 4 起服务端另带的两项（unreviewed 没能反查的句数、degrades 被推翻的会不会让出具降档）类型里都有，按需盖上 */ +const withChallenge = (c: Partial): ApprovalReport => ({ ...report, challenge: { ...challenge, ...c } }) const many = fx.many as unknown as ApprovalChallenge /** 没有被推翻的结论：同第一个用例去掉被推翻的那句，计数跟着改 */ const clear: Partial = { @@ -82,7 +86,7 @@ const clear: Partial = { * 记为无法判断，unreviewed 不会多于 inconclusive）。原来无法判断的 u11 是查过了、数据不够，不算未能反查 */ const UNREVIEWED_UNITS = ['u5', 'u8'] -const unreviewed: Partial = { +const unreviewed: Partial = { 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), @@ -245,10 +249,20 @@ export const cases: Record JSX.Element> = { ), + 'challenge-approval-given': () => ( + + ), 'challenge-approval-offpath': () => ( ), + 'challenge-claim-quiet': () => ( +
+ it.verdict === 'refuted') })]} + runId={RUNS.formal} runClass="formal" scope="claim" issuance={false} /> +
+ ), 'challenge-inspector': () => , 'challenge-inspector-chain': () => , } diff --git a/frontend/src/dev/fixtures/evidence_ask.tsx b/frontend/src/dev/fixtures/evidence_ask.tsx new file mode 100644 index 00000000..08523d05 --- /dev/null +++ b/frontend/src/dev/fixtures/evidence_ask.tsx @@ -0,0 +1,27 @@ +import type { JSX } from 'react' +import { EvidenceDoc } from '../../run/EvidenceDoc' +import type { EvidenceDocData } from '../../types' +import judge from '../../run/__tests__/evidence-judge.json' + +/** + * 报告正文句末「质询」图标（审批质询）平时的样子，scripts/check-evidence.mjs 按它量平时状态的对比度： + * - ?syn=evidence-ask：同一份没开裁判的周报（run/__tests__/evidence-judge.json 的 plain，后端 compose_doc 真跑出来的， + * 内容虚构）摆两份，都给了质询入口：一份在页面底色上（同审批卡里展开的报告），一份在面板底色上（同运行详情的证据页） + * + * 证据图、片段接口由检查脚本伪造；不点「质询」，提问框不挂 + */ +const DOC = judge.plain.doc as unknown as EvidenceDocData +const ACCESS = { approvalId: 'ap-evidence-ask', host: 'evidence-ask' } + +export const cases: Record JSX.Element> = { + 'evidence-ask': () => ( +
+
+ +
+
+ +
+
+ ), +} diff --git a/frontend/src/dev/fixtures/evidence_marks.tsx b/frontend/src/dev/fixtures/evidence_marks.tsx new file mode 100644 index 00000000..61f23dbd --- /dev/null +++ b/frontend/src/dev/fixtures/evidence_marks.tsx @@ -0,0 +1,143 @@ +import { useState, type JSX } from 'react' +import { EvidencePane } from '../../pages/runs/EvidencePane' +import { EvidenceDoc, EvidenceField } from '../../run/EvidenceDoc' +import { useEvidence } from '../../store/evidence' +import type { EvidenceDocData, Run } from '../../types' +import judge from '../../run/__tests__/evidence-judge.json' + +/** + * 正文里被反方审过的句子（期 4，run/EvidenceDoc 的句末标记）的预览用例，scripts/check-evidence.mjs 按它们检查。报告文档 + * 取自 run/__tests__/evidence-judge.json 的 plain（后端 compose_doc 真跑出来的周报，内容虚构）；证据图、片段接口、审计 + * 接口都由检查脚本伪造，这里不发任何写请求。 + * + * - ?syn=evidence-marks-text：同一份周报，数字、取值都改成纯文字：整份报告一个可点的片段都没有，也没开裁判，挂上时键盘 + * 顺序是空的。证据图（检查脚本晚一点答）带着被审过的句子，标记到了以后得进 Tab 顺序。前面摆一个按钮，从它按 Tab 进报告 + * - ?syn=evidence-marks-stale：同一次运行先后在几个地方挂这份报告，看手里那份证据图过期了重不重取。按钮换场景（每按一次 + * 都重新挂）：审批卡里的初稿（old）；报告改写后第二次审批的新稿（new）；同一个实例从初稿换到新稿（switch，同画布的审批 + * 浮层换审批）；运行结束后成果区的新稿（output，EvidenceField）；运行详情的证据页（pane-interrupted：运行停在第二次审批 + * 上；pane-succeeded：运行已经结束、封存过）。两份文档预先放进证据 store：文档按工件 id 永久缓存，取文档不是这里要看的 + */ + +/** 同一次运行：初稿是夹具里那一份，新稿改了一句话和一个数（文档的 run_id 改成这次运行，成果区按它认是不是同一次运行） */ +const RUN = 'run-evidence-marks-stale' +const OLD_ART = judge.plain.doc_artifact +const NEW_ART = 'b7'.repeat(32) +const BASE = judge.plain.doc as unknown as EvidenceDocData + +const OLD: EvidenceDocData = { ...BASE, run_id: RUN } +const NEW: EvidenceDocData = { + ...BASE, + run_id: RUN, + markdown: (BASE.markdown ?? '').replace('增长主要来自新客首单，老客复购持平。', '增长主要来自老客复购，新客首单持平。') + .replace('退款 29 单', '退款 31 单'), + blocks: BASE.blocks.map((b) => ({ + ...b, + units: b.units?.map((u) => ({ + ...u, + segments: u.segments?.map((s) => (s.id === 's11' ? { ...s, text: '增长主要来自老客复购，新客首单持平。' } + : s.id === 's14' && s.cite ? { ...s, text: '31', cite: { ...s.cite, value: 31, rendered: '31' } } : s)), + })), + })), +} + +/** 一个可点的片段都没有的那一份：非结构片段一律改成普通文字，去掉出处 */ +const TEXT_ONLY: EvidenceDocData = { + ...BASE, + blocks: BASE.blocks.map((b) => ({ + ...b, + units: b.units?.map((u) => ({ + ...u, + segments: u.segments?.map((s) => (s.kind === 'structural' ? s : { id: s.id, kind: 'text', text: s.text, state: 'neutral' })), + })), + })), +} + +function TextOnly() { + return ( +
+ +
+ +
+
+ ) +} + +type Stage = 'old' | 'new' | 'switch' | 'output' | 'pane-interrupted' | 'pane-succeeded' +const STAGES: [Stage, string][] = [ + ['old', '审批卡 · 初稿'], ['new', '第二次审批 · 新稿'], ['switch', '同一张卡换稿'], ['output', '成果区 · 新稿'], + ['pane-interrupted', '证据页 · 停在审批上'], ['pane-succeeded', '证据页 · 运行已结束'], +] + +function runOf(status: 'interrupted' | 'succeeded'): Run { + const done = status === 'succeeded' + return { + id: RUN, workflow_id: null, workflow_name: '周报', status, input: {}, output: {}, error: null, + usage: { input_tokens: 0, output_tokens: 0, cost_usd: 0 } as Run['usage'], run_class: 'formal', version: 2, + manifest_hash: done ? 'c'.repeat(64) : null, manifest_seq: done ? 64 : null, + created_at: '2026-10-05T06:00:00', started_at: '2026-10-05T06:00:00', + } +} + +/** 审批卡里展开的报告（同 run/ApprovalReport 的 ReportDoc：限高、窄栏、自带证据条） */ +function Card({ doc, artifact }: { doc: EvidenceDocData; artifact: string }) { + return ( +
+ +
+ ) +} + +/** 同一个 EvidenceDoc 实例从初稿换到新稿 */ +function Switch() { + const [fresh, setFresh] = useState(false) + return ( +
+ +
+ +
+
+ ) +} + +function Stale() { + // 首次渲染前把两份文档放进 store：文档按工件 id 永久缓存，证据页、成果区按工件 id 取的就是它们 + useState(() => { + useEvidence.setState((s) => ({ + docs: { ...s.docs, [OLD_ART]: { status: 'ok', data: OLD }, [NEW_ART]: { status: 'ok', data: NEW } }, + })) + return true + }) + const [at, setAt] = useState<{ stage: Stage; n: number }>({ stage: 'old', n: 0 }) + const go = (stage: Stage) => setAt((cur) => ({ stage, n: cur.n + 1 })) + return ( +
+
+ {STAGES.map(([stage, label]) => ( + + ))} +
+ {/* 每按一次都按新的 key 重新挂：同一场景按两次，看手里那份图对上了还会不会重取 */} +
+ {at.stage === 'old' && } + {at.stage === 'new' && } + {at.stage === 'switch' && } + {at.stage === 'output' && ( +
+ +
+ )} + {(at.stage === 'pane-interrupted' || at.stage === 'pane-succeeded') && ( + (id === 'write' ? '写周报' : undefined)} refreshKey="0" /> + )} +
+
+ ) +} + +export const cases: Record JSX.Element> = { + 'evidence-marks-text': () => , + 'evidence-marks-stale': () => , +} diff --git a/frontend/src/dev/fixtures/issuance.tsx b/frontend/src/dev/fixtures/issuance.tsx new file mode 100644 index 00000000..522e1145 --- /dev/null +++ b/frontend/src/dev/fixtures/issuance.tsx @@ -0,0 +1,52 @@ +import type { JSX } from 'react' +import { AssistantStream, type StreamTurn } from '../../run/AssistantStream' +import { decodeRun } from '../../run/decode' +import type { RunEvent } from '../../types' + +/** + * 出具横幅里的核查缺口（运行面板成果区、问数据回答用的 run/AssistantStream 的 IssuanceBanner），scripts/check-stream.mjs + * 按它检查： + * - ?syn=issued-verify：正式运行降档出具。缺口里有一条没通过 SQL 检查的（横幅单列）、双盲复算和反方审稿报上来的几条 + * （两路结果不一致、结论被推翻、指标无法复算），和一条校验没做完的；先后照服务端（出具契约按上游节点的先后收），核查的和 + * 别的混在一起。横幅按「核查未通过」「核查未完成」「校验未全部完成」分组，先后同时间线上出具那一行 + * + * 门店、指标、数字都是虚构的。缺口原话照服务端的写法（出具契约给上游节点的缺口加「节点类型「节点名」：」的前缀） + */ +export const ISSUED_VERIFY = { + run: 'syn-issued-verify', + sql: '查询「取门店流水」（Q1）未通过 SQL 检查（「门店」关联「流水明细」是一对多，对「门店」的「面积」求和会重复计算），结果不可靠；受影响的引用：指标「坪效」', + failed: ['双盲复算「复核月报口径」：指标「客单价」两路结果不一致，审核人选择了盲算结果', '反方审稿：推翻了 1 句结论：「西区客流回升主要来自会员日」'], + unfinished: ['双盲复算「复核月报口径」：指标「复购率」无法复算：输入来自合并查询，无法单独复算'], + other: ['叙述模板渲染为空（路径可能有误）'], +} + +const V = ISSUED_VERIFY +const ISSUANCE = { + tier: 'degraded', matched_numbers: 4, metrics_checked: 3, missing_required: [], missing_expected: [], unmatched_numbers: [], + calibers: [], + gaps: [V.failed[0], V.sql, V.other[0], V.unfinished[0], V.failed[1]], + sql_checks: [{ query: '查询「取门店流水」（Q1）', node_id: 'fetch', problems: ['「门店」关联「流水明细」是一对多，对「门店」的「面积」求和会重复计算'], + refs: ['指标「坪效」'], gap: V.sql }], +} +const OUTPUT = { 月报: '上月各门店客单价 86.4 元，坪效 1,240 元。', _issuance: ISSUANCE } + +function verifyTurn(): StreamTurn { + const at = Date.now() / 1000 - 30 + const events: RunEvent[] = [ + { seq: 1, type: 'run.started', node_id: null, ts: at, data: { nodes: 1 } }, + { seq: 2, type: 'node.started', node_id: 'done', ts: at + 1, data: {} }, + { seq: 3, type: 'issuance', node_id: 'done', ts: at + 1.2, data: { ...ISSUANCE, unmatched: 0 } }, + { seq: 4, type: 'node.finished', node_id: 'done', ts: at + 1.3, data: { duration_ms: 300 } }, + { seq: 5, type: 'run.finished', node_id: null, ts: at + 1.4, data: { output: OUTPUT, duration_ms: 1400 } }, + ] + return { + id: 'issued-verify', question: '上月门店经营月报', phase: 'done', status: '已完成', + steps: decodeRun(events, { status: 'succeeded' }), output: OUTPUT, runId: V.run, runClass: 'formal', + } +} + +export const cases: Record JSX.Element> = { + 'issued-verify': () => ( +
+ ), +} diff --git a/frontend/src/lib/terms.ts b/frontend/src/lib/terms.ts index 8ea7b9fb..aedba907 100644 --- a/frontend/src/lib/terms.ts +++ b/frontend/src/lib/terms.ts @@ -3954,6 +3954,34 @@ export const CHALLENGE_TEXT = { /** 同上，没有可跳的查询时（双盲复算的理由）只念出处 */ citedPlain: (source: string) => `（出处：${source}）`, + // ---- 证据面板的单句展示（ChallengeSummary 的 scope="claim"）与正文的句末标记（run/EvidenceDoc）---- + /** 证据面板里这一节的标题 */ + claimTitle: '反方审稿', + /** 单句展示：展开反方对这一句的理由和它执行过的查询 */ + claimDetail: '反方的理由与查询', + /** 这一句判为无法判断，而这份报告无法判断的句子全是没反查成的：这一句就是 */ + claimUnreviewed: '这一句未能反查，已记为无法判断', + /** 同上，但无法判断的句子里还有查过了、数据不够的：说不准是不是这一句 */ + claimMaybeUnreviewed: (n: number) => `这份报告有 ${formatNumber(n)} 句未能反查，已记为无法判断，这一句可能在其中`, + /** + * 单句展示的先行版：只知道判断（正文标记用的证据图），这一句的理由、查询和整份报告的计数要等片段接口答回来。 + * 还在取、取不到（给重试）、答了却没有可用的内容 + */ + claimPending: '正在获取反方的理由与查询…', + claimFailed: '未能获取反方的理由与查询', + claimNoDetail: '无法查看反方的理由与查询', + /** + * 无法判断的落款：未能反查的句子也记为无法判断（服务端按规则记的，反方模型没看过这一句），说不准是哪一种时不说成反方 + * 模型的判断。证据面板先行版的落款、正文句末标记的悬停说明都用这一句 + */ + judgedUnsure: '可能是反方模型的判断，也可能是未能反查时记下的，并非系统核对', + /** 正文句末标记的悬停说明：判断是反方模型给的 */ + markTitle: (verdict: string) => `反方审稿：${verdict}（反方模型的判断，并非系统核对）`, + /** 同上，无法判断的那一种（括号里同 judgedUnsure） */ + markTitleUnsure: (verdict: string) => `反方审稿：${verdict}（可能是反方模型的判断，也可能是未能反查时记下的，并非系统核对）`, + /** 句末标记读屏念的那一段：跟在句子后面（只有反方审稿时），或接在裁判的判定后面（两样都有时，并在一个标记里） */ + markLabel: (verdict: string) => `反方审稿：${verdict}`, + // ---- 时间线（run/decode.ts explainLog）：按日志的 code 和结构化字段说，不从原话里认 log: { skippedDisabled: '反方审稿未启用，已跳过', diff --git a/frontend/src/pages/runs/EvidencePane.tsx b/frontend/src/pages/runs/EvidencePane.tsx index 67c2a952..531d895c 100644 --- a/frontend/src/pages/runs/EvidencePane.tsx +++ b/frontend/src/pages/runs/EvidencePane.tsx @@ -12,9 +12,8 @@ import { issuanceMarks, segmentState, unitVerdict, verdictState, type AuditFilter, type AuditGroup, type AuditRow, } from '../../lib/evidence' import { formatNumber } from '../../lib/format' -import { DUAL_CHECK_TEXT, EVIDENCE_AUDIT_TEXT as T, UPGRADE_TEXT } from '../../lib/terms' +import { 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 { ReportInquiry, inquiryOpen, locateIn, useInquiryAccess } from '../../run/Inquiry' @@ -49,12 +48,40 @@ export function EvidencePane({ run, output, labelOf, refreshKey }: { const loadGraph = useEvidence((s) => s.loadGraph) const reloadGraph = useEvidence((s) => s.reloadGraph) const first = useRef(true) + // 报告正文（审批卡里展开的、成果区的）有运行就先取过证据图，取的时候运行可能还停在审批上（之后报告又改写过）、刚收尾还没 + // 封存，也可能是接着跑之前封存的那一版。挂上时手里那份不是「封存了、封存的就是这一版」就重取一次，不看运行停在哪：之后 + // 没有新事件，refreshKey 不再变，过期的那份会一直留着。别处正在取的那份取回来再看一眼（recheck）。 + // 重取回来之前先占位（renewing），不画手里那份：画出来的是旧稿，审计表却是挂上时新取的，点一行会按片段 id 打开旧稿里同号 + // 的片段。第一次渲染就按挂上那一刻手里的那份定，不先画一帧旧稿再收起来；换下来的判据是 store 里那一格不再是它 + const [held] = useState(() => useEvidence.getState().graphs[run.id]) + const [renewing, setRenewing] = useState(() => staleHeld(held, run.manifest_seq)) + const recheck = useRef(false) useEffect(() => { - if (first.current) { first.current = false; void loadGraph(run.id); return } + if (first.current) { + first.current = false + if (!staleHeld(held, run.manifest_seq)) void loadGraph(run.id) + else if (held?.status === 'loading') recheck.current = true + else void reloadGraph(run.id) + return + } void reloadGraph(run.id) - }, [run.id, refreshKey, loadGraph, reloadGraph]) + // held 是挂上那一刻的，之后不变 + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [run.id, run.status, run.manifest_seq, refreshKey, loadGraph, reloadGraph]) + useEffect(() => { + // 挂上时那一份还没换下来（重取还没发出、还没回来），或者正在取：接着等 + if (!renewing || graphSlot === held || graphSlot?.status === 'loading') return + if (recheck.current) { + recheck.current = false + if (graphSlot?.status === 'ok' && !sealedNow(graphSlot.data, run.manifest_seq)) { + void reloadGraph(run.id) + return + } + } + setRenewing(false) + }, [renewing, graphSlot, held, run.id, run.manifest_seq, reloadGraph]) const audit = useAudit(run.id, refreshKey) - const graph = graphSlot?.data + const graph = renewing ? undefined : graphSlot?.data const [root, setRoot] = useState(null) const wide = useWide(root, 880) @@ -150,8 +177,13 @@ export function EvidencePane({ run, output, labelOf, refreshKey }: { reports={graph.reports ?? []} labelOf={labelOf} /> {/* 出具档位和降档原因写在报告上方：降档时只在侧栏小标签里写「SQL 检查未通过」，报告上却是绿色的 - 「10 个数字都有出处」，读的人会以为一切正常。SQL 检查导致的降档在横幅里单列一块 */} - {!!output?._issuance?.tier && } + 「10 个数字都有出处」，读的人会以为一切正常。SQL 检查导致的降档在横幅里单列一块，双盲复算、反方审稿报上来的 + 缺口分「核查未通过」「核查未完成」两组（和问数据、画布右栏同一个横幅） */} + {!!output?._issuance?.tier && ( +
+ +
+ )} {mode === 'cited' && reports.map((r) => { const doc = docOf(r.node_id) @@ -220,6 +252,17 @@ const openKey = (row: AuditRow): string | undefined => /** 已经收尾的运行：还在跑、停在审批上的，报告可能还没写，说「这次的报告没有逐段证据」太早 */ const SETTLED = new Set(['succeeded', 'failed', 'cancelled']) +/** + * 手里这份证据图能不能直接用：封存了，而且封存的就是运行现在这一版（失败后接着跑的运行会重新封存，manifest_seq 跟着变）。 + * 运行记录上没有 manifest_seq（老运行）、老服务端的证据图没给时只看封没封存 + */ +const sealedNow = (graph: EvidenceGraph | undefined, seq: number | null | undefined) => + !!graph?.seal?.sealed && (seq == null || graph.seal.manifest_seq == null || graph.seal.manifest_seq === seq) + +/** 证据页挂上时手里那份（别处取的）要不要重取：正在取的取回来再看；取到了的不是封存的这一版就重取。没有、取失败的照常取 */ +const staleHeld = (held: { status: string; data?: EvidenceGraph } | undefined, seq: number | null | undefined) => + held?.status === 'loading' || (held?.status === 'ok' && !sealedNow(held.data, seq)) + /** * 工作流现在的图能不能一键升级：拿它去校验，看有没有 evidence.upgrade_available 这条建议。老后端不给 * 这条建议，横幅也就不出现（它也没有升级接口）。按工作流 id 和版本记住答案：同一张图的几条运行不重复问； @@ -322,38 +365,6 @@ 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; 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 && ( -
-
{DUAL_CHECK_TEXT.verifyGaps[kind]}
-
    - {gaps.map((g) =>
  • · {g}
    • )} -
-
- ) - return ( -
- - {verify && ( -
- {group('failed', failed)} - {group('unfinished', unfinished)} -
- )} -
- ) -} - /** 顶上一行：这次运行按哪种方式展示证据、封存核对的结果、每份报告文档的哈希 */ function SummaryBar({ mode, seal, message, reports, labelOf }: { mode?: string diff --git a/frontend/src/run/AssistantStream.tsx b/frontend/src/run/AssistantStream.tsx index ecdc7eb0..e229f9a6 100644 --- a/frontend/src/run/AssistantStream.tsx +++ b/frontend/src/run/AssistantStream.tsx @@ -16,11 +16,12 @@ import { explainRunError } from '../lib/explain' import { formatClock, formatDuration, formatNumber, NONE, shortId } from '../lib/format' import { statusLabel } from '../lib/status' import { - COPILOT_CONTEXT_TEXT, EVIDENCE_TEXT, JUDGE_TEXT, MERGE_TEXT, RUN_SQL_CHECK_TEXT, evidenceTally, issuanceLabel, nodeTypeLabel, + COPILOT_CONTEXT_TEXT, DUAL_CHECK_TEXT, EVIDENCE_TEXT, JUDGE_TEXT, MERGE_TEXT, RUN_SQL_CHECK_TEXT, evidenceTally, issuanceLabel, + nodeTypeLabel, } from '../lib/terms' import { SqlCheckList } from './SqlChecks' import { - ISSUANCE_HINT, childrenByExec, compactSteps, parseQueryResult, progressOf, spread, teamVerdictOf, + ISSUANCE_HINT, childrenByExec, compactSteps, parseQueryResult, progressOf, splitIssuanceGaps, spread, teamVerdictOf, type Exec, type FixKind, type ResultTable as Table, type Step, type StepKind, type TeamMemberEx, type TeamRun, } from './decode' @@ -2296,6 +2297,22 @@ export function IssuanceSqlChecks({ tier, checks }: { tier: string; checks: Issu ) } +/** + * 出具横幅里双盲复算、反方审稿报上来的一组缺口：failed「核查未通过」、unfinished「核查未完成」。排在「校验未全部完成」 + * 上面，样子和它一样（同一种提醒色、小标题加圆点列表），一条都没有时不画 + */ +function IssuanceGaps({ kind, title, gaps }: { kind: 'failed' | 'unfinished'; title: string; gaps: string[] }) { + if (!gaps.length) return null + return ( +
+
{title}：
+
    + {gaps.map((g) =>
  • · {g}
    • )} +
+
+ ) +} + const TIER_META: Record = { formal: { color: 'var(--st-done)', soft: 'var(--st-done-soft)', hint: ISSUANCE_HINT.formal }, degraded: { color: 'var(--st-waiting)', soft: 'var(--st-waiting-soft)', hint: ISSUANCE_HINT.degraded }, @@ -2312,7 +2329,9 @@ const TIER_META: Record = * * 降档的原因必须写在这里：以前只列缺指标和回指不上的数字，而「叙述模板渲染 * 为空」「指标集为空」这类校验根本没跑起来的缺口（gaps）一条都不显示——横幅 - * 说「请对照下方声明」，下方什么都没有。 + * 说「请对照下方声明」，下方什么都没有。缺口分几块：没通过 SQL 检查的单列在最前， + * 双盲复算、反方审稿报上来的分「核查未通过」「核查未完成」，其余的归「校验未全部完成」。 + * 运行详情的证据页、问数据的回答、画布右栏用的都是这一个横幅，三处说法一样。 */ export function IssuanceBanner({ issuance, runClass, evidence }: { issuance: any; runClass?: string @@ -2331,7 +2350,11 @@ export function IssuanceBanner({ issuance, runClass, evidence }: { const sqlChecks: IssuanceSqlCheck[] = (Array.isArray(issuance?.sql_checks) ? issuance.sql_checks : []) .filter((x: unknown): x is IssuanceSqlCheck => !!x && typeof x === 'object') const sqlGaps = new Set(sqlChecks.map((x) => x.gap).filter(Boolean)) - const gaps: string[] = (Array.isArray(issuance?.gaps) ? issuance.gaps.map(String) : []).filter((g: string) => !sqlGaps.has(g)) + // 其余缺口里双盲复算、反方审稿报上来的另起两组：「核查未通过」（两路结果不一致、结论被推翻）、「核查未完成」（指标无法 + // 复算），排在「校验未全部完成」上面，先后同时间线、证据页、成果节点的印章（分组见 decode.ts 的 splitIssuanceGaps）。 + // 不分的话核查查出的问题读着像校验没做完，没核成的数又像被查出了错 + const { failed: verifyFailed, unfinished: verifyUnfinished, other: gaps } = splitIssuanceGaps( + (Array.isArray(issuance?.gaps) ? issuance.gaps.map(String) : []).filter((g: string) => !sqlGaps.has(g))) const calibers: any[] = issuance?.calibers ?? [] const matched = Number(issuance?.matched_numbers ?? 0) // 逐个数字的出处（matched[].caliber 形如「口径名 @ v2」）：有它就能按卡数清楚， @@ -2404,6 +2427,8 @@ export function IssuanceBanner({ issuance, runClass, evidence }: { )} {!!sqlChecks.length && } + + {!!gaps.length && (
{RUN_SQL_CHECK_TEXT.otherGaps}
diff --git a/frontend/src/run/ChallengeSummary.tsx b/frontend/src/run/ChallengeSummary.tsx index 1e850522..5a277302 100644 --- a/frontend/src/run/ChallengeSummary.tsx +++ b/frontend/src/run/ChallengeSummary.tsx @@ -11,58 +11,74 @@ import type { import { BlockView, CopyChip, Markdown, StyledSlice, inlineStyles, numericColumns } from './Markdown' export interface ChallengeSummaryProps { - /** 这张审批卡审的报告（payload.reports，和 ApprovalReports 拿到的是同一份） */ + /** + * 审的报告：审批卡是 payload.reports（和 ApprovalReports 拿到的是同一份）；证据面板是按片段接口的 unit.challenge 拼的 + * 一份，条目只有这一句 + */ reports: ApprovalReport[] - runId: string + /** 运行 id：要谈出具、又没给 runClass 时按它取一次运行类别 */ + runId?: string /** * 这次运行的类别（审批自带的 approval.run_class，同 ApprovalReports 的 runClass）。给了就照它说、不再另取；没给 * （老服务端的审批没有这一项）才按运行 id 取一次 */ runClass?: string | null + /** + * report（默认）：报告级的一块，审批卡用——标题、四种判断各几句、逐句列出、点开一句看理由和查询。 + * claim：单句，证据面板用——只有这一句的判断、它可能没反查成的说明、展开看理由和查询，不画报告级的标题、计数和别的句子 + * （面板里这一句就在正文上方；计数说的是整份报告，放在一句话的面板里读着像这一句的结果）。只取条目里的第一条 + */ + scope?: 'report' | 'claim' + /** + * 谈不谈出具（「出具会降档」、只标注、不在出具路径上）。默认谈：审批卡上运行还没出具，预告有用。证据面板看的是已经结束 + * 的运行，降没降档、出没出具以报告的出具横幅（封存的出具判定）为准，再说一遍将来时的预告只会和横幅对不上（驳回了、 + * 不予出具、反方审稿不在成果节点上游……）：传 false，一句和出具有关的话都不说，也不为此去取运行类别 + */ + issuance?: boolean } /** - * 审批卡里反方审稿的摘要，紧跟在报告核对概况（ApprovalReports）后面：一行概况（四种判断各几句），出具相关的那一句， - * 有句子反查没完成时再说一行「N 句未能反查」，逐句列出结论原文和判断，点开一句再按 challenge_artifact 取完整内容，看反方 - * 的理由和它执行过的查询。审稿记录没存上（没有工件）时只列判断、不能点开，整块说一次。 + * 反方审稿的摘要。两种摆法： + * - 审批卡（scope 为 report），紧跟在报告核对概况（ApprovalReports）后面：一行概况（四种判断各几句），出具相关的那一句， + * 有句子反查没完成时再说一行「N 句未能反查」，逐句列出结论原文和判断，点开一句再按 challenge_artifact 取完整内容，看 + * 反方的理由和它执行过的查询。审稿记录没存上（没有工件）时只列判断、不能点开，整块说一次。 + * - 证据面板（scope 为 claim、issuance 为 false）：一句话的判断，展开同样按 challenge_artifact 取这一句的理由和查询。片段 + * 接口还没答回来、答不了时，由 ClaimVerdictPending 先按正文标记（证据图）写出判断，说清在等什么、给重试。 * * 判断是反方模型给的，不是系统核对：颜色照结论句裁判的那一套，「经受住」也不用确定性的绿。 - * 「出具会降档」只在正式运行、有被推翻的结论、被推翻的真会让出具降档时才写：服务端给了 degrades 就照它（按降档处置、又接 - * 在带出具契约的成果节点上游才为真），老服务端没给时按「没写只标注」算。只标注的写一句不影响出具，按降档处置却不在出具 - * 路径上的写一句为什么不影响；探索运行不出具，和出具有关的话一句不说。运行类别照审批卡给的（runClass，审批自带的那一项， - * 卡顶写的也是它）；没给时按运行 id 从证据 store 取（loadRunClass），取到之前、取不到时都不说和出具有关的话（窗口重新 - * 拿到焦点时再取）。 + * 「出具会降档」只在谈出具（issuance）、正式运行、有被推翻的结论、被推翻的真会让出具降档时才写：服务端给了 degrades 就照它 + * （按降档处置、又接在带出具契约的成果节点上游才为真），老服务端没给时按「没写只标注」算。只标注的写一句不影响出具，按降档 + * 处置却不在出具路径上的写一句为什么不影响；探索运行不出具，和出具有关的话一句不说。运行类别照审批卡给的（runClass，审批 + * 自带的那一项，卡顶写的也是它）；没给时按运行 id 从证据 store 取（loadRunClass），取到之前、取不到时都不说和出具有关的话 + * （窗口重新拿到焦点时再取）。 * * 审的报告都没有经过反方审稿时什么都不画，也不发任何请求，卡片和以前一样。 */ -/** - * 审批卡上的反方审稿概况，约定之外服务端另带两项（期 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) { +export function ChallengeSummary({ reports, runId = '', runClass, scope = 'report', issuance = true }: ChallengeSummaryProps) { const reviewed = useMemo(() => reports.flatMap((r) => { const challenge = challengeOf(r) return challenge ? [{ report: r, challenge }] : [] }), [reports]) if (!reviewed.length) return null - return + return } -function ChallengeList({ reviewed, runId, given }: { - reviewed: { report: ApprovalReport; challenge: Challenge }[]; runId: string; given: RunClass | null +function ChallengeList({ reviewed, runId, given, scope, issuance }: { + reviewed: { report: ApprovalReport; challenge: ApprovalChallenge }[]; runId: string; given: RunClass | null + scope: 'report' | 'claim'; issuance: boolean }) { - // 审批卡给了运行类别就照它，不另取：另取的那一次失败了，正式运行里的「出具会降档」会无端消失，而卡顶照样写着正式运行 - const fetched = useRunClass(given ? '' : runId) - const run = given ?? fetched + // 审批卡给了运行类别就照它，不另取：另取的那一次失败了，正式运行里的「出具会降档」会无端消失，而卡顶照样写着正式运行。 + // 不谈出具的连取都不取：运行类别只用来决定说不说出具 + const fetched = useRunClass(given || !issuance ? '' : runId) + const run = issuance ? given ?? fetched : null return ( <> - {reviewed.map(({ report, challenge }) => ( - - ))} + {reviewed.map(({ report, challenge }) => (scope === 'claim' + ? + : ))} ) } @@ -92,7 +108,7 @@ const count = (v: unknown) => (typeof v === 'number' && Number.isFinite(v) && v * payload.reports[i].challenge 认不认得：要么有计数、要么有条目。计数缺了按条目数（条目最多 10 条，计数才是全部）； * 条目缺了 unit 的留空（行的键带序号，区分得开），不补假的：补出来的键会被当成真的 unit 去和工件里的句子比 */ -function challengeOf(report: ApprovalReport): Challenge | null { +function challengeOf(report: ApprovalReport): ApprovalChallenge | null { const raw = report.challenge as unknown if (!raw || typeof raw !== 'object') return null const c = raw as Record @@ -113,6 +129,19 @@ function challengeOf(report: ApprovalReport): Challenge | null { } } +/** + * 出具相关的那一句说什么（run 为 null——不谈出具、不是正式运行、类别还不知道——时一句都不说）： + * degrade 会降档（写「出具会降档」和原因）；off 按降档处置却不在出具路径上（写为什么不影响）；flag 只标注（写不影响出具档位） + */ +type Issuance = 'degrade' | 'off' | 'flag' | null +function issuanceOf(challenge: ApprovalChallenge, run: RunClass | null): Issuance { + if (run !== 'formal' || challenge.counts.refuted <= 0) return null + // 没给 on_refuted（老服务端）按降档；报错的节点到不了审批，不会是 fail + if (challenge.on_refuted === 'flag') return 'flag' + // 被推翻的真会让出具降档：服务端给了就照它，老服务端没给时按「不是只标注」算 + return (challenge.degrades ?? true) ? 'degrade' : 'off' +} + /** * 这次运行的类别（审批卡没给时才取，runId 为空就不取）：取到之前、取不到时为 null——不知道是不是正式运行，就一句和出具 * 有关的话都不说。取失败了不就此作罢：窗口重新拿到焦点时再取一次（store 对出错的槽会重发），取到了正式运行，降档的提示 @@ -222,7 +251,7 @@ const focusLost = () => !document.activeElement || document.activeElement === do // ---------------------------------------------------------------- 卡片 function ChallengeBlock({ report, challenge, run }: { - report: ApprovalReport; challenge: Challenge; run: RunClass | null + report: ApprovalReport; challenge: ApprovalChallenge; run: RunClass | null }) { const [open, setOpen] = useState>(() => new Set()) const [all, setAll] = useState(false) @@ -231,11 +260,7 @@ 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 === 'formal' - // 没给 on_refuted（老服务端）按降档；报错的节点到不了审批，不会是 fail - const flagged = challenge.on_refuted === 'flag' - // 被推翻的真会让出具降档：服务端给了就照它，老服务端没给时按「不是只标注」算 - const degrades = challenge.degrades ?? !flagged + const said = issuanceOf(challenge, run) // 未能反查的每一句都记为无法判断（服务端的约定），不会多于概况里的「无法判断」：对不上时按概况的数说，两个数不打架 const unreviewed = Math.min(challenge.unreviewed ?? 0, counts.inconclusive) // 条目之外的几句（条目最多 10 条）：要看全部时从工件里补上，排在后面，顺序照工件 @@ -284,27 +309,14 @@ function ChallengeBlock({ report, challenge, run }: { ))} - {refuted && !flagged && degrades && ( - - {CHALLENGE_TEXT.degrade} - - )} + {said === 'degrade' && }
) : (
{CHALLENGE_TEXT.none}
)} {/* 降档的原因常显，不放在悬停提示里：触屏、键盘用户也得看得到为什么、会怎样（只标注那一档同样常显一行）。 紧跟在概况那一行（「出具会降档」的标记）下面，中间不插别的话 */} - {refuted && !flagged && degrades && ( -
{CHALLENGE_TEXT.degradeHint}
- )} - {refuted && !flagged && !degrades && ( -
{CHALLENGE_TEXT.degradeOff}
- )} - {refuted && flagged && ( -
{CHALLENGE_TEXT.flagNote}
- )} + {/* 反查没完成的几句：「无法判断」里分不出查了数据不够和反查没做完，单独说一次 */} {unreviewed > 0 && (

@@ -365,6 +377,116 @@ function ChallengeBlock({ report, challenge, run }: { ) } +/** 「出具会降档」的醒目标记：跟在概况（单句时跟在判断）后面，原因由 IssuanceNote 常显在下一行 */ +function DegradeChip() { + return ( + + {CHALLENGE_TEXT.degrade} + + ) +} + +/** 出具相关的那一行：会降档的原因、不在出具路径上为什么不影响、只标注不影响出具档位。不谈出具时什么都不画 */ +function IssuanceNote({ said }: { said: Issuance }) { + const note = 'mt-0.5 text-2xs leading-relaxed text-dim' + if (said === 'degrade') return

{CHALLENGE_TEXT.degradeHint}
+ if (said === 'off') return
{CHALLENGE_TEXT.degradeOff}
+ if (said === 'flag') return
{CHALLENGE_TEXT.flagNote}
+ return null +} + +/** + * 单句（证据面板）：这一句的判断；判为无法判断、这份报告又有句子未能反查时说一句它（可能）没反查成；展开看反方的理由和 + * 它执行过的查询（按 challenge_artifact 取，和审批卡共用一份缓存）；最后写明判断出自反方模型。不画报告级的标题、四种 + * 判断的计数和别的句子，也不列这一句的原文（面板上方就是这一句）。审稿记录没存上时不给展开，说一次为什么 + */ +function ClaimBlock({ report, challenge, run }: { + report: ApprovalReport; challenge: ApprovalChallenge; run: RunClass | null +}) { + const [open, setOpen] = useState(false) + const detail = useChallengeArtifact(challenge.artifact ?? '', open) + const detailId = useId() + const item = challenge.items[0] + if (!item) return null + const noRecord = !challenge.artifact + const said = issuanceOf(challenge, run) + // 未能反查的每一句都记为无法判断（服务端的约定）：这一句判为无法判断、报告里又有没反查成的，才可能是它。无法判断的 + // 句子全是没反查成的（未能反查的不少于无法判断的），那就一定是它；还有查过了、数据不够的，说不准，照实说「可能」 + const unreviewed = item.verdict === 'inconclusive' ? Math.min(challenge.unreviewed ?? 0, challenge.counts.inconclusive) : 0 + const surely = unreviewed > 0 && unreviewed >= challenge.counts.inconclusive + return ( +
+
+ + {said === 'degrade' && } + {!noRecord && ( + + )} +
+ + {unreviewed > 0 && ( +

+ + {surely ? CHALLENGE_TEXT.claimUnreviewed : CHALLENGE_TEXT.claimMaybeUnreviewed(unreviewed)} + + 。{CHALLENGE_TEXT.unreviewedHint} +

+ )} + {open && ( +
+ +
+ )} + {noRecord &&

{CHALLENGE_TEXT.noRecord}

} + {/* 判断标签看着像结论，得说清是谁判的：展开取到审稿记录之后带上模型名。这一句一定没反查成（surely）的不写：那是 + 服务端按规则记的无法判断，反方模型没看过这一句，上面一行已经说了。说不准的（maybe）照旧写 */} + {!surely &&

{CHALLENGE_TEXT.judgedBy(detail.data?.model ?? null)}

} +
+ ) +} + +/** 证据面板先行版在等什么：片段接口还在取、取不到、答了却没有可用的 unit.challenge */ +export type ClaimWait = 'loading' | 'error' | 'missing' + +/** + * 单句展示的先行版（证据面板）：只知道这一句的判断（正文标记用的证据图 challenge_verdicts），审稿记录、整份报告的计数要等 + * 片段接口的 unit.challenge。判断标签先画出来——用户是点着句末醒目的「被推翻」进来的，这一节不能空着；还在取时说正在获取， + * 取不到给重试（onRetry），答了却没有可用的内容时照实说看不了。拿到 unit.challenge 之后调用方换成完整的单句展示 + * （ChallengeSummary 的 scope="claim"）。无法判断的说不准是不是根本没反查成（要整份报告的计数才分得出），落款不说成反方模型 + * 的判断。不谈出具，同证据面板里的完整展示 + */ +export function ClaimVerdictPending({ verdict, wait, onRetry }: { verdict: string; wait: ClaimWait; onRetry?: () => void }) { + return ( +
+
+ +
+ {wait === 'loading' ? ( +

{CHALLENGE_TEXT.claimPending}

+ ) : ( +
+ + {wait === 'error' ? CHALLENGE_TEXT.claimFailed : CHALLENGE_TEXT.claimNoDetail} + + {wait === 'error' && onRetry && ( + + )} +
+ )} +

+ {verdict === 'inconclusive' ? CHALLENGE_TEXT.judgedUnsure : CHALLENGE_TEXT.judgedBy(null)} +

+
+ ) +} + /** 判断标签：文字加颜色（去掉颜色也读得出），不铺底色——浅色主题下底色会把小字的对比度压到 4.5 以下 */ function VerdictTag({ verdict }: { verdict: string }) { const color = isVerdict(verdict) ? VERDICT_COLOR[verdict] : 'var(--text-dim)' diff --git a/frontend/src/run/EvidenceDoc.tsx b/frontend/src/run/EvidenceDoc.tsx index e086f702..454e2e35 100644 --- a/frontend/src/run/EvidenceDoc.tsx +++ b/frontend/src/run/EvidenceDoc.tsx @@ -4,7 +4,9 @@ import { type KeyboardEvent as ReactKeyboardEvent, type MouseEvent as ReactMouseEvent, type RefObject, } from 'react' import { createPortal } from 'react-dom' -import { ListChecks, MessageCircleQuestion } from 'lucide-react' +import { + ListChecks, MessageCircleQuestion, ShieldAlert, ShieldCheck, ShieldEllipsis, ShieldMinus, ShieldX, type LucideIcon, +} from 'lucide-react' import clsx from 'clsx' import { rovingTarget } from '../components/ui' import { @@ -13,9 +15,15 @@ import { type EvidenceStateCode, type EvidenceTally as Tally, } from '../lib/evidence' import { formatNumber } from '../lib/format' -import { EVIDENCE_STATE_LABEL, EVIDENCE_TEXT, INQUIRY_TEXT, JUDGE_TEXT, claimTally, evidenceTally, type ClaimTallyCounts } from '../lib/terms' -import { useEvidence, useVerdicts } from '../store/evidence' -import type { EvidenceBlock, EvidenceDocData, EvidenceSegment, EvidenceUnit, EvidenceVerdict } from '../types' +import { + CHALLENGE_TEXT, EVIDENCE_STATE_LABEL, EVIDENCE_TEXT, INQUIRY_TEXT, JUDGE_TEXT, claimTally, evidenceTally, + type ClaimTallyCounts, +} from '../lib/terms' +import { useEvidence, useVerdicts, type Slot } from '../store/evidence' +import type { + ChallengeVerdict, EvidenceBlock, EvidenceChallengeVerdicts, EvidenceDocData, EvidenceGraph, EvidenceSegment, EvidenceUnit, + EvidenceVerdict, +} from '../types' import { EvidencePanel, type PanelMode, type PanelView } from './EvidencePanel' import { askAbout, type InquiryAccess } from './Inquiry' import { BlockView, Markdown, StyledSlice, inlineStyles, numericColumns, type InlineStyles } from './Markdown' @@ -30,6 +38,9 @@ import { BlockView, Markdown, StyledSlice, inlineStyles, numericColumns, type In * * 结论句的判定（四期）只在句末挂一枚小徽标（◆ ◇ ! ○ ?），整句不画线；证据相矛盾（和旧的证据不支持）的整句 * 铺一层浅底。徽标也是按钮：点开是这一句的「模型的解释」。判定是模型给的，颜色一律不用确定性的绿。 + * 被反方审过的句子（期 4，证据图的 reports[].challenge_verdicts）同样在句末挂标记：被推翻、被削弱带字、醒目，经受住、 + * 无法判断只有淡色图标；有判定的句子并在同一枚徽标里。点开都是整句面板，没有可点片段的句子也打得开。证据图有运行就取 + * 一次；手里那份是别处早先取的、已经过期（报告改写过、运行收尾之前取的）时重取一次，见 useRunGraph。 * * 键盘：整份报告只占一个 Tab 位（roving tabindex）。←/→ 在有状态的片段、句末徽标间走，↑/↓ 按 * 句子走（表格里按列走到上一行 / 下一行，出了表格接着按句子走），n / N 跳到下一处 / @@ -69,7 +80,15 @@ const unitOfAsk = (key: string) => (key.startsWith('ask:') ? key.slice(4) : null const askable = (unit: EvidenceUnit, block: EvidenceBlock) => (unit.kind ? unit.kind === 'claim' : !!unitText(unit).trim()) && !['heading', 'code', 'hr', 'table'].includes(block.type) -interface Badge { unit: EvidenceUnit; block: number; verdict: EvidenceVerdict; state: EvidenceStateCode } +/** + * 句末徽标：结论句裁判的判定（verdict、state），和 / 或反方审稿的判断（challenge）。两样都有的并在一个徽标里，不挂两个； + * 只被反方审过的句子（没开裁判的报告、裁判没送的句子）只有 challenge + */ +interface Badge { + unit: EvidenceUnit; block: number + verdict?: EvidenceVerdict; state?: EvidenceStateCode + challenge?: string +} interface Model { /** 可点的片段和句末徽标，按正文顺序 */ @@ -98,7 +117,8 @@ interface Model { grid: Map } -function buildModel(blocks: EvidenceBlock[], overlay?: Record, ask = false): Model { +function buildModel(blocks: EvidenceBlock[], overlay?: Record, ask = false, + marks?: Record): Model { const order: string[] = [] const index = new Map() const seg = new Map() @@ -132,12 +152,15 @@ function buildModel(blocks: EvidenceBlock[], overlay?: Record[number] + +/** + * 证据图里的这一项说的是不是正文这一份：同一个报告节点，封存的就是这一稿（工件 id 对得上）。证据图说的是这个报告节点最后 + * 写的那一稿，正文是另一稿时同一个句子编号说的可能是别的话。正文没记报告节点、没给工件 id 的（预览、老文档）不按它比 + */ +const sameReport = (r: GraphReport | undefined, report: string | undefined, artifact: string | undefined) => + (!report || !r?.node_id || r.node_id === report) && (!artifact || r?.doc_artifact === artifact) + +/** + * 这次运行的证据图（正文的反方标记、按需判过的句子都从这里来）：有运行就取一次，同一次运行只取一回，不逐句请求。 + * + * 挂上（或换了一稿）那一刻手里已经有的那一份是别处早先取的，可能过期了。审批卡里展开过报告，取的就是运行停在审批上那一刻 + * 的图：之后报告改写了（第二次审批、同一张卡换稿），正文这一稿在那份图里找不到，一个标记都挂不上；正文是运行的成果 + * （settled）而那份图没封存，审批之后才审完的反方审稿不在里面。这两种按（运行、报告、工件）重取一次，重取回来还是这样 + * 就作罢（正文是改写前的原件时本来就对不上），不反复请求。挂上时还没有、正在取的那一份是这时候取的，不算过期。证据页自己 + * 管重取（pages/runs/EvidencePane） + */ +function useRunGraph(runId: string | undefined, report: string | undefined, artifact: string | undefined, settled: boolean): + EvidenceGraph | undefined { + const slot = useEvidence((s) => (runId ? s.graphs[runId] : undefined)) + const loadGraph = useEvidence((s) => s.loadGraph) + const reloadGraph = useEvidence((s) => s.reloadGraph) + const key = runId ? `${runId}\u0000${report ?? ''}\u0000${artifact ?? ''}` : '' + // 挂上、换了一稿那一刻手里已经取到的那一份：只有它可能过期，看过一次就放下 + const held = useRef<{ key: string; slot: Slot | null }>({ key: '', slot: null }) + useEffect(() => { + if (!runId || held.current.key === key) return + const cur = useEvidence.getState().graphs[runId] + held.current = { key, slot: cur?.status === 'ok' ? cur : null } + void loadGraph(runId) + }, [runId, key, loadGraph]) + useEffect(() => { + const h = held.current + if (!runId || h.key !== key || !h.slot || slot !== h.slot) return + h.slot = null + const graph = slot.data + const mine = (graph?.reports ?? []).some((r) => sameReport(r, report, artifact)) + if (!mine || (settled && !graph?.seal?.sealed)) void reloadGraph(runId) + }, [runId, key, slot, report, artifact, settled, reloadGraph]) + return slot?.data +} + +/** + * 这份报告里被反方审过的句子 → 判断（证据图 reports[].challenge_verdicts），只认说的就是正文这一份的那一项（sameReport）。 + * 没有运行、证据图还没取到（或取不到）、一句都没审、老服务端都是 undefined + */ +function challengeMarks(graph: EvidenceGraph | undefined, report: string | undefined, artifact: string | undefined): + EvidenceChallengeVerdicts | undefined { + const hit = (graph?.reports ?? []).find((r) => sameReport(r, report, artifact)) + const raw: unknown = hit?.challenge_verdicts + if (!raw || typeof raw !== 'object') return undefined + const marks = Object.fromEntries(Object.entries(raw as Record) + .filter((e): e is [string, string] => !!e[0] && typeof e[1] === 'string' && !!e[1])) + return Object.keys(marks).length ? marks : undefined +} + +/** 句末标记读屏念的那一句：截到 40 字（同 lib/evidence 的 claimLabel） */ +const markSentence = (unit: EvidenceUnit) => { + const text = unitText(unit).trim() + return text.length > 40 ? `${text.slice(0, 39)}…` : text +} + +/** 反方审稿判断的叫法：认不出的照写原值（同审批卡） */ +const challengeLabel = (v: string) => (Object.hasOwn(CHALLENGE_TEXT.verdict, v) + ? CHALLENGE_TEXT.verdict[v as keyof typeof CHALLENGE_TEXT.verdict] : CHALLENGE_TEXT.verdictUnknown(v)) + +/** + * 句末徽标的读屏名：有判定的照裁判的说法（claimLabel），被反方审过的接着说反方审稿的判断；只被反方审过的 + * 说「结论句「…」，反方审稿：被推翻」 + */ +function badgeLabel(badge: Badge): string { + const said = badge.challenge ? CHALLENGE_TEXT.markLabel(challengeLabel(badge.challenge)) : '' + if (!badge.verdict) return JUDGE_TEXT.badgeLabel(markSentence(badge.unit), said, false) + const judged = claimLabel(badge.unit, badge.verdict) + return said ? `${judged}，${said}` : judged +} + /** 片段的外观：线型走 data 属性（CSS 里只管线型），颜色写成变量交给 index.css（引文前的引号用 --ev-glyph） */ function segStyle(state: EvidenceStateCode): CSSProperties { const meta = EVIDENCE_STATE[state] @@ -243,6 +344,11 @@ export const EvidenceDoc = forwardRef(function EvidenceDoc({ doc, artifact, runId, dense = false, label, panel = 'auto', dock, onView, tally = false, runClass, - tier, inquiry }, ref) { + tier, settled = false, inquiry }, ref) { const blocks = useMemo(() => doc.blocks ?? [], [doc]) const report = doc.node_id || undefined // 质询要知道是哪次运行的哪份报告：两样缺一样就不挂入口 const ask = !!inquiry && !!runId && !!report // 封存之后按需追加的判定：盖过文档里的「未裁判 · 按需」。只换句末徽标，封存的文档一个字不改 const overlay = useVerdicts(runId, report) - const model = useMemo(() => buildModel(blocks, overlay, ask), [blocks, overlay, ask]) + // 有运行就取这次运行的证据图（同一次运行只取一次，不逐句请求；过期了重取一次）：它带着被反方审过的句子 + // （reports[].challenge_verdicts，正式、探索运行都可能有，反方审稿在报告写完之后才审，文档里没有这份记录），探索运行的 + // 报告还带着之前按需判过的句子（reports[].post_seal_verdicts，useVerdicts 读），重新打开页面时标记、徽标都还在 + const graph = useRunGraph(runId, report, artifact, settled) + // 被反方审过的句子：句末挂标记（和裁判的判定并在一个徽标里），点开是整句面板 + const marks = useMemo(() => challengeMarks(graph, report, artifact), [graph, report, artifact]) + const model = useMemo(() => buildModel(blocks, overlay, ask, marks), [blocks, overlay, ask, marks]) const counts = useMemo(() => docTally(doc), [doc]) const claims = useMemo(() => claimCounts(doc, overlay), [doc, overlay]) - // 探索运行的报告（开了裁判的按需文档，或调用方说了是探索运行）：证据图带着这次运行里之前按需判过的句子 - // （reports[].post_seal_verdicts），取一次，重新打开页面时徽标还在。别的报告不多发这个请求 - const loadGraph = useEvidence((s) => s.loadGraph) - const lateOnes = doc.judge?.mode === 'on_demand' || (runClass === 'exploratory' && doc.judge?.mode !== 'inline') - useEffect(() => { if (lateOnes && runId) void loadGraph(runId) }, [lateOnes, runId, loadGraph]) const rootRef = useRef(null) const instance = useId() const panelId = `${instance}-panel` @@ -283,9 +390,10 @@ export const EvidenceDoc = forwardRef { - if (current && !model.index.has(current)) setCurrent(model.order[0] ?? null) + if (current ? !model.index.has(current) : model.order.length > 0) setCurrent(model.order[0] ?? null) }, [model, current]) // 同一时刻只开一个面板：另一份报告打开了自己的面板，这边的就收起 @@ -341,7 +449,8 @@ export const EvidenceDoc = forwardRef close()} onLocate={(id) => { focusSeg(id, { flash: true }); openSeg(id) }} @@ -860,10 +970,51 @@ const DocBlock = memo(function DocBlock({ block, dense, doc, visual, current, ac } }) +/** 反方审稿的判断在句末徽标里的样子。soft 是悬停、展开时铺的浅底，醒目的那两种不铺（见 LOUD_RING） */ +interface MarkLook { icon: LucideIcon; color: string; soft: string; loud: boolean } + +/** + * 被推翻、被削弱醒目：盾牌图标加判断两个字，用失败色、提醒色；经受住、无法判断低调：只有淡色的盾牌图标（悬停、读屏照样 + * 说得出是哪一种）。四种图标各不相同，去掉颜色也分得开：无法判断用省略号不用问号——句末常常已经有裁判的「?」（未裁判、 + * 证据不足）和「质询」的问号，再添一个问号就分不清了，和经受住的勾也更好分。判断是反方模型给的，经受住也不用确定性的绿。 + * 认不出的判断按低调画 + */ +const MARK_LOOK: Record = { + refuted: { icon: ShieldX, color: 'var(--st-failed)', soft: 'transparent', loud: true }, + weakened: { icon: ShieldMinus, color: 'var(--st-waiting)', soft: 'transparent', loud: true }, + stands: { icon: ShieldCheck, color: 'var(--text-faint)', soft: 'var(--st-idle-soft)', loud: false }, + inconclusive: { icon: ShieldEllipsis, color: 'var(--text-faint)', soft: 'var(--st-idle-soft)', loud: false }, +} +const markLook = (verdict: string): MarkLook => (Object.hasOwn(MARK_LOOK, verdict) ? MARK_LOOK[verdict as ChallengeVerdict] + : { icon: ShieldAlert, color: 'var(--text-faint)', soft: 'var(--st-idle-soft)', loud: false }) + +/** + * 带字的醒目标记悬停、展开时不铺浅底（index.css 的 .ev-badge 按 --ev-soft 铺），改描一圈细边：10px 的失败色、提醒色字叠在 + * 14% 的浅底上，浅色主题里对比度只有 4.0 左右（页面底色上），面板开着时这枚标记一直是展开态。和裁判徽标并在一起的同样 + * 不铺（浅底是裁判判定的颜色，字是反方的颜色）。细边用徽标的字色，和焦点环（2px 强调色、外扩）分得开 + */ +const LOUD_RING = 'hover:shadow-[inset_0_0_0_1px_currentColor] aria-expanded:shadow-[inset_0_0_0_1px_currentColor]' + +/** + * 句末徽标里反方审稿的那一截。和裁判的字形并在一个徽标里时跟在字形后面（after）。醒目的那两种连字一起写：字号定成 + * 10px（同句末的「无证据」小标签），窄栏里 0.72em 的上标只有 8px，汉字认不清 + */ +function ChallengeMark({ verdict, look, after }: { verdict: string; look: MarkLook; after: boolean }) { + const Icon = look.icon + return ( + + ) +} + /** * 一句话：文字按行内 Markdown 渲染（整句算一次样式，跨片段的 `code`、**粗体** 不会 * 被切坏），有状态的片段包成按钮。含无证据片段的句子末尾挂「? 无证据」；有判定的结论句末尾挂 - * 一枚徽标（也是按钮），证据相矛盾（和旧的证据不支持）的整句铺浅底——字本身不画线 + * 一枚徽标（也是按钮），证据相矛盾（和旧的证据不支持）的整句铺浅底——字本身不画线。被反方审过的 + * 句子同样挂徽标（和判定并在一起），点开都是整句面板 */ function UnitView({ unit, doc, current, active, panelId, code, tag, badge, ask }: { unit: EvidenceUnit; doc: EvidenceDocData; current: string | null; active: string | null; panelId: string @@ -911,8 +1062,21 @@ function UnitView({ unit, doc, current, active, panelId, code, tag, badge, ask } ) }) const key = badge ? badgeKey(unit.id) : '' - const meta = badge ? EVIDENCE_STATE[badge.state] : null + const meta = badge?.state ? EVIDENCE_STATE[badge.state] : null const open = !!badge && active === key + const verdict = badge?.verdict + // 模型判过的写明谁判的、非确定（证据不足的接着写缺什么）；模型没判过的（按需还没点、到上限、没跑成）只说 + // 这是什么状态——到上限没判的也记着裁判模型，但不能写成「（模型 · 非确定）」，像是它判过一样 + const judgedTitle = !verdict || !meta ? '' + : isJudged(verdict) + ? `${meta.label}${verdict.post_seal ? ` · ${JUDGE_TEXT.postSeal}` : ''}（${verdict.judge || JUDGE_TEXT.judgeModel} · 非确定）${ + verdictMissing(verdict) ? `。${JUDGE_TEXT.missing(verdictMissing(verdict))}` : ''}` + : limitOf(verdict) ? `${meta.label}：${JUDGE_TEXT.limitNotJudged}` : `${meta.label}：${meta.hint}` + // 无法判断的句子可能根本没反查成（服务端按规则记的无法判断，反方模型没看过），正文里分不出是哪一种：不说成反方模型的判断 + const challengeTitle = !badge?.challenge ? '' + : badge.challenge === 'inconclusive' ? CHALLENGE_TEXT.markTitleUnsure(challengeLabel(badge.challenge)) + : CHALLENGE_TEXT.markTitle(challengeLabel(badge.challenge)) + const look = badge?.challenge ? markLook(badge.challenge) : null const body = ( <> {conflicting(badge?.state) @@ -924,32 +1088,34 @@ function UnitView({ unit, doc, current, active, panelId, code, tag, badge, ask } {EVIDENCE_STATE[state].glyph}{TAG_TEXT[state]} ))} - {badge && meta && ( + {badge && (meta || look) && ( )} ) if (!ask) return body // 「质询」跟在句末，是一个固定宽度的小图标：平时淡淡的，悬停这一句、焦点落在这一句上时显出来（强调色、描边）。 + // 平时也得看得清它是个可点的东西（WCAG 1.4.11 要求界面组件对背景 ≥ 3:1）：最淡的字色再压到 60% 不透明，深色约 2.75、 + // 浅色约 2.33，看不出来。改用次一级的暗字色压到 70%：深浅两套、报告摆在页面底色或面板底色上都在 3.3 以上，仍比正文 + // 淡得多；不透明度留在 0.75 以下，和悬停、聚焦时显出来（不透明、强调色）分得开。 // 显没显出来只换颜色，宽度一直是那么宽——悬停时撑开的话，后面的字整体右移，鼠标底下的数字跟着挪走，点不到。 // 触屏没有悬停，一直显出来，并写上「质询」两个字。 // 跟随的那种只在焦点在这一句上时进 Tab 顺序，整份报告不因此多出一串 Tab 位 @@ -961,7 +1127,7 @@ function UnitView({ unit, doc, current, active, panelId, code, tag, badge, ask }