dsh-crwu-workbench 0.0.10

package/skills/crwu/crwu-audit/scripts/audit_delivery.py

@@ -0,0 +1,2736 @@
+#!/usr/bin/env python3
+"""CRWU 审核意见交付工具：AuditResult 校验 + 单文件 HTML 渲染。
+
+实现《CRWU 审核意见 HTML 送达规范 v1.6》
+（正文：本技能 references/11-html-delivery-spec.md）：
+
+- AuditResult JSON 是唯一事实源；HTML 仅如实呈现，不新增/删除/合并/改写任何结论；
+- 校验覆盖 §9.4 关键校验规则 + §11.1 门禁 + §12.2 维护红线（敏感信息扫描）；
+- 渲染输出自包含单文件 HTML（内嵌 CSS、无外链资源、A4 可打印、专业审核轨迹默认折叠）。
+
+用法：
+    python3 scripts/audit_delivery.py validate <audit-result.json> [--rendered]
+    python3 scripts/audit_delivery.py render   <audit-result.json> --out <opinion.html> --json-out <result.json>
+退出码：0 成功；1 校验失败（错误打印到 stderr）。
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import html
+import json
+import re
+import sys
+from pathlib import Path
+
+RENDERER_VERSION = "renderer/1.2.6"
+TEMPLATE_PATH = Path(__file__).resolve().parent.parent / "template" / "audit-report.html"
+SCHEMA_VERSION_PREFIX = "1."
+
+SEVERITY_LABEL = {"high": "高", "medium": "中", "low": "低"}
+SEVERITY_CLASS = {"high": "sev-high", "medium": "sev-medium", "low": "sev-low"}
+ISSUE_TYPE_LABEL = {
+    "rule_defect": "规则性缺陷",
+    "reasonableness_doubt": "合理性存疑",
+    "unsupported_pending": "无依据待判",
+}
+DECISION_LABEL = {"fail": "不符合", "pending_confirmation": "需人工确认", "pass": "符合"}
+MODULE_LABEL = {
+    "dataCheck": "数据勾稽",
+    "marketApproach": "市场法",
+    "incomeApproach": "收益法",
+    "costApproach": "成本法",
+    "assetBasis": "资产基础法",
+    "reportDisclosure": "报告披露",
+    "generalStandards": "通用准则与程序",
+    "externalData": "外部数据核验",
+}
+OVERALL_LABEL = {"fail": "存在需要处理的问题", "pending_confirmation": "有待人工确认事项", "pass": "本次未发现需要处理的问题"}
+AUTHORITY_LABEL = {
+    "external_formal": "外部正式依据",
+    "internal_auxiliary": "内部辅助规则",
+    "experience_reference": "历史风险经验",
+}
+SOURCE_TYPE_LABEL = {
+    "law": "法律法规",
+    "valuation_standard": "资产评估准则",
+    "valuation_method_rule": "评估方法规则",
+    "regulatory": "监管规则",
+    "association": "行业协会要求",
+    "internal_audit": "内部审核规则",
+    "crwu_kb": "CRWU 知识库规则",
+    "risk_case": "历史风险案例",
+}
+FLOW_LABEL = {"pending_response": "待答复", "answered": "已答复", "reviewed": "已复核"}
+REVIEW_CATEGORY_LABEL = {
+    "A": "AI 与人工复核均发现",
+    "B": "仅 AI 发现",
+    "C": "AI 与复核均涉及但结论或范围不同",
+}
+REVIEWER_ONLY_LABEL = "仅人工复核发现"
+REVIEW_MATCH_VALUES = {"exact", "partial", "miss"}
+# AI 对照说明（受控常量）：逐条讲清「AI 命中与否」与「是否计入命中率分母」的因果，
+# 特别是「AI 未命中 + 复核件标注已修改」时必须核验是否确已修改，并给出两种分支的后果。
+AI_COMPARISON_NOTE = {
+    ("miss", "L-resolved"):
+        "AI 未命中｜复核件标注该项「已修改」：已按在件核验确认该项确已修改（复核事项在被审件中已不存在）→ 不计入命中率分母；"
+        "若核验发现并未修改，则须计入分母并计为 AI 漏检",
+    ("miss", "L-open"):
+        "AI 未命中｜已在件核验：该项并未修改 → 计入命中率分母，计为 AI 漏检",
+    ("miss", "L-unclosed"):
+        "AI 未命中｜答复称已改但被审件未落地：计入命中率分母并计为漏检，优先回客户",
+    ("miss", "L-uncheckable"):
+        "AI 未命中｜材料缺失或不可读·未能核验：不计入命中率分母，登记为未检查项（未核≠未命中）",
+    ("exact", "L-resolved"):
+        "AI 精确命中｜复核意见在被审件中已落实：不计入命中率分母（作人工工作成果呈现）",
+    ("partial", "L-resolved"):
+        "AI 部分命中｜复核意见在被审件中已落实：不计入命中率分母（作人工工作成果呈现）",
+    ("exact", "L-open"):
+        "AI 精确命中｜被审件未落实：计入命中率分母",
+    ("partial", "L-open"):
+        "AI 部分命中｜被审件未落实：计入命中率分母",
+    ("exact", "L-unclosed"):
+        "AI 精确命中｜答复称已改但被审件未落地：计入命中率分母，优先回客户",
+    ("partial", "L-unclosed"):
+        "AI 部分命中｜答复称已改但被审件未落地：计入命中率分母，优先回客户",
+    ("exact", "L-uncheckable"):
+        "AI 精确命中｜材料缺失或不可读·未能核验：不计入命中率分母，登记为未检查项",
+    ("partial", "L-uncheckable"):
+        "AI 部分命中｜材料缺失或不可读·未能核验：不计入命中率分母，登记为未检查项",
+}
+AI_COMPARISON_NOTE_FALLBACK = "AI 对照状态未完整标注（matchStatus / inFileResolution 缺失）"
+
+HIT_LEVEL_LABEL = [
+    ("exact", "精确命中"),
+    ("partial", "部分命中"),
+    ("miss", "未命中"),
+]
+REVIEW_MATCH_LABEL = {
+    "exact": "AI 精确命中",
+    "partial": "AI 部分命中",
+    "miss": "AI 未命中",
+}
+REASON_LABEL = {
+    "missing_material": "缺材料",
+    "unreadable": "不可读",
+    "unsupported": "能力不支持",
+    "out_of_scope": "超出本次范围",
+    "not_applicable": "不适用",
+}
+RESULT_LABEL = {"pass": "符合", "difference": "差异", "not_applicable": "不适用", "not_checked": "未检查"}
+CONFIDENCE_LABEL = {"high": "高", "medium": "中", "low": "低"}
+REVIEW_STATUS_LABEL = {"not_performed": "未执行", "performed": "已执行"}
+
+EMPTY_TEXT = "本次无此类事项"
+EXT_DATA_EMPTY_TEXT = "本次未提供外部数据核验适用性判断"
+EXT_DATA_NO_CHECK_TEXT = "本次无可核验的外部数据项"
+EXT_DATA_NOT_APPLICABLE_TEXT = "本报告暂不涉及外部数据核验"
+EXT_DATA_APPLICABILITY_LABEL = {"required": "需要外部数据核验", "not_applicable": "不适用"}
+EXT_DATA_DECISIONS = ("符合", "不符合", "请说明", "未检查")
+EXT_DATA_UNAVAILABLE_TEXT = "不可用（未经外部数据核验）"
+EXT_DATA_NOT_FETCHED_TEXT = "未取数"
+EXT_DATA_NO_DEVIATION_TEXT = "无出入（符合）"
+EXT_DATA_UNSPECIFIED_SOURCE_TEXT = "未列明来源"
+SUMMARY_DIGEST_ITEM_LIMIT = 3
+
+HEX64 = re.compile(r"^[0-9a-f]{64}$")
+ABSOLUTE_PATH_PATTERNS = [
+    (re.compile(r"(?:^|[^A-Za-z0-9])/(?:Users|home|var|tmp|private|Volumes|opt)/"), "绝对路径"),
+    (re.compile(r"\b[A-Za-z]:[\\/]"), "Windows 绝对路径"),
+    (re.compile(r"file://"), "file:// 地址"),
+]
+FORBIDDEN_KEY_PATTERN = re.compile(r"(?i)(token|api[_-]?key|cookie|password|passwd|secret|connection[_-]?string|nodeId)")
+
+# ---- §4.6 问题描述写法：员工可读性硬校验（首句 + 明细两段式） ----
+PROBLEM_HEADLINE_MAX = 60
+PROBLEM_DETAIL_MAX_LINES = 4
+PROBLEM_DETAIL_MIN_LINES = 2
+PROBLEM_DETAIL_LINE_MAX = 80
+PROBLEM_TEXT_MAX = 420
+PROBLEM_HEADLINE_FORBIDDEN_LABEL = "规则编号/内部代号"
+PROBLEM_SENTENCE_TERMINATORS = "。；！？"
+PROBLEM_LOCATOR_ANCHOR_PATTERN = re.compile(
+    r"(?<!\d)(?:\.[A-Za-z]{2,5}(?![A-Za-z0-9])"
+    r"|(?<![A-Za-z0-9])[A-Za-z]{1,3}\d{1,4}(?::[A-Za-z]{1,3}\d{1,4})?"
+    r"|!\s*\S)"
+    r"|第\s*\d+\s*[页条项]"
+    r"|「|」"
+)
+PROBLEM_HEADLINE_FORBIDDEN_PATTERNS = [
+    (re.compile(r"\b(?:RULE|CHK|KB|ISS)-[A-Za-z0-9][A-Za-z0-9._-]*"), PROBLEM_HEADLINE_FORBIDDEN_LABEL),
+    (re.compile(r"kb[_-]?id", re.IGNORECASE), PROBLEM_HEADLINE_FORBIDDEN_LABEL),
+    # 知识库相对路径形如 `06-规则库/…`：`/` 后必须是中文路径段，
+    # 否则区间值（0-50/51-100）与页码（L206-L302）会被误判（真实项目回测修正）。
+    (re.compile(r"\d{2}-[\u4e00-\u9fff][^\s，。；、]{0,}/"), "知识库相对路径"),
+]
+PROBLEM_DETAIL_FORBIDDEN = PROBLEM_HEADLINE_FORBIDDEN_PATTERNS[:2]
+# 首句是员工唯一的“一句话结论”，不得出现公式、区域坐标、文件!表 定位串或案例目录内相对路径；
+# 现象要用普通话描述，精确坐标放明细行。口径源自真实项目回测（ISS-DC-001 等 20 条坐标串堆叠）。
+PROBLEM_HEADLINE_TECHNICAL_PATTERN = re.compile(
+    r"=|\b(?:SUM|AVERAGE|IF|VLOOKUP)\("
+    r"|[A-Za-z]{1,3}\d{1,4}:[A-Za-z]{1,3}\d{1,4}"
+    r"|[^\s，。；]{2,}\.(?:xlsx|xls|docx|doc|pdf)!"
+    r"|(?:工作版|提取|材料-源|raw)/"
+)
+PROBLEM_TEXT_FORBIDDEN_PATTERNS = [
+    (re.compile(r"\d{2}-[\u4e00-\u9fff][^\s，。；、]{0,}/"), "知识库相对路径"),
+    (re.compile(r"(?i)\bnodeId\b"), "nodeId"),
+    (re.compile(r"file://"), "file:// 地址"),
+    (re.compile(r"(?:^|[^A-Za-z0-9])/(?:Users|home|var|tmp|private|Volumes|opt)/"), "绝对路径"),
+    (re.compile(r"\b[A-Za-z]:[\\/]"), "Windows 绝对路径"),
+]
+
+REQUIRED_TOP_LEVEL = [
+    "schemaVersion",
+    "auditTask",
+    "phaseControl",
+    "summary",
+    "issues",
+    "manualConfirmationItems",
+    "auditBasis",
+    "reviewComparison",
+    "scope",
+    "professionalTrail",
+    "fileTrace",
+    "renderPolicy",
+]
+
+ISSUE_REQUIRED = [
+    "issueId",
+    "title",
+    "module",
+    "locationSummary",
+    "severity",
+    "issueType",
+    "decision",
+    "problemDescription",
+    "handlingRequirement",
+    "ruleEvidence",
+    "materialEvidence",
+    "gapAnalysis",
+    "recommendedEdits",
+    "flowStatus",
+    "confidence",
+    "reviewComparison",
+]
+
+RULE_REQUIRED = [
+    "ruleId",
+    "authorityClass",
+    "sourceType",
+    "title",
+    "version",
+    "clause",
+    "quote",
+    "kbRelativePath",
+    "exportedAt",
+    "usageCount",
+    "purposes",
+    "usedByIssueIds",
+]
+
+MATERIAL_EVIDENCE_REQUIRED = ["fileId", "displayName", "locator", "excerptOrValue", "evidenceRole"]
+NOT_CHECKED_REQUIRED = ["itemId", "item", "reasonCode", "reason", "impact", "requiredAction", "relatedFiles"]
+MANUAL_ITEM_REQUIRED = [
+    "itemId",
+    "title",
+    "locationSummary",
+    "observation",
+    "questionToConfirm",
+    "evidence",
+    "suggestedAction",
+]
+CHECK_RECORD_REQUIRED = [
+    "recordId",
+    "domain",
+    "checkItem",
+    "targets",
+    "evidence",
+    "result",
+    "linkedIssueIds",
+    "performedAt",
+    "executor",
+]
+REVIEWER_ONLY_REQUIRED = ["itemId", "title", "reviewerEvidence", "handling", "inFileResolution"]
+# 能力边界条目：AI 当前不具备该层能力（如底稿审核），不计分母/不计漏检，但必须登记备查并渲染
+OUT_OF_SCOPE_REQUIRED = ["itemId", "title", "reviewerEvidence", "handling", "exclusionReason"]
+# 工具能力声明（受控常量，非业务结论）：必须在每份交付件中显式出现
+CAPABILITY_WORKPAPER_NOTICE = (
+    "本工具当前暂不支持底稿文件审核：底稿类复核意见不计入 AI 命中率，仅登记备查并交人工底稿审核。"
+)
+# ---- AI 审核评分卡（自评；量化工种差距。维度与算法为技能内受控取值，知识库暂无对应词表） ----
+SCORECARD_DIMENSIONS = [
+    ("first_delivery_correctness", "首轮交付正确性"),
+    ("self_correction", "自我纠错与定位"),
+    ("incremental_value", "增量发现价值"),
+    ("coverage_completeness", "覆盖完整性"),
+    ("process_discipline", "过程纪律与可追溯"),
+    ("judgment_quality", "本轮判断质量"),
+]
+SCORECARD_DIMENSION_KEYS = [key for key, _label in SCORECARD_DIMENSIONS]
+SCORECARD_LEVELS = ("初审", "复审", "终审")
+SCORECARD_ERROR_KINDS = {"false_positive", "correction", "omission", "wording"}
+SCORECARD_ERROR_KIND_LABEL = {
+    "false_positive": "假阳性（原判不成立）",
+    "correction": "事实更正（结论成立但表述有误）",
+    "omission": "漏检（人工复核已提出而 AI 未命中）",
+    "wording": "表述修正",
+}
+
+
+def _round_half_up(value: float) -> float:
+    """按 0.5 取整（四舍五入，非银行家舍入）。"""
+    import math
+    return math.floor(value * 2 + 0.5) / 2.0
+
+
+def _mean_score(dimensions: list) -> float:
+    scores = [float(d.get("score")) for d in dimensions]
+    return _round_half_up(sum(scores) / len(scores))
+IN_FILE_RESOLUTION_VALUES = {"L-resolved", "L-open", "L-unclosed", "L-uncheckable"}
+IN_FILE_RESOLUTION_LABEL = {
+    "L-resolved": "复核已提出 · 被审件已落实",
+    "L-open": "复核已提出 · 被审件未落实",
+    "L-unclosed": "复核答复称已改 · 被审件未落地",
+    "L-uncheckable": "材料缺失或不可读 · 未能核验",
+}
+# 受控占位标签：无在件位置时不得留空白单元格（送达规范 §10.3）
+IN_FILE_ABSENT_LABEL = "未做在件核验（材料不可及或超出本次范围）"
+
+
+def _percentage(numerator: int, denominator: int):
+    return round(numerator * 100.0 / denominator, 1) if denominator else None
+
+
+def _review_metrics(items: list) -> dict:
+    """从逐条复核事实重算客观指标；已落实与无法核验不进入命中率分母。
+
+    口径（2026-09-16 修订）：**部分命中是命中，只是层次较低** ——
+    命中率 = (exact + partial) / evaluable；exact/partial/miss 作为**命中层次**单列。
+    不得用 exact/evaluable 冒充“命中率”（那等于把部分命中当未命中）。
+    `strictHitRate` / `coverageRate` 仅为历史 JSON 兼容别名，展示名分别降为
+    「精确命中率」与「命中率」，不得再作为独立主指标。
+    """
+    resolved = [item for item in items if item.get("inFileResolution") == "L-resolved"]
+    uncheckable = [item for item in items if item.get("inFileResolution") == "L-uncheckable"]
+    evaluable_items = [
+        item for item in items
+        if item.get("inFileResolution") not in ("L-resolved", "L-uncheckable")
+    ]
+    exact = sum(item.get("matchStatus") == "exact" for item in evaluable_items)
+    partial = sum(item.get("matchStatus") == "partial" for item in evaluable_items)
+    misses = sum(item.get("matchStatus") == "miss" for item in evaluable_items)
+    denominator = len(evaluable_items)
+    hit_rate = _percentage(exact + partial, denominator)
+    exact_rate = _percentage(exact, denominator)
+    return {
+        "total": len(items),
+        "resolved": len(resolved),
+        "uncheckable": len(uncheckable),
+        "evaluable": denominator,
+        "exactHits": exact,
+        "partialHits": partial,
+        "misses": misses,
+        "hitRate": hit_rate,
+        "exactRate": exact_rate,
+        "partialRate": _percentage(partial, denominator),
+        "missRate": _percentage(misses, denominator),
+        "strictHitRate": exact_rate,
+        "coverageRate": hit_rate,
+    }
+
+
+def _header_hit_rate_caliber(comparison) -> str:
+    """首屏命中率口径表（精确数字，按全部复核级次汇总）。
+
+    口径：分母 = 员工复核意见中**未修改（未落实）**的条目；分子 = **AI 命中**的条目
+    （精确命中 + 部分命中）。已剔除项、未命中项与各复核级次条数一并列出，
+    使读者可直接复核分母构成，不会误以为只统计了某一级复核。
+    """
+    items = comparison.get("reviewItems") or []
+    if not items:
+        return ""
+    metrics = _review_metrics(items)
+    out_of_scope = comparison.get("outOfScopeItems") or []
+    levels = []
+    for entry in sorted(comparison.get("reviewFiles") or [], key=lambda e: e.get("order", 9999)):
+        level = entry.get("level")
+        if _is_nonempty_str(level) and level not in levels:
+            levels.append(level)
+    rows = []
+    for level in levels:
+        count = sum(1 for i in items if i.get("reviewLevel") == level)
+        if not count:
+            continue  # 该级次条目已整体移入能力边界登记备查（如底稿层），不在此表列 0
+        rows.append(("复核意见（按级次）", level, count))
+    rows.extend([
+        ("复核意见（按级次）", "合计", metrics["total"]),
+        ("命中率分母", "员工复核中未修改（未落实）", metrics["evaluable"]),
+        ("命中率分子", "AI 命中 · 精确命中", metrics["exactHits"]),
+        ("命中率分子", "AI 命中 · 部分命中", metrics["partialHits"]),
+        ("AI 未命中", "计入分母并计为漏检", metrics["misses"]),
+        ("已剔除 · 不计入分母", "已在件落实（含已修改故 AI 不可能命中）", metrics["resolved"]),
+        ("已剔除 · 不计入分母", "材料缺失或不可读（未能核验）", metrics["uncheckable"]),
+        ("已剔除 · 不计入分母", "能力边界（底稿类，仅登记备查）", len(out_of_scope)),
+    ])
+    numerator = metrics["exactHits"] + metrics["partialHits"]
+    rows.extend([
+        ("结果", "分子 ÷ 分母 = 命中率", "{0} ÷ {1} = {2}".format(
+            numerator, metrics["evaluable"], _format_rate(metrics["hitRate"]))),
+        ("结果（层次）", "精确命中率（精确命中 ÷ 分母）", "{0} ÷ {1} = {2}".format(
+            metrics["exactHits"], metrics["evaluable"], _format_rate(metrics["exactRate"]))),
+    ])
+    parts = ['<h4>{0}</h4>'.format(_text("命中率口径（精确数字 · 按全部复核级次汇总）")),
+             '<p class="formula">{0}</p>'.format(_text(
+                 "分母＝员工复核意见中未修改（未落实）的条目；分子＝AI 命中的条目（精确命中＋部分命中）。"
+                 "已在件落实、材料缺失或不可读、超出能力层的条目不进入分母。")),
+             '<div class="table-scroll"><table><thead><tr>' + "".join(
+                 '<th scope="col">{0}</th>'.format(_text(label)) for label in ("口径", "分组", "条数 / 结果")
+             ) + "</tr></thead><tbody>"]
+    for row in rows:
+        parts.append("<tr>" + "".join("<td>{0}</td>".format(_text(cell)) for cell in row) + "</tr>")
+    parts.append("</tbody></table></div>")
+    return "".join(parts)
+
+
+def _hit_level_row(metrics: dict) -> str:
+    """命中层次：精确/部分/未命中三档条数与占比；部分命中是命中，只标层次。"""
+    denominator = metrics.get("evaluable") or 0
+    if not denominator:
+        return ""
+    cells = []
+    for key, label in HIT_LEVEL_LABEL:
+        count = {"exact": metrics.get("exactHits"), "partial": metrics.get("partialHits"),
+                 "miss": metrics.get("misses")}[key]
+        rate = {"exact": metrics.get("exactRate"), "partial": metrics.get("partialRate"),
+                "miss": metrics.get("missRate")}[key]
+        cells.append('<span>{0}：{1} / {2}（{3}）</span>'.format(
+            _text(label), _text(count), _text(denominator), _text(_format_rate(rate))))
+    return '<p class="formula hit-levels">{0}{1}</p>'.format(_text("命中层次："), "".join(cells))
+
+
+def _format_rate(value) -> str:
+    return "不适用" if value is None else "{0:.1f}%".format(float(value))
+
+
+# --------------------------------------------------------------------------- #
+# 基础工具
+# --------------------------------------------------------------------------- #
+def canonical_json(value) -> str:
+    """确定性序列化：字段排序、UTF-8、无多余空白（摘要与嵌入均基于它）。"""
+    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+
+
+def sha256_hex(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def load_result(path: Path) -> dict:
+    with path.open("r", encoding="utf-8") as handle:
+        data = json.load(handle)
+    if not isinstance(data, dict):
+        raise ValueError("AuditResult 顶层必须是 JSON 对象")
+    return data
+
+
+def iter_all_scalars(value):
+    if isinstance(value, dict):
+        for key, item in value.items():
+            yield str(key)
+            for scalar in iter_all_scalars(item):
+                yield scalar
+    elif isinstance(value, list):
+        for item in value:
+            for scalar in iter_all_scalars(item):
+                yield scalar
+    elif value is None:
+        return
+    else:
+        yield value if isinstance(value, str) else str(value)
+
+
+def iter_keys(value):
+    if isinstance(value, dict):
+        for key, item in value.items():
+            yield str(key)
+            for nested in iter_keys(item):
+                yield nested
+    elif isinstance(value, list):
+        for item in value:
+            for nested in iter_keys(item):
+                yield nested
+
+
+def scan_sensitive(result: dict):
+    """§10.1 / §12.2：绝对路径、file://、nodeId、凭据类字段一律不得进入交付物。"""
+    errors = []
+    for key in iter_keys(result):
+        match = FORBIDDEN_KEY_PATTERN.search(key)
+        if match:
+            errors.append("禁止字段名 {0}（交付物不得含 nodeId 或任何凭据类字段）".format(key))
+    for text in iter_all_scalars(result):
+        for pattern, label in ABSOLUTE_PATH_PATTERNS:
+            if pattern.search(text):
+                errors.append("禁止出现{0}：{1}".format(label, text[:80]))
+    return errors
+
+
+# --------------------------------------------------------------------------- #
+# 校验（§9.4 / §11.1）
+# --------------------------------------------------------------------------- #
+def _is_nonempty_str(value) -> bool:
+    return isinstance(value, str) and value.strip() != ""
+
+
+def _check_relative_path(value: str) -> bool:
+    if not _is_nonempty_str(value):
+        return False
+    if value.startswith("/") or value.startswith("~") or value.startswith("file://"):
+        return False
+    if re.match(r"^[A-Za-z]:", value):
+        return False
+    return True
+
+
+def _parse_time(value: str):
+    try:
+        return __import__("datetime").datetime.fromisoformat(value)
+    except ValueError:
+        return None
+
+
+def split_problem_description(value) -> tuple:
+    """按 §4.6 把 problemDescription 拆为（首句, [明细行]）。
+
+    renderer 只做分段与呈现，不改写任何业务句子。校验器与渲染器共用同一解析口径。
+    """
+    if not isinstance(value, str):
+        return "", []
+    blocks = [block.strip() for block in value.split("\n") if block.strip()]
+    if not blocks:
+        return "", []
+    return blocks[0], blocks[1:]
+
+
+def _issue_location_anchors(issue: dict) -> list:
+    """收集本条问题真实存在的材料落点：材料证据文件名 + 建议修改文件名。"""
+    anchors = []
+    for bucket in ("materialEvidence", "recommendedEdits"):
+        items = issue.get(bucket)
+        if not isinstance(items, list):
+            continue
+        for item in items:
+            if isinstance(item, dict) and _is_nonempty_str(item.get("displayName")):
+                anchors.append(str(item["displayName"]).strip())
+    return anchors
+
+
+def validate_problem_description(where: str, issue: dict) -> list:
+    """§4.6 问题描述写法硬校验：首句 + 明细两段式，员工可直接核对。
+
+    返回以 where 开头的错误字符串列表；空列表表示通过。
+    """
+    errors = []
+    raw = issue.get("problemDescription")
+    if not _is_nonempty_str(raw):
+        # 空值由字段必填校验统一报错，这里不重复报
+        return errors
+    text = str(raw)
+    headline, details = split_problem_description(text)
+    if not headline:
+        errors.append("{0}.problemDescription 缺少首句（须先一句话说清问题是什么）".format(where))
+        return errors
+    if len(headline) > PROBLEM_HEADLINE_MAX:
+        errors.append(
+            "{0}.problemDescription 首句 {1} 字，超过 {2} 字上限（首句只写问题是什么，其余内容移到明细行）".format(
+                where, len(headline), PROBLEM_HEADLINE_MAX
+            )
+        )
+    if headline[-1] not in PROBLEM_SENTENCE_TERMINATORS:
+        errors.append(
+            "{0}.problemDescription 首句未以句读收尾（须以 。；！？ 之一结束）".format(where)
+        )
+    if PROBLEM_HEADLINE_TECHNICAL_PATTERN.search(headline):
+        errors.append(
+            "{0}.problemDescription 首句含公式/单元格坐标/文件定位串，员工读不懂："
+            "首句用普通话写清现象，精确坐标移到明细行".format(where)
+        )
+    if len(details) < PROBLEM_DETAIL_MIN_LINES:
+        errors.append(
+            "{0}.problemDescription 必须是两段式：明细 {1} 行，少于 {2} 行下限".format(
+                where, len(details), PROBLEM_DETAIL_MIN_LINES
+            )
+        )
+    if len(details) > PROBLEM_DETAIL_MAX_LINES:
+        errors.append(
+            "{0}.problemDescription 明细 {1} 行，超过 {2} 行上限".format(
+                where, len(details), PROBLEM_DETAIL_MAX_LINES
+            )
+        )
+    for position, detail in enumerate(details, start=2):
+        if len(detail) > PROBLEM_DETAIL_LINE_MAX:
+            errors.append(
+                "{0}.problemDescription 明细第 {1} 行 {2} 字，超过 {3} 字上限（请拆成短句）".format(
+                    where, position - 1, len(detail), PROBLEM_DETAIL_LINE_MAX
+                )
+            )
+        if detail[-1] in PROBLEM_SENTENCE_TERMINATORS:
+            continue
+        if PROBLEM_LOCATOR_ANCHOR_PATTERN.search(detail):
+            # 以文件名/单元格/页码等落点收尾的明细行本身就是可核对指令，不强行加句号
+            continue
+        errors.append(
+            "{0}.problemDescription 明细第 {1} 行既未以句读收尾（。；！？），"
+            "也未以文件、sheet、单元格或页码等可核对落点收尾".format(where, position - 1)
+        )
+    if len(text) > PROBLEM_TEXT_MAX:
+        errors.append(
+            "{0}.problemDescription 共 {1} 字，超过 {2} 字上限（规则要求与判定链放 gapAnalysis）".format(
+                where, len(text), PROBLEM_TEXT_MAX
+            )
+        )
+    for pattern, label in PROBLEM_HEADLINE_FORBIDDEN_PATTERNS:
+        if pattern.search(headline):
+            errors.append(
+                "{0}.problemDescription 首句含{1}，员工看不懂：请改为具体现象，编号与路径放规则依据".format(where, label)
+            )
+    for pattern, label in PROBLEM_DETAIL_FORBIDDEN:
+        if pattern.search(" ".join(details)):
+            errors.append(
+                "{0}.problemDescription 明细含{1}，请移除（规则出处放「展开判断依据与规则」）".format(where, label)
+            )
+    for pattern, label in PROBLEM_TEXT_FORBIDDEN_PATTERNS:
+        if pattern.search(text):
+            errors.append("{0}.problemDescription 含{1}，禁止出现在员工交付内容中".format(where, label))
+
+    anchors = _issue_location_anchors(issue)
+    detail_text = " ".join(details)
+    has_anchor = any(anchor and anchor in detail_text for anchor in anchors) or bool(
+        PROBLEM_LOCATOR_ANCHOR_PATTERN.search(detail_text)
+    )
+    if not has_anchor:
+        errors.append(
+            "{0}.problemDescription 明细未给出可核对的文件与位置："
+            "请写明本次材料中的具体文件名（如 报告.docx、评估说明.xlsx），以及 sheet 名、"
+            "单元格/区域、第 N 页或章节名".format(where)
+        )
+    return errors
+
+
+def validate(result: dict, rendered: bool = False, expect_renderer: bool = False):
+    errors = []
+    for key in REQUIRED_TOP_LEVEL:
+        if key not in result:
+            errors.append("缺少顶层字段 {0}".format(key))
+    if errors:
+        return errors
+
+    schema_version = result.get("schemaVersion")
+    if not _is_nonempty_str(schema_version) or not str(schema_version).startswith(SCHEMA_VERSION_PREFIX):
+        errors.append("schemaVersion 必须是 {0}x 版本".format(SCHEMA_VERSION_PREFIX))
+
+    # auditTask
+    audit_task = result.get("auditTask") or {}
+    for field in ("projectId", "reportVersion", "auditTime", "engineVersion"):
+        if not _is_nonempty_str(audit_task.get(field)):
+            errors.append("auditTask.{0} 不得为空".format(field))
+
+    # phaseControl（§11 两阶段门禁）
+    phase = result.get("phaseControl") or {}
+    frozen_at = phase.get("phase1FrozenAt")
+    digest = phase.get("phase1Digest")
+    accessed_at = phase.get("reviewAccessedAt")
+    phase2_at = phase.get("phase2CompletedAt")
+    if not _is_nonempty_str(frozen_at):
+        errors.append("phaseControl.phase1FrozenAt 不得为空")
+    if not _is_nonempty_str(digest) or not HEX64.match(str(digest)):
+        errors.append("phaseControl.phase1Digest 必须是 sha256 十六进制摘要")
+    if _is_nonempty_str(accessed_at):
+        if not _is_nonempty_str(frozen_at):
+            errors.append("存在 reviewAccessedAt 时必须先记录 phase1FrozenAt")
+        else:
+            frozen_dt, accessed_dt = _parse_time(str(frozen_at)), _parse_time(str(accessed_at))
+            if frozen_dt is None or accessed_dt is None:
+                errors.append("phaseControl 时间必须为 ISO-8601 字符串")
+            elif accessed_dt <= frozen_dt:
+                errors.append("reviewAccessedAt 必须晚于 phase1FrozenAt（阶段一必须先冻结）")
+    if _is_nonempty_str(phase2_at):
+        if not _is_nonempty_str(accessed_at):
+            errors.append("phase2CompletedAt 非空时必须记录 reviewAccessedAt")
+        else:
+            accessed_dt, phase2_dt = _parse_time(str(accessed_at)), _parse_time(str(phase2_at))
+            if accessed_dt and phase2_dt and phase2_dt < accessed_dt:
+                errors.append("phase2CompletedAt 不得早于 reviewAccessedAt")
+
+    # issues
+    issues = result.get("issues")
+    if not isinstance(issues, list):
+        errors.append("issues 必须是数组")
+        issues = []
+    seen_issue_ids = set()
+    rules_used_by_issues = {}
+    review_categories = {"A": 0, "B": 0, "C": 0}
+    severity_counts = {"high": 0, "medium": 0, "low": 0}
+    fail_count = 0
+
+    for index, issue in enumerate(issues):
+        where = "issues[{0}]".format(index)
+        if not isinstance(issue, dict):
+            errors.append("{0} 必须是对象".format(where))
+            continue
+        for field in ISSUE_REQUIRED:
+            if field not in issue:
+                errors.append("{0} 缺少字段 {1}".format(where, field))
+        issue_id = issue.get("issueId")
+        if not _is_nonempty_str(issue_id):
+            errors.append("{0}.issueId 不得为空".format(where))
+        elif issue_id in seen_issue_ids:
+            errors.append("issueId 重复：{0}".format(issue_id))
+        else:
+            seen_issue_ids.add(issue_id)
+        for field, label in (("severity", "severity"), ("issueType", "issueType"), ("decision", "decision")):
+            value = issue.get(field)
+            table = {"severity": SEVERITY_LABEL, "issueType": ISSUE_TYPE_LABEL, "decision": DECISION_LABEL}[field]
+            if value not in table:
+                errors.append("{0}.{1} 取值非法：{2}".format(where, label, value))
+        for field in ("title", "problemDescription", "handlingRequirement", "locationSummary", "module"):
+            if not _is_nonempty_str(issue.get(field)):
+                errors.append("{0}.{1} 不得为空".format(where, field))
+        errors.extend(validate_problem_description(where, issue))
+
+        severity = issue.get("severity")
+        if severity in severity_counts and issue.get("decision") == "fail":
+            severity_counts[severity] += 1
+        if issue.get("decision") == "fail":
+            fail_count += 1
+
+        rule_evidence = issue.get("ruleEvidence")
+        material_evidence = issue.get("materialEvidence")
+        if not isinstance(rule_evidence, list):
+            errors.append("{0}.ruleEvidence 必须是数组".format(where))
+            rule_evidence = []
+        if not isinstance(material_evidence, list):
+            errors.append("{0}.materialEvidence 必须是数组".format(where))
+            material_evidence = []
+        if not material_evidence:
+            errors.append("{0}.materialEvidence 至少一条（材料证据缺失不得形成结论）".format(where))
+        if issue.get("decision") == "fail" and issue.get("issueType") == "rule_defect" and not rule_evidence:
+            errors.append("{0} 规则性缺陷不通过必须同时具备规则证据与材料证据".format(where))
+        for position, evidence in enumerate(material_evidence):
+            if not isinstance(evidence, dict):
+                errors.append("{0}.materialEvidence[{1}] 必须是对象".format(where, position))
+                continue
+            for field in MATERIAL_EVIDENCE_REQUIRED:
+                if not _is_nonempty_str(evidence.get(field)) and field != "evidenceRole":
+                    errors.append("{0}.materialEvidence[{1}].{2} 不得为空".format(where, position, field))
+            if not _is_nonempty_str(evidence.get("evidenceRole")):
+                errors.append("{0}.materialEvidence[{1}].evidenceRole 不得为空".format(where, position))
+        for position, evidence in enumerate(rule_evidence):
+            if not isinstance(evidence, dict):
+                errors.append("{0}.ruleEvidence[{1}] 必须是对象".format(where, position))
+                continue
+            rule_id = evidence.get("ruleId")
+            if not _is_nonempty_str(rule_id):
+                errors.append("{0}.ruleEvidence[{1}].ruleId 不得为空".format(where, position))
+            else:
+                rules_used_by_issues.setdefault(str(rule_id), set()).add(str(issue_id))
+            if not _is_nonempty_str(evidence.get("quote")):
+                errors.append("{0}.ruleEvidence[{1}].quote 不得为空（须为本次真实读取原文）".format(where, position))
+
+        gap = issue.get("gapAnalysis") or {}
+        if not isinstance(gap, dict):
+            errors.append("{0}.gapAnalysis 必须是对象".format(where))
+        else:
+            for field in ("ruleRequirement", "observedCondition", "difference", "finalJudgment"):
+                if not _is_nonempty_str(gap.get(field)):
+                    errors.append("{0}.gapAnalysis.{1} 不得为空".format(where, field))
+
+        edits = issue.get("recommendedEdits")
+        if not isinstance(edits, list) or not edits:
+            errors.append("{0}.recommendedEdits 至少一条".format(where))
+        else:
+            for position, edit in enumerate(edits):
+                if not isinstance(edit, dict):
+                    errors.append("{0}.recommendedEdits[{1}] 必须是对象".format(where, position))
+                    continue
+                for field in ("fileId", "displayName", "locator", "action"):
+                    if not _is_nonempty_str(edit.get(field)):
+                        errors.append("{0}.recommendedEdits[{1}].{2} 不得为空".format(where, position, field))
+
+        if issue.get("flowStatus") not in FLOW_LABEL:
+            errors.append("{0}.flowStatus 取值非法：{1}".format(where, issue.get("flowStatus")))
+        confidence = issue.get("confidence") or {}
+        if not isinstance(confidence, dict) or confidence.get("level") not in CONFIDENCE_LABEL:
+            errors.append("{0}.confidence.level 取值非法".format(where))
+        elif not _is_nonempty_str(confidence.get("reason")):
+            errors.append("{0}.confidence.reason 不得为空".format(where))
+
+        comparison = issue.get("reviewComparison") or {}
+        if not isinstance(comparison, dict) or comparison.get("status") not in REVIEW_STATUS_LABEL:
+            errors.append("{0}.reviewComparison.status 取值非法".format(where))
+        elif comparison.get("status") == "performed":
+            category = comparison.get("category")
+            if category not in review_categories:
+                errors.append("{0}.reviewComparison.category 必须是 A/B/C".format(where))
+            else:
+                review_categories[category] += 1
+
+    # manualConfirmationItems
+    manual_items = result.get("manualConfirmationItems")
+    if not isinstance(manual_items, list):
+        errors.append("manualConfirmationItems 必须是数组")
+        manual_items = []
+    manual_ids = set()
+    for index, item in enumerate(manual_items):
+        where = "manualConfirmationItems[{0}]".format(index)
+        if not isinstance(item, dict):
+            errors.append("{0} 必须是对象".format(where))
+            continue
+        for field in MANUAL_ITEM_REQUIRED:
+            if field not in item:
+                errors.append("{0} 缺少字段 {1}".format(where, field))
+        item_id = item.get("itemId")
+        if not _is_nonempty_str(item_id):
+            errors.append("{0}.itemId 不得为空".format(where))
+        elif item_id in manual_ids:
+            errors.append("manualConfirmationItems.itemId 重复：{0}".format(item_id))
+        else:
+            manual_ids.add(item_id)
+        for field in ("title", "locationSummary", "observation", "questionToConfirm", "suggestedAction"):
+            if not _is_nonempty_str(item.get(field)):
+                errors.append("{0}.{1} 不得为空".format(where, field))
+        if not isinstance(item.get("evidence"), list) or not item.get("evidence"):
+            errors.append("{0}.evidence 至少一条".format(where))
+
+    # auditBasis
+    audit_basis = result.get("auditBasis") or {}
+    rules = audit_basis.get("rules")
+    if not isinstance(rules, list) or not rules:
+        errors.append("auditBasis.rules 至少一条（只列本次实际使用规则）")
+        rules = []
+    seen_rule_ids = set()
+    for index, rule in enumerate(rules):
+        where = "auditBasis.rules[{0}]".format(index)
+        if not isinstance(rule, dict):
+            errors.append("{0} 必须是对象".format(where))
+            continue
+        for field in RULE_REQUIRED:
+            if field not in rule:
+                errors.append("{0} 缺少字段 {1}".format(where, field))
+        rule_id = rule.get("ruleId")
+        if not _is_nonempty_str(rule_id):
+            errors.append("{0}.ruleId 不得为空".format(where))
+        elif rule_id in seen_rule_ids:
+            errors.append("ruleId 重复：{0}".format(rule_id))
+        else:
+            seen_rule_ids.add(rule_id)
+            where = "{0}({1})".format(where, rule_id)
+        authority = rule.get("authorityClass")
+        if authority not in AUTHORITY_LABEL:
+            errors.append("{0}.authorityClass 取值非法：{1}".format(where, authority))
+        if rule.get("sourceType") not in SOURCE_TYPE_LABEL:
+            errors.append("{0}.sourceType 取值非法：{1}".format(where, rule.get("sourceType")))
+        if authority == "external_formal":
+            for field in ("title", "version", "clause", "quote"):
+                if not _is_nonempty_str(rule.get(field)):
+                    errors.append("{0} 外部正式依据必须给出 {1}".format(where, field))
+            if str(rule.get("version")).strip() in {"现行", "现行有效", "有效"}:
+                errors.append("{0}.version 不得宣称“现行”（须写本次实际读取版本）".format(where))
+        if not _check_relative_path(str(rule.get("kbRelativePath"))):
+            errors.append("{0}.kbRelativePath 必须是知识库相对路径".format(where))
+        if not _is_nonempty_str(rule.get("exportedAt")):
+            errors.append("{0}.exportedAt 不得为空".format(where))
+        if not isinstance(rule.get("purposes"), list) or not rule.get("purposes"):
+            errors.append("{0}.purposes 至少一项".format(where))
+        expected_users = rules_used_by_issues.get(str(rule_id), set())
+        declared_users = set(map(str, rule.get("usedByIssueIds") or []))
+        if declared_users != expected_users:
+            errors.append(
+                "{0}.usedByIssueIds 与明细不一致（应为 {1}）".format(where, sorted(expected_users) or "空")
+            )
+        expected_usage = len(expected_users)
+        if rule.get("usageCount") != expected_usage:
+            errors.append(
+                "{0}.usageCount 必须可由明细重算（应为 {1}）".format(where, expected_usage)
+            )
+
+    # knowledgeBaseFiles（§5.3 相对路径；渲染器按 path 字段显示文件名）
+    kb_files = audit_basis.get("knowledgeBaseFiles")
+    if not isinstance(kb_files, list):
+        errors.append("auditBasis.knowledgeBaseFiles 必须是数组")
+    else:
+        for index, item in enumerate(kb_files):
+            where = "auditBasis.knowledgeBaseFiles[{0}]".format(index)
+            if not isinstance(item, dict):
+                errors.append("{0} 必须是对象".format(where))
+                continue
+            if not _is_nonempty_str(item.get("path")):
+                errors.append(
+                    "{0}.path 不得为空（渲染器按 path 显示知识库文件路径；形如 kbRelativePath 的别名会导致只显示时间）".format(where)
+                )
+            elif not _check_relative_path(str(item.get("path"))):
+                errors.append("{0}.path 必须是知识库相对路径".format(where))
+            if not _is_nonempty_str(item.get("exportedAt")):
+                errors.append("{0}.exportedAt 不得为空".format(where))
+
+    # reviewComparison（§6）
+    comparison = result.get("reviewComparison") or {}
+    status = comparison.get("status")
+    if status not in REVIEW_STATUS_LABEL:
+        errors.append("reviewComparison.status 取值非法：{0}".format(status))
+    reviewer_only = comparison.get("reviewerOnlyItems")
+    if not isinstance(reviewer_only, list):
+        errors.append("reviewComparison.reviewerOnlyItems 必须是数组")
+        reviewer_only = []
+    reviewer_ids = set()
+    for index, item in enumerate(reviewer_only):
+        where = "reviewComparison.reviewerOnlyItems[{0}]".format(index)
+        if not isinstance(item, dict):
+            errors.append("{0} 必须是对象".format(where))
+            continue
+        for field in REVIEWER_ONLY_REQUIRED:
+            if field not in item:
+                errors.append("{0} 缺少字段 {1}".format(where, field))
+        item_id = item.get("itemId")
+        if not _is_nonempty_str(item_id):
+            errors.append("{0}.itemId 不得为空".format(where))
+        elif item_id in reviewer_ids:
+            errors.append("reviewerOnlyItems.itemId 重复：{0}".format(item_id))
+        else:
+            reviewer_ids.add(item_id)
+        evidence = item.get("reviewerEvidence") or {}
+        if not isinstance(evidence, dict):
+            errors.append("{0}.reviewerEvidence 必须是对象".format(where))
+        else:
+            for field in ("file", "locator", "quote"):
+                if not _is_nonempty_str(evidence.get(field)):
+                    errors.append("{0}.reviewerEvidence.{1} 不得为空".format(where, field))
+        if not _is_nonempty_str(item.get("handling")):
+            errors.append("{0}.handling 不得为空".format(where))
+        resolution = item.get("inFileResolution")
+        if resolution not in IN_FILE_RESOLUTION_VALUES:
+            errors.append("{0}.inFileResolution 必须为 L-resolved/L-open/L-unclosed/L-uncheckable".format(where))
+        else:
+            if resolution in ("L-resolved", "L-open", "L-unclosed"):
+                in_file = item.get("inFileEvidence") or {}
+                for field in ("file", "locator"):
+                    if not _is_nonempty_str(in_file.get(field)):
+                        errors.append("{0}.inFileResolution={1} 必须给出 inFileEvidence.{2}（被审件在件位置）".format(where, resolution, field))
+            if resolution == "L-unclosed":
+                closure = item.get("closureEvidence") or {}
+                if not (_is_nonempty_str(closure.get("file")) and _is_nonempty_str(closure.get("locator"))):
+                    errors.append("{0}.inFileResolution=L-unclosed 必须给出 closureEvidence（答复出处）".format(where))
+
+    # 新版逐条复核事实源：文件顺序、逐条命中和指标全部可重算。
+    review_files = comparison.get("reviewFiles")
+    review_items = comparison.get("reviewItems")
+    if review_files is not None or review_items is not None:
+        if not isinstance(review_files, list) or not review_files:
+            errors.append("reviewComparison.reviewFiles 必须是非空数组（按实际复核顺序登记）")
+            review_files = []
+        if not isinstance(review_items, list):
+            errors.append("reviewComparison.reviewItems 必须是数组")
+            review_items = []
+
+        file_orders = set()
+        file_names = set()
+        levels = set()
+        for index, entry in enumerate(review_files):
+            where = "reviewComparison.reviewFiles[{0}]".format(index)
+            if not isinstance(entry, dict):
+                errors.append("{0} 必须是对象".format(where))
+                continue
+            for field in ("order", "level", "displayName", "version"):
+                if field == "order":
+                    if not isinstance(entry.get(field), int) or entry.get(field) < 1:
+                        errors.append("{0}.order 必须是从 1 开始的整数".format(where))
+                elif not _is_nonempty_str(entry.get(field)):
+                    errors.append("{0}.{1} 不得为空".format(where, field))
+            if entry.get("order") in file_orders:
+                errors.append("reviewComparison.reviewFiles.order 重复：{0}".format(entry.get("order")))
+            file_orders.add(entry.get("order"))
+            file_names.add(str(entry.get("displayName")))
+            levels.add(str(entry.get("level")))
+        if review_files and sorted(file_orders) != list(range(1, len(review_files) + 1)):
+            errors.append("reviewComparison.reviewFiles.order 必须连续且可排序")
+
+        item_ids = set()
+        for index, item in enumerate(review_items):
+            where = "reviewComparison.reviewItems[{0}]".format(index)
+            if not isinstance(item, dict):
+                errors.append("{0} 必须是对象".format(where))
+                continue
+            for field in ("itemId", "title", "module", "reviewLevel", "matchStatus", "reviewerEvidence", "linkedIssueIds", "inFileResolution", "handling"):
+                if field not in item:
+                    errors.append("{0} 缺少字段 {1}".format(where, field))
+            item_id = item.get("itemId")
+            if not _is_nonempty_str(item_id):
+                errors.append("{0}.itemId 不得为空".format(where))
+            elif item_id in item_ids:
+                errors.append("reviewComparison.reviewItems.itemId 重复：{0}".format(item_id))
+            item_ids.add(item_id)
+            if item.get("matchStatus") not in REVIEW_MATCH_VALUES:
+                errors.append("{0}.matchStatus 必须为 exact/partial/miss".format(where))
+            if item.get("reviewLevel") not in levels:
+                errors.append("{0}.reviewLevel 未在 reviewFiles 中登记".format(where))
+            evidence = item.get("reviewerEvidence") or {}
+            for field in ("file", "locator", "quote"):
+                if not _is_nonempty_str(evidence.get(field)):
+                    errors.append("{0}.reviewerEvidence.{1} 不得为空".format(where, field))
+            if _is_nonempty_str(evidence.get("file")) and str(evidence.get("file")) not in file_names:
+                errors.append("{0}.reviewerEvidence.file 未在 reviewFiles 中登记".format(where))
+            explanation = item.get("hitExplanation")
+            if not isinstance(explanation, dict):
+                errors.append("{0}.hitExplanation 必须是对象（AI 须逐条说明命中了哪些、未命中哪些、判定理由）".format(where))
+            else:
+                scope = explanation.get("reviewerScope")
+                if scope not in ("general", "specific"):
+                    errors.append("{0}.hitExplanation.reviewerScope 必须为 general（复核条目笼统）/ specific（具体）".format(where))
+                matched = explanation.get("matchedAspects")
+                unmatched = explanation.get("unmatchedAspects")
+                for field, value in (("matchedAspects", matched), ("unmatchedAspects", unmatched)):
+                    if not isinstance(value, list) or any(not _is_nonempty_str(x) for x in value):
+                        errors.append("{0}.hitExplanation.{1} 必须是非空字符串数组（可为空数组）".format(where, field))
+                if not _is_nonempty_str(explanation.get("rationale")):
+                    errors.append("{0}.hitExplanation.rationale 不得为空（禁止无理由给判定）".format(where))
+                if isinstance(matched, list) and isinstance(unmatched, list):
+                    match_status = item.get("matchStatus")
+                    if match_status == "exact" and unmatched:
+                        errors.append("{0} matchStatus=exact 时 hitExplanation.unmatchedAspects 必须为空".format(where))
+                    if match_status == "partial" and not (matched and unmatched):
+                        errors.append("{0} matchStatus=partial 时 hitExplanation 必须同时给出 matchedAspects 与 unmatchedAspects".format(where))
+                    if match_status == "miss" and (matched or not unmatched):
+                        errors.append("{0} matchStatus=miss 时 hitExplanation 必须无 matchedAspects 且有 unmatchedAspects".format(where))
+            linked = item.get("linkedIssueIds")
+            if not isinstance(linked, list):
+                errors.append("{0}.linkedIssueIds 必须是数组".format(where))
+            elif item.get("matchStatus") in ("exact", "partial") and not linked:
+                errors.append("{0} AI 命中项必须关联至少一个 issueId".format(where))
+            elif any(issue_id not in seen_issue_ids for issue_id in linked):
+                errors.append("{0}.linkedIssueIds 含不存在的 issueId".format(where))
+            resolution = item.get("inFileResolution")
+            if resolution not in IN_FILE_RESOLUTION_VALUES:
+                errors.append("{0}.inFileResolution 取值非法".format(where))
+            elif resolution in ("L-resolved", "L-open", "L-unclosed"):
+                in_file = item.get("inFileEvidence") or {}
+                for field in ("file", "locator"):
+                    if not _is_nonempty_str(in_file.get(field)):
+                        errors.append("{0}.{1} 必须给出在件核验证据".format(where, field))
+                # AI 未命中而按「已落实」剔除分母时，必须给出在件原文证明该事项确已修改/不存在
+                if resolution == "L-resolved" and item.get("matchStatus") == "miss":
+                    if not _is_nonempty_str(in_file.get("quote")):
+                        errors.append(
+                            "{0}.inFileEvidence.quote 不得为空：AI 未命中且按 L-resolved 剔除分母时，"
+                            "必须给出在件原文，证明该意见确已修改/已不存在（无法证明的应按 L-open 计入漏检）".format(where))
+            if resolution == "L-unclosed":
+                closure = item.get("closureEvidence") or {}
+                for field in ("file", "locator"):
+                    if not _is_nonempty_str(closure.get(field)):
+                        errors.append("{0}.closureEvidence.{1} 不得为空".format(where, field))
+
+        expected_metrics = _review_metrics(review_items)
+        metrics = comparison.get("metrics")
+        if not isinstance(metrics, dict):
+            errors.append("reviewComparison.metrics 必须是对象且可由 reviewItems 重算")
+        else:
+            for key, expected in expected_metrics.items():
+                if metrics.get(key) != expected:
+                    errors.append(
+                        "reviewComparison.metrics.{0} 必须可由 reviewItems 重算（应为 {1}）".format(key, expected)
+                    )
+    out_of_scope = comparison.get("outOfScopeItems")
+    if out_of_scope is not None:
+        if not isinstance(out_of_scope, list):
+            errors.append("reviewComparison.outOfScopeItems 必须是数组（无则省略或空数组）")
+        else:
+            scope_ids = set()
+            for index, item in enumerate(out_of_scope):
+                where = "reviewComparison.outOfScopeItems[{0}]".format(index)
+                if not isinstance(item, dict):
+                    errors.append("{0} 必须是对象".format(where))
+                    continue
+                for field in OUT_OF_SCOPE_REQUIRED:
+                    if field not in item:
+                        errors.append("{0} 缺少字段 {1}".format(where, field))
+                item_id = item.get("itemId")
+                if not _is_nonempty_str(item_id):
+                    errors.append("{0}.itemId 不得为空".format(where))
+                elif item_id in item_ids:
+                    errors.append("{0}.itemId 与 reviewItems 重复：{1}（能力边界条目不得混入命中率明细）".format(where, item_id))
+                elif item_id in scope_ids:
+                    errors.append("outOfScopeItems.itemId 重复：{0}".format(item_id))
+                else:
+                    scope_ids.add(item_id)
+                evidence = item.get("reviewerEvidence") or {}
+                for field in ("file", "locator", "quote"):
+                    if not _is_nonempty_str(evidence.get(field)):
+                        errors.append("{0}.reviewerEvidence.{1} 不得为空".format(where, field))
+                for field in ("title", "handling", "exclusionReason"):
+                    if not _is_nonempty_str(item.get(field)):
+                        errors.append("{0}.{1} 不得为空".format(where, field))
+
+    hidden_access = comparison.get("hiddenRegionAccess")
+    if hidden_access is not None:
+        if not isinstance(hidden_access, list):
+            errors.append("reviewComparison.hiddenRegionAccess 必须是数组")
+        else:
+            for idx, entry in enumerate(hidden_access):
+                where = "reviewComparison.hiddenRegionAccess[{0}]".format(idx)
+                if not isinstance(entry, dict):
+                    errors.append("{0} 必须是对象".format(where))
+                    continue
+                for field in ("authorizedBy", "authorizedAt", "authorization", "scope"):
+                    if not _is_nonempty_str(entry.get(field)):
+                        errors.append("{0}.{1} 不得为空".format(where, field))
+
+    if status == "performed":
+        expected_bands = {
+            "overlap": review_categories["A"],
+            "aiOnly": review_categories["B"],
+            "divergent": review_categories["C"],
+            "reviewerOnly": len(reviewer_only),
+        }
+        bands = comparison.get("bands")
+        if not isinstance(bands, dict):
+            errors.append("reviewComparison.bands 必须是对象（阶段二已完成）")
+        else:
+            for band, expected in expected_bands.items():
+                if bands.get(band) != expected:
+                    errors.append(
+                        "reviewComparison.bands.{0} 必须可由明细重算（应为 {1}）".format(band, expected)
+                    )
+        metrics = comparison.get("metrics") or {}
+        if review_items is None and (not isinstance(metrics, dict) or not _is_nonempty_str(metrics.get("denominator"))):
+            errors.append("reviewComparison.metrics.denominator 不得为空（命中率必须给出分母口径）")
+        for index, issue in enumerate(issues):
+            if isinstance(issue, dict):
+                item = issue.get("reviewComparison") or {}
+                if item.get("status") != "performed":
+                    errors.append(
+                        "阶段二已完成，issues[{0}] 必须具有 reviewComparison（不得标未执行）".format(index)
+                    )
+    elif status == "not_performed":
+        if reviewer_only:
+            errors.append("reviewComparison.status=not_performed 时不得填写复核独有项")
+        for index, issue in enumerate(issues):
+            if isinstance(issue, dict):
+                item = issue.get("reviewComparison") or {}
+                if item.get("status") == "performed":
+                    errors.append(
+                        "reviewComparison.status=not_performed 时 issues[{0}] 不得标为已执行".format(index)
+                    )
+
+    # scope（§7）
+    scope = result.get("scope") or {}
+    if not isinstance(scope.get("inputs"), list) or not scope.get("inputs"):
+        errors.append("scope.inputs 至少一项")
+    if not isinstance(scope.get("checkDomains"), list) or not scope.get("checkDomains"):
+        errors.append("scope.checkDomains 至少一项")
+    not_checked = scope.get("notCheckedItems")
+    if not isinstance(not_checked, list):
+        errors.append("scope.notCheckedItems 必须是数组（无则空数组）")
+        not_checked = []
+    not_checked_ids = set()
+    for index, item in enumerate(not_checked):
+        where = "scope.notCheckedItems[{0}]".format(index)
+        if not isinstance(item, dict):
+            errors.append("{0} 必须是对象".format(where))
+            continue
+        for field in NOT_CHECKED_REQUIRED:
+            if field not in item:
+                errors.append("{0} 缺少字段 {1}".format(where, field))
+        item_id = item.get("itemId")
+        if not _is_nonempty_str(item_id):
+            errors.append("{0}.itemId 不得为空".format(where))
+        elif item_id in not_checked_ids:
+            errors.append("notCheckedItems.itemId 重复：{0}".format(item_id))
+        else:
+            not_checked_ids.add(item_id)
+        if item.get("reasonCode") not in REASON_LABEL:
+            errors.append("{0}.reasonCode 取值非法：{1}".format(where, item.get("reasonCode")))
+        for field in ("item", "reason", "impact", "requiredAction"):
+            if not _is_nonempty_str(item.get(field)):
+                errors.append("{0}.{1} 不得为空".format(where, field))
+        if not isinstance(item.get("relatedFiles"), list):
+            errors.append("{0}.relatedFiles 必须是数组".format(where))
+
+    # professionalTrail（§8）
+    trail = result.get("professionalTrail") or {}
+    if not isinstance(trail.get("applicableRuleSnapshot"), dict):
+        errors.append("professionalTrail.applicableRuleSnapshot 必须是对象")
+    for field in ("adjudications", "checkRecords"):
+        if not isinstance(trail.get(field), list):
+            errors.append("professionalTrail.{0} 必须是数组".format(field))
+    if not isinstance(trail.get("comprehensiveComparison"), dict):
+        errors.append("professionalTrail.comprehensiveComparison 必须是对象")
+    for index, record in enumerate(trail.get("adjudications") or []):
+        where = "professionalTrail.adjudications[{0}]".format(index)
+        if not isinstance(record, dict):
+            errors.append("{0} 必须是对象".format(where))
+            continue
+        if not (_is_nonempty_str(record.get("recordId")) or _is_nonempty_str(record.get("chkId"))):
+            errors.append("{0}.recordId 不得为空（渲染器按 recordId 显示编号，缺失将导致裁定表编号列空白）".format(where))
+        if not (_is_nonempty_str(record.get("itemRef")) or _is_nonempty_str(record.get("item"))
+                or _is_nonempty_str(record.get("checkItem"))):
+            errors.append("{0}.itemRef 不得为空（渲染器按 itemRef 显示条目，缺失将导致裁定表条目列空白）".format(where))
+        if not (_is_nonempty_str(record.get("ruling")) or _is_nonempty_str(record.get("result"))):
+            errors.append("{0} 必须给出 ruling 或 result（缺失将导致裁定列空白）".format(where))
+    check_record_ids = set()
+    for index, record in enumerate(trail.get("checkRecords") or []):
+        where = "professionalTrail.checkRecords[{0}]".format(index)
+        if not isinstance(record, dict):
+            errors.append("{0} 必须是对象".format(where))
+            continue
+        for field in CHECK_RECORD_REQUIRED:
+            if field not in record:
+                errors.append("{0} 缺少字段 {1}".format(where, field))
+        record_id = record.get("recordId")
+        if not _is_nonempty_str(record_id):
+            errors.append("{0}.recordId 不得为空".format(where))
+        elif record_id in check_record_ids:
+            errors.append("checkRecords.recordId 重复：{0}".format(record_id))
+        else:
+            check_record_ids.add(record_id)
+        if record.get("result") not in RESULT_LABEL:
+            errors.append("{0}.result 取值非法：{1}".format(where, record.get("result")))
+        for field in ("checkItem", "performedAt", "executor"):
+            if not _is_nonempty_str(record.get(field)):
+                errors.append("{0}.{1} 不得为空".format(where, field))
+        if not isinstance(record.get("evidence"), list) or not record.get("evidence"):
+            errors.append("{0}.evidence 至少一条（每条“检查过”必须有真实文件证据）".format(where))
+        for field in ("targets", "linkedIssueIds"):
+            if not isinstance(record.get(field), list):
+                errors.append("{0}.{1} 必须是数组".format(where, field))
+
+    # summary（§9.4 可重算）
+    summary = result.get("summary") or {}
+    if summary.get("overallDecision") not in OVERALL_LABEL:
+        errors.append("summary.overallDecision 取值非法：{0}".format(summary.get("overallDecision")))
+    expected_counts = {
+        "issuesTotal": len(issues),
+        "fail": fail_count,
+        "high": severity_counts["high"],
+        "medium": severity_counts["medium"],
+        "low": severity_counts["low"],
+        "pendingConfirmation": len(manual_items),
+        "notChecked": len(not_checked),
+    }
+    counts = summary.get("counts")
+    if not isinstance(counts, dict):
+        errors.append("summary.counts 必须是对象且可由明细重算")
+    else:
+        for key, expected in expected_counts.items():
+            if counts.get(key) != expected:
+                errors.append("summary.counts.{0} 必须可由明细重算（应为 {1}）".format(key, expected))
+    if fail_count and summary.get("overallDecision") == "pass":
+        errors.append("存在不通过问题，summary.overallDecision 不得为 pass")
+    if not fail_count and summary.get("overallDecision") == "fail":
+        errors.append("不存在不通过问题，summary.overallDecision 不得为 fail")
+    if not _is_nonempty_str(summary.get("narrative")):
+        errors.append("summary.narrative 不得为空")
+
+    # externalDataVerification（外部数据核验：基准日锚定 + 源可用性声明 + 逐项核验）
+    if result.get("externalDataVerification") is not None:
+        _validate_external_data(result.get("externalDataVerification"), errors)
+
+    # fileTrace（§10 / §12）
+    file_trace = result.get("fileTrace") or {}
+    if not _is_nonempty_str(file_trace.get("generatedAt")):
+        errors.append("fileTrace.generatedAt 不得为空")
+    renderer_version = file_trace.get("rendererVersion")
+    if not _is_nonempty_str(renderer_version):
+        errors.append("fileTrace.rendererVersion 不得为空")
+    for field in ("sourceDigest", "embeddedJsonDigest"):
+        value = file_trace.get(field)
+        if rendered:
+            if not _is_nonempty_str(value) or not HEX64.match(str(value)):
+                errors.append("fileTrace.{0} 必须是渲染后的 sha256 摘要".format(field))
+        elif _is_nonempty_str(value) and not HEX64.match(str(value)):
+            errors.append("fileTrace.{0} 如果不是空值必须是 sha256 摘要".format(field))
+    if expect_renderer and renderer_version != RENDERER_VERSION:
+        errors.append("fileTrace.rendererVersion 与当前 renderer 不一致：{0}".format(renderer_version))
+
+    # renderPolicy
+    policy = result.get("renderPolicy") or {}
+    if not isinstance(policy, dict):
+        errors.append("renderPolicy 必须是对象")
+    elif not isinstance(policy.get("printTrail"), bool):
+        errors.append("renderPolicy.printTrail 必须是布尔值")
+
+    # 敏感信息（§10.1 / §12.2）
+    errors.extend(scan_sensitive(result))
+
+    # ---- AI 审核评分卡（自评）+ 审核错误项 ----
+    scorecard = result.get("aiScorecard")
+    if not isinstance(scorecard, dict):
+        errors.append("aiScorecard 必须是对象")
+        scorecard = {}
+    level = scorecard.get("level")
+    if level not in SCORECARD_LEVELS:
+        errors.append("aiScorecard.level 必须为 初审/复审/终审（与台账 review_level 一致）")
+    dimensions = scorecard.get("dimensions")
+    if not isinstance(dimensions, list):
+        errors.append("aiScorecard.dimensions 必须是数组")
+        dimensions = []
+    seen_keys = []
+    for idx, dim in enumerate(dimensions):
+        where = "aiScorecard.dimensions[{0}]".format(idx)
+        if not isinstance(dim, dict):
+            errors.append("{0} 必须是对象".format(where))
+            continue
+        key = dim.get("key")
+        if key not in SCORECARD_DIMENSION_KEYS:
+            errors.append("{0}.key 取值非法：{1}".format(where, key))
+        else:
+            seen_keys.append(key)
+        score = dim.get("score")
+        if not isinstance(score, (int, float)) or isinstance(score, bool):
+            errors.append("{0}.score 必须是数值".format(where))
+        elif not (0 <= float(score) <= 10) or abs(float(score) * 2 - round(float(score) * 2)) > 1e-9:
+            errors.append("{0}.score 必须为 0–10 且 0.5 的整数倍".format(where))
+        if dim.get("max") != 10:
+            errors.append("{0}.max 必须为 10".format(where))
+        if not _is_nonempty_str(dim.get("basis")):
+            errors.append("{0}.basis 不得为空（禁止无依据给分）".format(where))
+    if sorted(seen_keys) != sorted(SCORECARD_DIMENSION_KEYS):
+        errors.append("aiScorecard.dimensions 必须恰好覆盖六维：{0}".format(SCORECARD_DIMENSION_KEYS))
+
+    composites = scorecard.get("composites")
+    if not isinstance(composites, dict):
+        errors.append("aiScorecard.composites 必须是对象")
+        composites = {}
+    corrections = scorecard.get("corrections") or []
+    if not isinstance(corrections, list):
+        errors.append("aiScorecard.corrections 必须是数组")
+        corrections = []
+    by_key = {d.get("key"): d.get("score") for d in dimensions if isinstance(d, dict)}
+
+    if dimensions:
+        expected_ai_only = _mean_score(dimensions)
+        if composites.get("aiOnly") != expected_ai_only:
+            errors.append("aiScorecard.composites.aiOnly 必须可由六维均值按 0.5 取整复算（应为 {0}）".format(expected_ai_only))
+
+    def _final_score(key):
+        score = by_key.get(key)
+        for cor in corrections:
+            if isinstance(cor, dict) and cor.get("key") == key:
+                score = cor.get("to")
+        return score
+
+    for idx, cor in enumerate(corrections):
+        where = "aiScorecard.corrections[{0}]".format(idx)
+        if not isinstance(cor, dict):
+            errors.append("{0} 必须是对象".format(where))
+            continue
+        key = cor.get("key")
+        if key not in SCORECARD_DIMENSION_KEYS:
+            errors.append("{0}.key 取值非法：{1}".format(where, key))
+            continue
+        if cor.get("from") != by_key.get(key):
+            errors.append("{0}.from 必须等于初审该维分数（只增不覆盖：不得改写初审分）".format(where))
+        if not _is_nonempty_str(cor.get("reason")):
+            errors.append("{0}.reason 不得为空（校正必须给理由）".format(where))
+
+    expected_loop = _round_half_up(
+        sum(float(_final_score(k)) for k in SCORECARD_DIMENSION_KEYS) / len(SCORECARD_DIMENSION_KEYS)
+    ) if dimensions else None
+    if level == "初审":
+        if corrections:
+            errors.append("aiScorecard.corrections 仅在复审/终审填写（初审不得事后校正）")
+        if composites.get("withHumanLoop") is not None:
+            errors.append("aiScorecard.composites.withHumanLoop 仅在复审/终审填写")
+    elif level in ("复审", "终审"):
+        if composites.get("withHumanLoop") != expected_loop:
+            errors.append("aiScorecard.composites.withHumanLoop 必须可由复审校正后六维均值按 0.5 取整复算（应为 {0}）".format(expected_loop))
+
+    self_errors = result.get("selfAuditErrors")
+    if not isinstance(self_errors, list):
+        errors.append("selfAuditErrors 必须是数组")
+        self_errors = []
+    error_ids = set()
+    for idx, item in enumerate(self_errors):
+        where = "selfAuditErrors[{0}]".format(idx)
+        if not isinstance(item, dict):
+            errors.append("{0} 必须是对象".format(where))
+            continue
+        for field in ("errorId", "kind", "discoveredAt", "description"):
+            if field not in item:
+                errors.append("{0} 缺少字段 {1}".format(where, field))
+        error_id = item.get("errorId")
+        if _is_nonempty_str(error_id):
+            if error_id in error_ids:
+                errors.append("selfAuditErrors.errorId 重复：{0}".format(error_id))
+            error_ids.add(error_id)
+        if item.get("kind") not in SCORECARD_ERROR_KINDS:
+            errors.append("{0}.kind 取值非法：{1}".format(where, item.get("kind")))
+        if item.get("discoveredAt") not in SCORECARD_LEVELS:
+            errors.append("{0}.discoveredAt 必须为 初审/复审/终审".format(where))
+        if not _is_nonempty_str(item.get("description")):
+            errors.append("{0}.description 不得为空".format(where))
+        if item.get("status") is not None and item.get("status") not in ("open", "closed"):
+            errors.append("{0}.status 取值非法：{1}".format(where, item.get("status")))
+        if (
+            item.get("kind") == "false_positive"
+            and item.get("status") == "closed"
+            and item.get("issueId") in seen_issue_ids
+        ):
+            errors.append(
+                "{0} 已关闭假阳性不得仍保留在 issues；请撤回对应问题项或改正错误记录".format(where)
+            )
+
+    return errors
+
+
+# --------------------------------------------------------------------------- #
+# 渲染（§10）
+# --------------------------------------------------------------------------- #
+def _text(value) -> str:
+    if isinstance(value, (dict, list)):
+        value = canonical_json(value)
+    return html.escape("" if value is None else str(value), quote=True)
+
+
+def _dt(value: str) -> str:
+    parsed = _parse_time(str(value))
+    return parsed.isoformat() if parsed else str(value)
+
+
+def _readable_status(value) -> str:
+    if value is True:
+        return '<span class="readable-status is-readable" title="可读" aria-label="可读">✅</span>'
+    return '<span class="readable-status is-unreadable" title="不可读" aria-label="不可读">❌</span>'
+
+
+def _span(cls: str, value) -> str:
+    return '<span class="{0}">{1}</span>'.format(cls, _text(value))
+
+
+def _item_index(label: str, index: int, total: int) -> str:
+    """生成分区内稳定序号；至少补齐两位，便于长列表扫描。"""
+    width = max(2, len(str(total)))
+    return _span(
+        "item-index",
+        "{0} {1}/{2}".format(label, str(index).zfill(width), str(total).zfill(width)),
+    )
+
+
+def _rows(pairs) -> str:
+    return "".join(
+        "<tr><th scope=\"row\">{0}</th><td>{1}</td></tr>".format(_text(label), _text(value))
+        for label, value in pairs
+    )
+
+
+def _list_block(items, formatter, empty_text=EMPTY_TEXT) -> str:
+    if not items:
+        return '<p class="empty">{0}</p>'.format(_text(empty_text))
+    return "<ul>" + "".join("<li>{0}</li>".format(formatter(item)) for item in items) + "</ul>"
+
+
+def _rule_map(rules) -> str:
+    grouped = {}
+    for rule in rules:
+        authority = rule.get("authorityClass")
+        source = rule.get("sourceType")
+        grouped.setdefault(authority, {}).setdefault(source, []).append(rule)
+    parts = ['<nav aria-label="审核规则地图" class="rule-map">']
+    for authority in sorted(grouped):
+        parts.append("<section><h4>{0}</h4>".format(_text(AUTHORITY_LABEL.get(authority, authority))))
+        for source in sorted(grouped[authority]):
+            parts.append("<p class=\"source\">{0}</p>".format(_text(SOURCE_TYPE_LABEL.get(source, source))))
+            parts.append("<ul>")
+            for rule in sorted(grouped[authority][source], key=lambda item: str(item.get("ruleId"))):
+                parts.append(
+                    "<li>{0}{1}</li>".format(
+                        _span("rule-id", rule.get("ruleId")),
+                        _span("rule-title", rule.get("title")),
+                    )
+                )
+            parts.append("</ul>")
+        parts.append("</section>")
+    parts.append("</nav>")
+    return "".join(parts)
+
+
+def _is_ai_only_issue(issue) -> bool:
+    comparison = issue.get("reviewComparison") or {}
+    return comparison.get("status") == "performed" and comparison.get("category") == "B"
+
+
+def _ai_only_summary(issues, comparison) -> str:
+    if comparison.get("status") != "performed":
+        return ""
+    ai_only = [issue for issue in issues if _is_ai_only_issue(issue)]
+    severity_counts = {"high": 0, "medium": 0, "low": 0}
+    for issue in ai_only:
+        severity = issue.get("severity")
+        if severity in severity_counts:
+            severity_counts[severity] += 1
+    parts = ['<aside class="ai-only-summary" aria-label="AI 独立检出统计">']
+    parts.append('<div class="ai-only-summary-head"><span>{0}</span>'.format(_text("AI 独立检出")))
+    parts.append('<span class="ai-only-total"><strong>{0}</strong><span>{1}</span></span></div>'.format(
+        _text(len(ai_only)), _text("项")))
+    parts.append('<div class="ai-only-severity-list">')
+    for severity in ("high", "medium", "low"):
+        parts.append('<span class="ai-only-severity {0}"><span>{1}</span><strong>{2}</strong></span>'.format(
+            SEVERITY_CLASS[severity], _text(SEVERITY_LABEL[severity]), _text(severity_counts[severity])))
+    parts.append("</div></aside>")
+    return "".join(parts)
+
+
+def _problem_block(value) -> str:
+    """§4.6 问题描述按两段式分行呈现：首句单行突出 + 明细逐行，不拼接、不改写。"""
+    headline, details = split_problem_description(value)
+    if not headline and not details:
+        return '<p class="problem"><span class="problem-label">问题描述</span>{0}</p>'.format(_text(EMPTY_TEXT))
+    parts = ['<div class="problem"><span class="problem-label">问题描述</span>']
+    if headline:
+        parts.append('<p class="problem-headline">{0}</p>'.format(_span("problem-description", headline)))
+    if details:
+        parts.append('<ul class="problem-details">')
+        for detail in details:
+            parts.append("<li>{0}</li>".format(_text(detail)))
+        parts.append("</ul>")
+    parts.append("</div>")
+    return "".join(parts)
+
+
+def _issue_location_block(issue: dict) -> str:
+    """把 JSON 中的定位摘要与材料证据落点组合成可扫描面板。"""
+    seen = set()
+    locations = []
+    for evidence in issue.get("materialEvidence") or []:
+        file_name = str(evidence.get("displayName") or "").strip()
+        locator = str(evidence.get("locator") or "").strip()
+        key = (file_name, locator)
+        if not file_name or not locator or key in seen:
+            continue
+        seen.add(key)
+        locations.append(key)
+    parts = ['<section class="issue-location-panel" aria-label="问题位置">']
+    parts.append('<p class="issue-location-heading">{0}</p>'.format(
+        _text("问题位置 · 请到以下位置核对")))
+    parts.append('<p class="issue-location-summary">{0}</p>'.format(
+        _text(issue.get("locationSummary"))))
+    if locations:
+        parts.append('<ul class="issue-location-list">')
+        for file_name, locator in locations:
+            parts.append(
+                '<li><span class="location-file">{0}</span>'
+                '<span class="location-arrow" aria-hidden="true">→</span>'
+                '<span class="location-locator">{1}</span></li>'.format(
+                    _text(file_name), _text(locator)))
+        parts.append("</ul>")
+    parts.append("</section>")
+    return "".join(parts)
+
+
+def _issue_card(issue, index: int, total: int) -> str:
+    ai_only = _is_ai_only_issue(issue)
+    card_classes = ["issue-card", SEVERITY_CLASS.get(issue.get("severity"), "")]
+    if ai_only:
+        card_classes.append("ai-only-issue")
+    cards = ['<article class="{0}">'.format(" ".join(filter(None, card_classes)))]
+    cards.append('<header class="issue-head">')
+    cards.append('<div class="issue-title-row">{0}<h3>{1}</h3>'.format(
+        _item_index("问题", index, total), _span("issue-title", issue.get("title"))))
+    if ai_only:
+        cards.append('<span class="ai-only-badge">{0}</span>'.format(_text("AI 独立发现")))
+    cards.append("</div>")
+    if ai_only:
+        cards.append('<p class="ai-only-note">{0}</p>'.format(
+            _text("未与人工复核意见重叠，请优先核验其准确性")))
+    cards.append('<div class="issue-meta">')
+    cards.append('<span class="meta-chip issue-id">{0}</span>'.format(_text(issue.get("issueId"))))
+    cards.append('<span class="meta-chip module-label">{0}：{1}</span>'.format(
+        _text("问题方向"), _text(MODULE_LABEL.get(issue.get("module"), issue.get("module")))))
+    cards.append('<span class="meta-chip severity-label">{0}：{1}</span>'.format(
+        _text("严重程度"), _text(SEVERITY_LABEL.get(issue.get("severity"), issue.get("severity")))))
+    cards.append('<span class="meta-chip type-label">{0}：{1}</span>'.format(
+        _text("问题类型"), _text(ISSUE_TYPE_LABEL.get(issue.get("issueType"), issue.get("issueType")))))
+    cards.append('<span class="meta-chip decision-label">{0}：{1}</span>'.format(
+        _text("判定"), _text(DECISION_LABEL.get(issue.get("decision"), issue.get("decision")))))
+    cards.append('</div>')
+    cards.append("</header>")
+    cards.append(_issue_location_block(issue))
+    cards.append(_problem_block(issue.get("problemDescription")))
+
+    recommended_edits = issue.get("recommendedEdits") or []
+    cards.append('<details class="issue-edits"><summary>{0}</summary>'.format(
+        _text("展开修改意见（共 {0} 项）".format(len(recommended_edits)))))
+    cards.append('<section class="stage stage-edit action-panel"><h4>{0}</h4>'.format(_text("建议修改")))
+    cards.append(_list_block(recommended_edits, _edit_item) if recommended_edits else _list_block([], None))
+    cards.append("</section></details>")
+
+    cards.append('<details class="issue-evidence"><summary>{0}</summary>'.format(
+        _text("展开判断依据与规则（{0} 条规则，{1} 条材料）".format(
+            len(issue.get("ruleEvidence") or []), len(issue.get("materialEvidence") or [])))))
+    cards.append('<section class="stage stage-rule"><h4>{0}</h4>'.format(_text("规则依据")))
+    cards.append(_list_block(issue.get("ruleEvidence"), _rule_evidence_item) if issue.get("ruleEvidence") else _list_block([], None))
+    cards.append("</section>")
+
+    cards.append('<section class="stage stage-material"><h4>{0}</h4>'.format(_text("材料证据")))
+    cards.append(_list_block(issue.get("materialEvidence"), _material_evidence_item) if issue.get("materialEvidence") else _list_block([], None))
+    cards.append("</section>")
+
+    gap = issue.get("gapAnalysis") or {}
+    cards.append(
+        '<section class="stage stage-diff"><h4>{0}</h4><table class="kv">{1}</table></section>'.format(
+            _text("差异"),
+            _rows(
+                [
+                    ("规则要求", gap.get("ruleRequirement")),
+                    ("材料现状", gap.get("observedCondition")),
+                    ("差异", gap.get("difference")),
+                    ("判断", gap.get("finalJudgment")),
+                ]
+            ),
+        )
+    )
+
+    confidence = issue.get("confidence") or {}
+    cards.append(
+        '<section class="stage stage-conclusion"><h4>{0}</h4><table class="kv">{1}</table></section>'.format(
+            _text("结论"),
+            _rows(
+                [
+                    ("处理要求", issue.get("handlingRequirement")),
+                    ("流转状态", FLOW_LABEL.get(issue.get("flowStatus"), issue.get("flowStatus"))),
+                    ("置信度", CONFIDENCE_LABEL.get(confidence.get("level"), confidence.get("level"))),
+                    ("置信度理由", confidence.get("reason")),
+                ]
+            ),
+        )
+    )
+
+    cards.append("</details>")
+
+    comparison = issue.get("reviewComparison") or {}
+    if comparison.get("status") == "performed":
+        cards.append('<p class="issue-review-status"><strong>{0}</strong>{1}</p>'.format(
+            _text("人工复核对照："),
+            _text(REVIEW_CATEGORY_LABEL.get(comparison.get("category"), comparison.get("category")))))
+    else:
+        cards.append(
+            '<p class="compare-status">{0}{1}</p>'.format(
+                _span("compare-label", "人工复核对照"), _span("compare-value", REVIEW_STATUS_LABEL["not_performed"])
+            )
+        )
+    cards.append("</article>")
+    return "".join(cards)
+
+
+def _rule_evidence_item(evidence) -> str:
+    return (
+        '<span class="rule-id">{0}</span>'
+        '<span class="authority">{1}</span>'
+        '<span class="clause">{2}</span>'
+        '<span class="quote">{3}</span>'
+        '<span class="kb-path">{4}</span>'
+        '<span class="exported-at">{5}</span>'
+    ).format(
+        _text(evidence.get("ruleId")),
+        _text(AUTHORITY_LABEL.get(evidence.get("authorityClass"), evidence.get("authorityClass"))),
+        _text(evidence.get("clause")),
+        _text(evidence.get("quote")),
+        _text(evidence.get("kbRelativePath")),
+        _text(evidence.get("exportedAt")),
+    )
+
+
+def _material_evidence_item(evidence) -> str:
+    return (
+        '<span class="file">{0}</span>'
+        '<span class="section">{1}</span>'
+        '<span class="locator">{2}</span>'
+        '<span class="excerpt">{3}</span>'
+        '<span class="role">{4}</span>'
+    ).format(
+        _text(evidence.get("displayName")),
+        _text(evidence.get("section")),
+        _text(evidence.get("locator")),
+        _text(evidence.get("excerptOrValue")),
+        _text(evidence.get("evidenceRole")),
+    )
+
+
+def _edit_item(edit) -> str:
+    return (
+        '<span class="file">{0}</span><span class="locator">{1}</span><span class="action">{2}</span>'
+    ).format(_text(edit.get("displayName")), _text(edit.get("locator")), _text(edit.get("action")))
+
+
+def _manual_item(item, index: int, total: int) -> str:
+    return (
+        '<div class="item-heading">{0}<h4>{1}</h4></div><table class="kv">{2}</table>'
+    ).format(
+        _item_index("确认", index, total),
+        _text(item.get("title")),
+        _rows(
+            [
+                ("编号", item.get("itemId")),
+                ("位置", item.get("locationSummary")),
+                ("客观发现", item.get("observation")),
+                ("需确认问题", item.get("questionToConfirm")),
+                ("建议动作", item.get("suggestedAction")),
+            ]
+        ),
+    )
+
+
+
+def _metric_cells(metrics: dict) -> str:
+    return "".join(
+        "<td>{0}</td>".format(_text(value))
+        for value in (
+            metrics["total"], metrics["resolved"], metrics["uncheckable"], metrics["evaluable"],
+            metrics["exactHits"], metrics["partialHits"], metrics["misses"],
+            _format_rate(metrics["hitRate"]), _format_rate(metrics["exactRate"]),
+        )
+    )
+
+
+def _performance_table(items: list, group_key: str, title: str) -> str:
+    groups = {}
+    for item in items:
+        groups.setdefault(str(item.get(group_key) or "未分类"), []).append(item)
+    parts = ["<h3>{0}</h3>".format(_text(title)), '<div class="table-scroll"><table class="performance-table">']
+    parts.append("<thead><tr>" + "".join(
+        '<th scope="col">{0}</th>'.format(_text(label))
+        for label in ("维度", "意见", "已验证修改", "无法核验", "可评价", "精确命中", "部分命中", "未命中", "命中率", "精确命中率")
+    ) + "</tr></thead><tbody>")
+    for name, grouped in groups.items():
+        parts.append("<tr><th scope=\"row\">{0}</th>{1}</tr>".format(_text(name), _metric_cells(_review_metrics(grouped))))
+    parts.append("</tbody></table></div>")
+    return "".join(parts)
+
+
+def _scorecard_section(comparison, self_errors) -> str:
+    """仅以逐条复核事实计算百分比；不再把主观 0–10 自评分作为员工端评分卡。"""
+    items = comparison.get("reviewItems") or []
+    metrics = _review_metrics(items)
+    parts = ['<section id="ai-scorecard">', '<h2>{0}</h2>'.format(_text("AI 审核表现评分卡"))]
+    if not items:
+        parts.append('<p class="empty">{0}</p>'.format(_text("缺少完整逐条复核数据，无法计算客观命中率")))
+    else:
+        parts.append('<div class="score-hero"><div><span>{0}</span><strong>{1}</strong></div><div><span>{2}</span><strong>{3}</strong></div></div>'.format(
+            _text("综合命中率"), _text(_format_rate(metrics["hitRate"])),
+            _text("综合精确命中率"), _text(_format_rate(metrics["exactRate"]))))
+        parts.append('<p class="formula">{0}：({1} + {2}) ÷ {3}。{4}</p>'.format(
+            _text("命中率"), _text(metrics["exactHits"]), _text(metrics["partialHits"]),
+            _text(metrics["evaluable"]),
+            _text("部分命中计为命中、只是层次较低；已验证修改和无法核验项不进入分母；综合值按全部有效明细汇总，不取各维度百分比平均。")))
+        parts.append(_hit_level_row(metrics))
+        parts.append(_performance_table(items, "reviewLevel", "按复核级次"))
+        parts.append(_performance_table(items, "module", "按问题模块"))
+    parts.append('<details class="secondary-details"><summary>{0}</summary>'.format(
+        _text("展开 AI 自查错误记录（共 {0} 条）".format(len(self_errors or [])))))
+    if self_errors:
+        parts.append('<div class="table-scroll"><table><thead><tr>' + "".join(
+            '<th scope="col">{0}</th>'.format(_text(label))
+            for label in ("编号", "错误类型", "发现级次", "说明", "处置")
+        ) + '</tr></thead><tbody>')
+        for item in self_errors:
+            parts.append("<tr><td>{0}</td><td>{1}</td><td>{2}</td><td>{3}</td><td>{4}</td></tr>".format(
+                _text(item.get("errorId")), _text(SCORECARD_ERROR_KIND_LABEL.get(item.get("kind"), item.get("kind"))),
+                _text(item.get("discoveredAt")), _text(item.get("description")), _text(item.get("correction"))))
+        parts.append("</tbody></table></div>")
+    else:
+        parts.append('<p class="empty">{0}</p>'.format(_text(EMPTY_TEXT)))
+    parts.append("</details></section>")
+    return "".join(parts)
+
+
+def _reviewer_only_item(item) -> str:
+    evidence = item.get("reviewerEvidence") or {}
+    in_file = item.get("inFileEvidence") or {}
+    closure = item.get("closureEvidence") or {}
+    resolution = item.get("inFileResolution")
+    rows = [
+        ("编号", item.get("itemId")),
+        ("复核文件", evidence.get("file")),
+        ("定位", evidence.get("locator")),
+        ("原文摘录", evidence.get("quote")),
+        ("在件核验", IN_FILE_RESOLUTION_LABEL.get(resolution, resolution)),
+        ("被审件文件", in_file.get("file") or IN_FILE_ABSENT_LABEL),
+        ("被审件定位", in_file.get("locator") or IN_FILE_ABSENT_LABEL),
+        ("处理", item.get("handling")),
+    ]
+    if resolution == "L-unclosed":
+        rows.insert(6, ("答复文件", closure.get("file", "") or IN_FILE_ABSENT_LABEL))
+        rows.insert(7, ("答复定位", closure.get("locator", "") or IN_FILE_ABSENT_LABEL))
+    return (
+        "<h4>{0}</h4><table class=\"kv\">{1}</table>"
+    ).format(_text(item.get("title")), _rows(rows))
+
+
+def _review_item_card(item, index: int, total: int) -> str:
+    evidence = item.get("reviewerEvidence") or {}
+    in_file = item.get("inFileEvidence") or {}
+    closure = item.get("closureEvidence") or {}
+    resolution = item.get("inFileResolution")
+    explanation = item.get("hitExplanation") or {}
+    scope_label = {"general": "笼统（复核表述较宽）", "specific": "具体（复核表述限定明确）"}.get(
+        explanation.get("reviewerScope"), IN_FILE_ABSENT_LABEL)
+    rows = [
+        ("编号", item.get("itemId")),
+        ("问题方向", item.get("module")),
+        ("AI 对照", AI_COMPARISON_NOTE.get(
+            (item.get("matchStatus"), item.get("inFileResolution")),
+            REVIEW_MATCH_LABEL.get(item.get("matchStatus"), item.get("matchStatus")))),
+        ("复核条目范围", scope_label),
+        ("AI 命中内容", "；".join(explanation.get("matchedAspects") or []) or "（无）"),
+        ("AI 未命中内容", "；".join(explanation.get("unmatchedAspects") or []) or "（无）"),
+        ("命中判定理由", explanation.get("rationale") or IN_FILE_ABSENT_LABEL),
+        ("关联 AI 问题", "、".join(item.get("linkedIssueIds") or []) or "无"),
+        ("复核文件", evidence.get("file")),
+        ("复核定位", evidence.get("locator")),
+        ("复核原文", evidence.get("quote")),
+        ("在件核验", IN_FILE_RESOLUTION_LABEL.get(resolution, resolution)),
+        ("被审件文件", in_file.get("file") or IN_FILE_ABSENT_LABEL),
+        ("被审件定位", in_file.get("locator") or IN_FILE_ABSENT_LABEL),
+        ("被审件证据", in_file.get("quote") or IN_FILE_ABSENT_LABEL),
+        ("处理", item.get("handling")),
+    ]
+    if resolution == "L-unclosed":
+        rows.extend([
+            ("答复文件", closure.get("file")),
+            ("答复定位", closure.get("locator")),
+            ("答复原文", closure.get("quote")),
+        ])
+    alert_class = " review-item-unclosed" if resolution == "L-unclosed" else ""
+    tags = [_item_index("复核", index, total)]
+    if resolution == "L-unclosed":
+        tags.append('<span class="closure-tag">{0}</span>'.format(
+            _text("闭环异常｜称已修复但实际未修改")))
+    return (
+        '<article class="review-item{0}"><div class="review-item-heading">{1}<h4>{2}</h4></div>'
+        '<table class="kv">{3}</table></article>'
+    ).format(alert_class, "".join(tags), _text(item.get("title")), _rows(rows))
+
+
+def _review_comparison_section(comparison) -> str:
+    parts = ['<section id="review-comparison">', '<h2>{0}</h2>'.format(_text("人工复核对照"))]
+    if comparison.get("status") != "performed":
+        parts.append('<p class="empty">{0}</p></section>'.format(_text("本次未执行人工复核对照")))
+        return "".join(parts)
+    files = sorted(comparison.get("reviewFiles") or [], key=lambda item: item.get("order", 9999))
+    items = comparison.get("reviewItems") or []
+    if not items:
+        parts.append('<p class="legacy-note">{0}</p>'.format(_text("当前结果仅含旧版复核汇总，未提供逐条复核文件与意见清单。")))
+        reviewer_items = comparison.get("reviewerOnlyItems") or []
+        parts.append(_list_block(reviewer_items, _reviewer_only_item, empty_text=EMPTY_TEXT))
+        parts.append("</section>")
+        return "".join(parts)
+    metrics = _review_metrics(items)
+    item_positions = {id(item): index for index, item in enumerate(items, start=1)}
+    unclosed = sum(item.get("inFileResolution") == "L-unclosed" for item in items)
+    if unclosed:
+        parts.append('<p id="review-unclosed-alert" class="closure-alert">{0}</p>'.format(
+            _text("已称修复但实际未落实：{0} 条，须优先回客户。".format(unclosed))))
+    parts.append('<p class="formula capability-notice">{0}</p>'.format(_text(CAPABILITY_WORKPAPER_NOTICE)))
+    parts.append('<p class="formula">{0}</p>'.format(
+        _text("分母判定：AI 未命中的复核意见，须先核验该事项是否已被修改——" 
+              "确已修改的（复核件标注已修改且在件核验通过）不计入命中率分母；并未修改的计入分母并计为漏检。" 
+              "材料缺失或不可读、超出 AI 能力层的条目不进入分母。逐条结论见下表「AI 对照」。")))
+    parts.append('<div class="review-kpis">')
+    for label, value, cls in (
+        ("复核意见", metrics["total"], ""), ("已验证修改", metrics["resolved"], "good"),
+        ("AI 精确命中", metrics["exactHits"], "good"), ("AI 部分命中", metrics["partialHits"], "good"),
+        ("AI 未命中", metrics["misses"], "warning"),
+        ("命中率", _format_rate(metrics["hitRate"]), "primary"),
+        ("精确命中率", _format_rate(metrics["exactRate"]), ""),
+    ):
+        parts.append('<div class="metric-card {0}"><span>{1}</span><strong>{2}</strong></div>'.format(
+            cls, _text(label), _text(value)))
+    parts.append("</div>")
+    parts.append('<p class="formula">{0}：({1} + {2}) ÷ {3} = {4}；{5}：{6}。{7}</p>'.format(
+        _text("命中率"), _text(metrics["exactHits"]), _text(metrics["partialHits"]),
+        _text(metrics["evaluable"]), _text(_format_rate(metrics["hitRate"])),
+        _text("精确命中率"), _text(_format_rate(metrics["exactRate"])),
+        _text("部分命中计为命中、只是层次较低；已验证修改和无法核验项不进入分母。")))
+    parts.append(_hit_level_row(metrics))
+    parts.append(_excluded_from_denominator_block(comparison))
+    parts.append('<h3>{0}</h3><ol class="review-file-list">'.format(_text("本次复核文件（按顺序）")))
+    for entry in files:
+        parts.append('<li><span class="order">{0}</span><strong>{1}</strong><span>{2}</span><span>{3}</span></li>'.format(
+            _text(entry.get("order")), _text(entry.get("displayName")), _text(entry.get("level")), _text(entry.get("version"))))
+    parts.append("</ol>")
+    seen_levels = []
+    for entry in files:
+        if entry.get("level") not in seen_levels:
+            seen_levels.append(entry.get("level"))
+    for level in seen_levels:
+        level_items = [item for item in items if item.get("reviewLevel") == level]
+        level_metrics = _review_metrics(level_items)
+        level_unclosed = sum(item.get("inFileResolution") == "L-unclosed" for item in level_items)
+        parts.append('<section class="review-level"><h3>{0}</h3>'.format(
+            _text("{0}：{1} 条意见".format(level, len(level_items)))))
+        level_summary = "".join(
+            '<span><strong>{0}</strong>{1}</span>'.format(_text(label), _text(value))
+            for label, value in (
+                ("已验证修改 ", level_metrics["resolved"]), ("AI 精确命中 ", level_metrics["exactHits"]),
+                ("AI 部分命中 ", level_metrics["partialHits"]), ("AI 未命中 ", level_metrics["misses"]),
+                ("命中率 ", _format_rate(level_metrics["hitRate"])),
+                ("精确命中率 ", _format_rate(level_metrics["exactRate"])),
+            )
+        )
+        if level_unclosed:
+            level_summary += '<span class="level-alert-tag">{0}</span>'.format(
+                _text("实际未落实 {0}".format(level_unclosed)))
+        parts.append('<div class="level-summary">{0}</div>'.format(level_summary))
+        parts.append('<details class="review-details"><summary>{0}</summary>'.format(
+            _text("展开{0}意见（共 {1} 条）".format(level, len(level_items)))))
+        for item in level_items:
+            parts.append(_review_item_card(item, item_positions[id(item)], len(items)))
+        parts.append("</details></section>")
+    parts.append(_out_of_scope_block(comparison))
+    parts.append("</section>")
+    return "".join(parts)
+
+
+def _excluded_from_denominator_block(comparison) -> str:
+    """分母剔除清单：逐条说明命中率分母为何小于复核条数，并给出在件依据。"""
+    items = comparison.get("reviewItems") or []
+    out_of_scope = comparison.get("outOfScopeItems") or []
+    rows = []
+    for resolution, label in (
+        ("L-resolved", "已修改/已落实 · 不计入分母"),
+        ("L-uncheckable", "材料缺失或不可读 · 不计入分母"),
+    ):
+        for item in items:
+            if item.get("inFileResolution") != resolution:
+                continue
+            evidence = item.get("inFileEvidence") or {}
+            rows.append((label, item.get("itemId"), item.get("title"),
+                         evidence.get("file") or IN_FILE_ABSENT_LABEL,
+                         evidence.get("locator") or IN_FILE_ABSENT_LABEL,
+                         REVIEW_MATCH_LABEL.get(item.get("matchStatus"), item.get("matchStatus"))))
+    for item in out_of_scope:
+        rows.append(("能力边界 · 登记备查", item.get("itemId"), item.get("title"),
+                     item.get("exclusionReason"), item.get("handling"), "不计分"))
+    if not rows:
+        return ""
+    parts = ['<details class="review-excluded"><summary>{0}</summary>'.format(
+        _text("展开不计入命中率分母的条目（共 {0} 条）".format(len(rows))))]
+    parts.append('<p class="formula">{0}</p>'.format(
+        _text("命中率分母 = 复核条数 − 已修改/已落实 − 材料缺失或不可读 − 能力边界；下列条目逐条给出剔除依据。")))
+    parts.append('<div class="table-scroll"><table><thead><tr>' + "".join(
+        '<th scope="col">{0}</th>'.format(_text(label))
+        for label in ("剔除依据", "编号", "条目", "在件文件/依据", "在件定位/处理", "AI 对照")
+    ) + "</tr></thead><tbody>")
+    for row in rows:
+        parts.append("<tr>" + "".join("<td>{0}</td>".format(_text(cell)) for cell in row) + "</tr>")
+    parts.append("</tbody></table></div></details>")
+    return "".join(parts)
+
+
+def _out_of_scope_block(comparison) -> str:
+    """能力边界条目：不计分母、不计漏检，但必须登记备查、可见可展开。"""
+    items = comparison.get("outOfScopeItems") or []
+    if not items:
+        return ""
+    parts = ['<details class="review-out-of-scope"><summary>{0}</summary>'.format(
+        _text("展开不计入命中率的登记备查条目（共 {0} 条）".format(len(items))))]
+    parts.append('<p class="formula">{0}</p>'.format(
+        _text("以下条目属 AI 当前不具备的能力层（如底稿审核），不计入命中率分母、不计漏检、不作评分，仅登记备查并交人工复核。")))
+    for item in items:
+        evidence = item.get("reviewerEvidence") or {}
+        rows = [
+            ("编号", item.get("itemId")),
+            ("问题方向", item.get("module")),
+            ("复核文件", evidence.get("file")),
+            ("复核定位", evidence.get("locator")),
+            ("复核原文", evidence.get("quote")),
+            ("不计分原因", item.get("exclusionReason")),
+            ("处理", item.get("handling")),
+        ]
+        parts.append('<article class="review-item"><h4>{0}</h4><table class="kv">{1}</table></article>'.format(
+            _text(item.get("title")), _rows(rows)))
+    parts.append("</details>")
+    return "".join(parts)
+
+
+def _not_checked_item(item, index: int, total: int) -> str:
+    return (
+        "<tr><td>{0}</td><td>{1}</td><td>{2}</td><td>{3}</td><td>{4}</td><td>{5}</td><td>{6}</td></tr>"
+    ).format(
+        _item_index("未检查", index, total),
+        _text(item.get("itemId")),
+        _text(item.get("item")),
+        _text(REASON_LABEL.get(item.get("reasonCode"), item.get("reasonCode"))),
+        _text(item.get("reason")),
+        _text(item.get("impact")),
+        _text(item.get("requiredAction")),
+    )
+
+
+def _check_record_row(record) -> str:
+    return "<tr><td>{0}</td><td>{1}</td><td>{2}</td><td>{3}</td></tr>".format(
+        _text(record.get("recordId")),
+        _text(record.get("checkItem")),
+        _text(RESULT_LABEL.get(record.get("result"), record.get("result"))),
+        _text(record.get("executor")),
+    )
+
+
+def _adjudication_row(record) -> str:
+    ruling = record.get("ruling")
+    if not _is_nonempty_str(ruling):
+        ruling = RESULT_LABEL.get(record.get("result"), record.get("result"))
+    return "<tr><td>{0}</td><td>{1}</td><td>{2}</td></tr>".format(
+        _text(record.get("recordId") or record.get("chkId")),
+        _text(record.get("itemRef") or record.get("item") or record.get("checkItem")),
+        _text(ruling),
+    )
+
+
+def _validate_external_data(verification, errors):
+    """外部数据核验区校验：基准日锚定、源可用性声明、逐项核验与判定档位。
+
+    不可用的数据源不得被当作核验依据；数据源不可用时必须在 sources[] 显式声明。
+    """
+    if not isinstance(verification, dict):
+        errors.append("externalDataVerification 必须是对象")
+        return
+    applicability = verification.get("applicability")
+    if not isinstance(applicability, dict):
+        errors.append("externalDataVerification.applicability 必须是对象并先完成适用性判断")
+        applicability = {}
+    status = applicability.get("status")
+    if status not in EXT_DATA_APPLICABILITY_LABEL:
+        errors.append(
+            "externalDataVerification.applicability.status 取值非法：{0}（仅允许 required / not_applicable）".format(
+                status
+            )
+        )
+    for field in ("reason", "basis"):
+        if not _is_nonempty_str(applicability.get(field)):
+            errors.append("externalDataVerification.applicability.{0} 不得为空".format(field))
+    if not _is_nonempty_str(verification.get("baseDate")):
+        errors.append("externalDataVerification.baseDate 不得为空（外部数据核验必须以报告基准日为锚）")
+
+    sources = verification.get("sources")
+    if sources is None:
+        sources = []
+    if not isinstance(sources, list):
+        errors.append("externalDataVerification.sources 必须是数组")
+        sources = []
+    declared = {}
+    for index, item in enumerate(sources):
+        where = "externalDataVerification.sources[{0}]".format(index)
+        if not isinstance(item, dict):
+            errors.append("{0} 必须是对象".format(where))
+            continue
+        for field in ("source", "note"):
+            if not _is_nonempty_str(item.get(field)):
+                errors.append("{0}.{1} 不得为空".format(where, field))
+        for field in ("configured", "authenticated"):
+            if not isinstance(item.get(field), bool):
+                errors.append("{0}.{1} 必须是布尔值".format(where, field))
+        declared[str(item.get("source"))] = item
+
+    checks = verification.get("checks")
+    if checks is None:
+        checks = []
+    if not isinstance(checks, list):
+        errors.append("externalDataVerification.checks 必须是数组")
+        return
+    if status == "not_applicable":
+        if sources:
+            errors.append("externalDataVerification.applicability.status=not_applicable 时 sources 必须为空")
+        if checks:
+            errors.append("externalDataVerification.applicability.status=not_applicable 时 checks 必须为空")
+        if _is_nonempty_str(verification.get("unavailableDeclaration")):
+            errors.append(
+                "externalDataVerification.applicability.status=not_applicable 时不得填写 unavailableDeclaration"
+            )
+    elif status == "required" and not sources and not checks:
+        errors.append("externalDataVerification 至少要有 sources 或 checks 之一，不得空返")
+
+    unavailable = [
+        item
+        for item in sources
+        if isinstance(item, dict) and not (item.get("configured") and item.get("authenticated"))
+    ]
+    if status == "required" and unavailable and not _is_nonempty_str(verification.get("unavailableDeclaration")):
+        errors.append(
+            "externalDataVerification.unavailableDeclaration 在存在未配置 / 未认证数据源时不得为空"
+            "（兜底声明须由数据提供方写入，渲染器不自造句子）"
+        )
+
+    for index, check in enumerate(checks):
+        where = "externalDataVerification.checks[{0}]".format(index)
+        if not isinstance(check, dict):
+            errors.append("{0} 必须是对象".format(where))
+            continue
+        for field in ("checkId", "metric", "reportValue", "decision", "baseDate"):
+            if not _is_nonempty_str(check.get(field)):
+                errors.append("{0}.{1} 不得为空".format(where, field))
+        if check.get("decision") not in EXT_DATA_DECISIONS:
+            errors.append("{0}.decision 取值非法：{1}".format(where, check.get("decision")))
+        if check.get("decision") == "请说明" and not _is_nonempty_str(check.get("note")):
+            errors.append("{0}.note 在判定为“请说明”时不得为空".format(where))
+        evidence = check.get("reportEvidence")
+        if check.get("decision") == "不符合":
+            if not isinstance(evidence, dict) or not _is_nonempty_str(evidence.get("locator")):
+                errors.append("{0}.reportEvidence.locator 在判定为“不符合”时不得为空".format(where))
+        elif evidence is not None and not isinstance(evidence, dict):
+            errors.append("{0}.reportEvidence 必须是对象".format(where))
+
+        items = check.get("sources")
+        if not isinstance(items, list) or not items:
+            errors.append("{0}.sources 必须是非空数组".format(where))
+            continue
+        for sindex, item in enumerate(items):
+            swhere = "{0}.sources[{1}]".format(where, sindex)
+            if not isinstance(item, dict):
+                errors.append("{0} 必须是对象".format(swhere))
+                continue
+            if not _is_nonempty_str(item.get("source")) or not _is_nonempty_str(item.get("value")):
+                errors.append("{0}.source / value 不得为空".format(swhere))
+            name = str(item.get("source"))
+            declaration = declared.get(name)
+            if declared and declaration is None:
+                errors.append("{0}.source 未在 externalDataVerification.sources 中声明：{1}".format(swhere, name))
+            elif declaration is not None and not (
+                declaration.get("configured") and declaration.get("authenticated")
+            ) and item.get("available") is not False:
+                errors.append(
+                    "{0}：数据源 {1} 不可用（未配置 / 未认证），必须在条目中标记 available=false".format(
+                        swhere, name
+                    )
+                )
+
+
+def _external_data_sources_section(verification):
+    parts = []
+    sources = verification.get("sources") or []
+    if not sources:
+        return ""
+    parts.append("<h4>{0}</h4>".format(_text("数据源可用性")))
+    parts.append(
+        "<table><thead><tr><th>{0}</th><th>{1}</th><th>{2}</th><th>{3}</th></tr></thead><tbody>".format(
+            _text("数据源"), _text("是否配置"), _text("是否已授权"), _text("说明")
+        )
+    )
+    for item in sources:
+        parts.append(
+            "<tr><td>{0}</td><td>{1}</td><td>{2}</td><td>{3}</td></tr>".format(
+                _text(item.get("source")),
+                _text("已配置" if item.get("configured") else "未配置"),
+                _text("已授权" if item.get("authenticated") else "未授权"),
+                _text(item.get("note")),
+            )
+        )
+    parts.append("</tbody></table>")
+    return "".join(parts)
+
+
+def _external_data_checks_section(verification):
+    checks = verification.get("checks") or []
+    parts = ["<h4>{0}</h4>".format(_text("逐项核验"))]
+    if not checks:
+        parts.append('<p class="empty">{0}</p>'.format(_text(EXT_DATA_NO_CHECK_TEXT)))
+        return "".join(parts)
+
+    header = ["编号", "数据项", "报告值", "报告位置", "数据源", "外部取值", "取值时点", "口径", "差异说明", "判定", "说明"]
+    parts.append(
+        '<div class="table-scroll"><table><thead><tr>{0}</tr></thead><tbody>'.format(
+            "".join('<th scope="col">{0}</th>'.format(_text(cell)) for cell in header)
+        )
+    )
+    for check in checks:
+        base_date = check.get("baseDate") or verification.get("baseDate")
+        deviation = check.get("deviationAgainst")
+        if not _is_nonempty_str(deviation) or str(deviation).strip() == "—":
+            # 归一化："未检查"的项一律显示"未取数"，不得与"无出入"共用 — 号
+            deviation = EXT_DATA_NOT_FETCHED_TEXT if check.get("decision") == "未检查" else "—"
+        evidence = check.get("reportEvidence") or {}
+        tail = [
+            _text(item) for item in (
+                evidence.get("locator") or "未提供",
+            )
+        ]
+        end_cells = [
+            _text(deviation),
+            _text(check.get("decision")),
+            _text(check.get("note")),
+        ]
+        for item in check.get("sources") or []:
+            if item.get("available") is False:
+                value_cell = _text(EXT_DATA_UNAVAILABLE_TEXT)
+            else:
+                value_cell = _text(item.get("value"))
+            cells = [
+                _text(check.get("checkId")),
+                _text(check.get("metric")),
+                _text(check.get("reportValue")),
+                tail[0],
+                _text(item.get("source")),
+                value_cell,
+                _text(item.get("asOfDate") or base_date or ""),
+                _text(item.get("caliber") or ""),
+            ] + end_cells
+            parts.append("<tr>{0}</tr>".format("".join("<td>{0}</td>".format(cell) for cell in cells)))
+    parts.append("</tbody></table></div>")
+    return "".join(parts)
+
+
+def _external_data_section(verification) -> str:
+    """《外部数据核验》区：先展示适用性，再按需展示数据源与逐项核验。"""
+    parts = ['<section id="external-data-verification">']
+    parts.append("<h2>{0}</h2>".format(_text("AI 外部数据核验结果")))
+    if not isinstance(verification, dict) or not verification:
+        parts.append('<p class="empty">{0}</p>'.format(_text(EXT_DATA_EMPTY_TEXT)))
+        parts.append("</section>")
+        return "".join(parts)
+
+    applicability = verification.get("applicability") or {}
+    if applicability.get("status") == "not_applicable":
+        parts.append('<div class="external-applicability not-applicable">')
+        parts.append('<h3>{0}</h3>'.format(_text(EXT_DATA_NOT_APPLICABLE_TEXT)))
+        parts.append('<table class="kv">{0}</table>'.format(_rows([
+            ("不适用原因", applicability.get("reason")),
+            ("外部核验范围依据", applicability.get("basis")),
+        ])))
+        parts.append("</div></section>")
+        return "".join(parts)
+
+    unavailable = [
+        item
+        for item in (verification.get("sources") or [])
+        if not (item.get("configured") and item.get("authenticated"))
+    ]
+    declaration = verification.get("unavailableDeclaration")
+    if unavailable and _is_nonempty_str(declaration):
+        parts.append('<p class="banner">{0}</p>'.format(_text(declaration)))
+    parts.append('<table class="kv">{0}</table>'.format(_rows([("基准日", verification.get("baseDate"))])))
+    parts.append(_external_data_sources_section(verification))
+    parts.append(_external_data_checks_section(verification))
+    parts.append("</section>")
+    return "".join(parts)
+
+
+def _summary_breakdown_section(rendered_result) -> str:
+    """概览分区：问题按模块分布 + 外部数据核验结果（分列呈现，不与问题总数混列）。
+
+    全部由既有数据确定性推导（issues[].module / externalDataVerification.checks），
+    不新增冻结字段、不引入人工撰写的句子。
+    """
+    parts = []
+    issues = rendered_result.get("issues") or []
+    if issues:
+        order = []
+        stats = {}
+        for issue in issues:
+            module = str(issue.get("module") or "")
+            if module not in stats:
+                stats[module] = {"total": 0, "high": 0, "medium": 0, "low": 0}
+                order.append(module)
+            stats[module]["total"] += 1
+            severity = issue.get("severity")
+            if severity in ("high", "medium", "low"):
+                stats[module][severity] += 1
+        parts.append("<h4>{0}</h4>".format(_text("问题按模块分布")))
+        parts.append(
+            "<table><thead><tr><th>{0}</th><th>{1}</th><th>{2}</th><th>{3}</th><th>{4}</th></tr></thead><tbody>".format(
+                _text("模块"), _text("问题数"), _text("高"), _text("中"), _text("低")
+            )
+        )
+        for module in sorted(order, key=lambda name: (-stats[name]["total"], name)):
+            row = stats[module]
+            parts.append(
+                "<tr><td>{0}</td><td>{1}</td><td>{2}</td><td>{3}</td><td>{4}</td></tr>".format(
+                    _text(MODULE_LABEL.get(module, module)), _text(row["total"]), _text(row["high"]),
+                    _text(row["medium"]), _text(row["low"]),
+                )
+            )
+        parts.append("</tbody></table>")
+
+    verification = rendered_result.get("externalDataVerification") or {}
+    checks = verification.get("checks") or []
+    applicability = verification.get("applicability") or {}
+    if applicability.get("status") == "not_applicable":
+        parts.append("<h4>{0}</h4>".format(_text("外部数据核验结果")))
+        parts.append(
+            '<table><tbody><tr><td>{0}</td><td>{1}</td></tr></tbody></table>'.format(
+                _text("适用性"), _text(EXT_DATA_APPLICABILITY_LABEL["not_applicable"])
+            )
+        )
+    elif isinstance(checks, list) and checks:
+        counts = {}
+        for check in checks:
+            decision = str(check.get("decision") or "")
+            counts[decision] = counts.get(decision, 0) + 1
+        parts.append("<h4>{0}</h4>".format(_text("外部数据核验结果")))
+        parts.append(
+            "<table><thead><tr><th>{0}</th><th>{1}</th></tr></thead><tbody>".format(_text("判定"), _text("项数"))
+        )
+        for decision in EXT_DATA_DECISIONS:
+            if counts.get(decision):
+                parts.append(
+                    "<tr><td>{0}</td><td>{1}</td></tr>".format(_text(decision), _text(counts[decision]))
+                )
+        parts.append("</tbody></table>")
+
+        deviating = {}
+        no_deviation = 0
+        not_fetched = 0
+        unspecified = 0
+        for check in checks:
+            against = str(check.get("deviationAgainst") or "").strip()
+            decision = str(check.get("decision") or "")
+            if against and against != "—":
+                deviating[against] = deviating.get(against, 0) + 1
+            elif decision == "未检查":
+                not_fetched += 1
+            elif decision == "符合":
+                no_deviation += 1
+            else:
+                unspecified += 1
+        parts.append("<h4>{0}</h4>".format(_text("与哪一数据源出入较大")))
+        parts.append(
+            "<table><thead><tr><th>{0}</th><th>{1}</th></tr></thead><tbody>".format(_text("数据源"), _text("项数"))
+        )
+        for name in sorted(deviating, key=lambda item: (-deviating[item], item)):
+            parts.append(
+                "<tr><td>{0}</td><td>{1}</td></tr>".format(_text(name), _text(deviating[name]))
+            )
+        if no_deviation:
+            parts.append(
+                "<tr><td>{0}</td><td>{1}</td></tr>".format(_text(EXT_DATA_NO_DEVIATION_TEXT), _text(no_deviation))
+            )
+        if not_fetched:
+            parts.append(
+                "<tr><td>{0}</td><td>{1}</td></tr>".format(_text(EXT_DATA_NOT_FETCHED_TEXT), _text(not_fetched))
+            )
+        if unspecified:
+            parts.append(
+                "<tr><td>{0}</td><td>{1}</td></tr>".format(
+                    _text(EXT_DATA_UNSPECIFIED_SOURCE_TEXT), _text(unspecified)
+                )
+            )
+        parts.append("</tbody></table>")
+    return "".join(parts)
+
+
+def _summary_digest_group(label: str, items: list, css_class: str) -> str:
+    """用 JSON 既有标题与计数生成紧凑摘要，不创作新的业务判断。"""
+    visible = items[:SUMMARY_DIGEST_ITEM_LIMIT]
+    parts = ['<article class="summary-action-group {0}">'.format(css_class)]
+    parts.append('<h3><span>{0}</span><strong>{1}</strong></h3>'.format(_text(label), _text(len(items))))
+    if visible:
+        parts.append('<ol class="summary-action-list">')
+        parts.extend("<li>{0}</li>".format(_text(item.get("title"))) for item in visible)
+        if len(items) > SUMMARY_DIGEST_ITEM_LIMIT:
+            parts.append("<li>{0}</li>".format(
+                _text("另 {0} 项".format(len(items) - SUMMARY_DIGEST_ITEM_LIMIT))))
+        parts.append("</ol>")
+    else:
+        parts.append('<p class="empty">{0}</p>'.format(_text(EMPTY_TEXT)))
+    parts.append("</article>")
+    return "".join(parts)
+
+
+def _summary_action_digest(issues: list, manual_items: list) -> str:
+    high = [item for item in issues if item.get("severity") == "high"]
+    other = [item for item in issues if item.get("severity") != "high"]
+    return '<div class="summary-action-digest">{0}{1}{2}</div>'.format(
+        _summary_digest_group("优先处理", high, "priority"),
+        _summary_digest_group("继续核对", other, "follow-up"),
+        _summary_digest_group("人工确认", manual_items, "manual"),
+    )
+
+
+def render(result: dict, print_trail: bool = None) -> str:
+    """确定性渲染：文本节点只来自受控标签或输入数据，不生成新的业务句子。"""
+    rendered_result = json.loads(json.dumps(result, ensure_ascii=False))
+    file_trace = rendered_result.setdefault("fileTrace", {})
+
+    # sourceDigest：渲染输入的规范化摘要（摘要字段自身清零）
+    file_trace["sourceDigest"] = ""
+    file_trace["embeddedJsonDigest"] = ""
+    file_trace["rendererVersion"] = RENDERER_VERSION
+    source_digest = sha256_hex(canonical_json(rendered_result))
+    file_trace["sourceDigest"] = source_digest
+
+    embedded_digest = sha256_hex(canonical_json(rendered_result))
+    file_trace["embeddedJsonDigest"] = embedded_digest
+
+    payload = canonical_json(rendered_result).replace("<", "\\u003c")
+    audit_task = rendered_result.get("auditTask") or {}
+    summary = rendered_result.get("summary") or {}
+    counts = summary.get("counts") or {}
+    issues = rendered_result.get("issues") or []
+    manual_items = rendered_result.get("manualConfirmationItems") or []
+    audit_basis = rendered_result.get("auditBasis") or {}
+    rules = audit_basis.get("rules") or []
+    comparison = rendered_result.get("reviewComparison") or {}
+    scope = rendered_result.get("scope") or {}
+    trail = rendered_result.get("professionalTrail") or {}
+    policy = rendered_result.get("renderPolicy") or {}
+    if print_trail is None:
+        print_trail = bool(policy.get("printTrail"))
+
+    sorted_issues = sorted(
+        issues,
+        key=lambda item: (
+            {"high": 0, "medium": 1, "low": 2}.get(item.get("severity"), 3),
+            str(item.get("module")),
+            str(item.get("issueId")),
+        ),
+    )
+
+    parts = []
+    parts.append('<main id="audit-report">')
+
+    review_items = comparison.get("reviewItems") or []
+    review_metrics = _review_metrics(review_items)
+    unresolved_claims = sum(item.get("inFileResolution") == "L-unclosed" for item in review_items)
+    report_title = "中瑞世联AI审核报告 - {0}".format(audit_task.get("projectId"))
+
+    # 01 AI 审核综合总结 + 紧凑项目信息
+    parts.append('<header id="project-info">')
+    parts.append("<h1>{0}</h1>".format(_text(report_title)))
+    parts.append('<p class="project-line"><strong>{0}</strong><span>{1}</span><span>{2}</span><span>{3}</span></p>'.format(
+        _text(audit_task.get("projectId")), _text(audit_task.get("reportVersion")),
+        _text(((audit_task.get("profile") or {}).get("objectType"))), _text(_dt(audit_task.get("auditTime", "")))))
+    parts.append(
+        '<p class="badge">{0}</p>'.format(
+            _span(
+                "phase-note",
+                "阶段一独立审核已完成并冻结；阶段二复核对照不改变阶段一结论"
+                if comparison.get("status") == "performed"
+                else "阶段一独立审核已完成并冻结；本次未执行阶段二复核对照",
+            )
+        )
+    )
+    parts.append(
+        '<details class="project-details"><summary>{0}</summary><table class="kv">{1}</table></details>'.format(
+            _text("查看完整项目信息"),
+            _rows(
+                [
+                    ("报告流水号ID", audit_task.get("projectId")),
+                    ("报告版本", audit_task.get("reportVersion")),
+                    ("审核时间", _dt(audit_task.get("auditTime", ""))),
+                    ("对象类型", ((audit_task.get("profile") or {}).get("objectType"))),
+                    ("评估方法", "、".join((audit_task.get("profile") or {}).get("methods") or [])),
+                    ("场景", ((audit_task.get("profile") or {}).get("scenario"))),
+                    ("环节", ((audit_task.get("profile") or {}).get("stage"))),
+                    ("引擎版本", audit_task.get("engineVersion")),
+                ]
+            )
+        )
+    )
+    parts.append("</header>")
+
+    # 02 审核结果概览
+    parts.append('<section id="summary">')
+    parts.append("<h2>{0}</h2>".format(_text("本次 AI 审核结论")))
+    parts.append('<p class="banner">{0}</p>'.format(_text(OVERALL_LABEL.get(summary.get("overallDecision"), summary.get("overallDecision")))))
+    if unresolved_claims:
+        parts.append('<a class="summary-closure-alert" href="#review-unclosed-alert">{0}</a>'.format(
+            _text("已称修复但实际未落实：{0} 条，须优先回客户".format(unresolved_claims))))
+    parts.append('<div class="summary-kpis">')
+    for label, value, cls, href in (
+        ("AI 检出问题", counts.get("issuesTotal"), "danger", "#actionable-issues"),
+        ("待人工确认", counts.get("pendingConfirmation"), "warning", "#manual-confirmation-items"),
+        ("未检查项", counts.get("notChecked"), "neutral", "#not-checked-items"),
+        ("命中率", _format_rate(review_metrics["hitRate"]) if review_items else "数据不足", "primary", None),
+        ("实际未落实", unresolved_claims, "danger", "#review-unclosed-alert" if unresolved_claims else None),
+    ):
+        if href:
+            parts.append(
+                '<a class="metric-card metric-link {0}" href="{1}"><span>{2}</span><strong>{3}</strong></a>'.format(
+                    cls, href, _text(label), _text(value)))
+        else:
+            parts.append('<div class="metric-card {0}"><span>{1}</span><strong>{2}</strong></div>'.format(
+                cls, _text(label), _text(value)))
+    parts.append("</div>")
+    parts.append(_summary_action_digest(sorted_issues, manual_items))
+    parts.append(
+        '<details class="summary-narrative-details"><summary>{0}</summary><p>{1}</p></details>'.format(
+            _text("查看完整 AI 审核说明"), _span("narrative", summary.get("narrative"))))
+    parts.append(_header_hit_rate_caliber(rendered_result.get("reviewComparison") or {}))
+    parts.append('<details class="summary-details"><summary>{0}</summary>{1}</details>'.format(
+        _text("展开问题分布与核验概览"), _summary_breakdown_section(rendered_result)))
+    parts.append("</section>")
+
+    # 03 需要处理的问题
+    parts.append('<section id="actionable-issues">')
+    parts.append("<h2>{0}</h2>".format(_text("AI 检出的问题项")))
+    parts.append(_ai_only_summary(sorted_issues, comparison))
+    if sorted_issues:
+        for index, issue in enumerate(sorted_issues, start=1):
+            parts.append(_issue_card(issue, index, len(sorted_issues)))
+    else:
+        parts.append('<p class="empty">{0}</p>'.format(_text(EMPTY_TEXT)))
+    parts.append("</section>")
+
+    # 04 需要人工确认事项
+    parts.append('<section id="manual-confirmation-items">')
+    parts.append("<h2>{0}</h2>".format(_text("需要人工确认事项")))
+    if manual_items:
+        parts.append('<ol class="numbered-card-list">')
+        for index, item in enumerate(manual_items, start=1):
+            parts.append("<li>{0}</li>".format(_manual_item(item, index, len(manual_items))))
+        parts.append("</ol>")
+    else:
+        parts.append('<p class="empty">{0}</p>'.format(_text(EMPTY_TEXT)))
+    parts.append("</section>")
+
+    # 05 AI 外部数据核验
+    parts.append(_external_data_section(rendered_result.get("externalDataVerification")))
+
+    # 06 人工复核对照
+    parts.append(_review_comparison_section(comparison))
+
+    # 07 AI 审核表现评分卡（按明细重算）
+    parts.append(_scorecard_section(comparison, result.get("selfAuditErrors") or []))
+
+    # 08 本次审核依据（默认收起）
+    parts.append('<section id="audit-basis">')
+    parts.append("<h2>{0}</h2>".format(_text("本次审核依据")))
+    parts.append('<details class="audit-basis-details"><summary>{0}</summary>'.format(
+        _text("展开全部审核依据（共 {0} 条规则）".format(len(rules)))))
+    parts.append(_rule_map(rules))
+    parts.append('<div class="table-scroll"><table><thead><tr>' + "".join(
+        '<th scope="col">{0}</th>'.format(_text(label))
+        for label in ("规则编号", "权威层级", "来源分类", "名称", "版本", "条款", "引用次数")
+    ) + '</tr></thead><tbody>')
+    for rule in sorted(rules, key=lambda item: str(item.get("ruleId"))):
+        parts.append("<tr><td>{0}</td><td>{1}</td><td>{2}</td><td>{3}</td><td>{4}</td><td>{5}</td><td>{6}</td></tr>".format(
+            _text(rule.get("ruleId")), _text(AUTHORITY_LABEL.get(rule.get("authorityClass"), rule.get("authorityClass"))),
+            _text(SOURCE_TYPE_LABEL.get(rule.get("sourceType"), rule.get("sourceType"))), _text(rule.get("title")),
+            _text(rule.get("version")), _text(rule.get("clause")), _text(rule.get("usageCount"))))
+    parts.append("</tbody></table></div>")
+    kb_files = audit_basis.get("knowledgeBaseFiles") or []
+    if kb_files:
+        parts.append("<h3>{0}</h3><ul>".format(_text("本次知识库文件")))
+        parts.extend("<li>{0}{1}</li>".format(
+            _span("kb-path", item.get("path") or item.get("kbRelativePath")),
+            _span("exported-at", item.get("exportedAt"))) for item in kb_files)
+        parts.append("</ul>")
+    parts.append("</details></section>")
+
+    # 07 审核范围与未检查项
+    parts.append('<section id="scope-and-not-checked">')
+    parts.append("<h2>{0}</h2>".format(_text("审核范围与未检查项")))
+    parts.append(
+        '<table><thead><tr><th>{0}</th><th>{1}</th><th>{2}</th></tr></thead><tbody>'.format(
+            _text("文件"), _text("版本"), _text("可读")
+        )
+    )
+    for item in scope.get("inputs") or []:
+        parts.append(
+            "<tr><td>{0}</td><td>{1}</td><td>{2}</td></tr>".format(
+                _text(item.get("displayName")), _text(item.get("version")), _readable_status(item.get("readable"))
+            )
+        )
+    parts.append("</tbody></table>")
+    parts.append("<h4>{0}</h4>".format(_text("检查域")))
+    parts.append("<ul>" + "".join("<li>{0}</li>".format(_text(domain)) for domain in (scope.get("checkDomains") or [])) + "</ul>")
+    parts.append('<div id="not-checked-items">')
+    parts.append("<h4>{0}</h4>".format(_text("未检查项")))
+    not_checked = scope.get("notCheckedItems") or []
+    if not_checked:
+        parts.append(
+            '<table><thead><tr><th>{0}</th><th>{1}</th><th>{2}</th><th>{3}</th><th>{4}</th><th>{5}</th><th>{6}</th></tr></thead><tbody>'.format(
+                _text("序号"), _text("编号"), _text("未检查项"), _text("原因码"), _text("原因"), _text("影响"), _text("需要的动作")
+            )
+        )
+        for index, item in enumerate(not_checked, start=1):
+            parts.append(_not_checked_item(item, index, len(not_checked)))
+        parts.append("</tbody></table>")
+    else:
+        parts.append('<p class="empty">{0}</p>'.format(_text(EMPTY_TEXT)))
+    parts.append("</div>")
+    limitations = scope.get("limitations") or []
+    if limitations:
+        parts.append("<h4>{0}</h4>".format(_text("能力边界")))
+        parts.append("<ul>" + "".join("<li>{0}</li>".format(_text(item)) for item in limitations) + "</ul>")
+    parts.append("</section>")
+
+    # 08 专业审核轨迹（默认折叠）
+    parts.append('<details id="professional-trail"{0}>'.format(" open" if print_trail else ""))
+    parts.append("<summary>{0}</summary>".format(_text("专业审核轨迹")))
+    parts.append('<section id="rule-snapshot"><h4>{0}</h4><table class="kv">{1}</table></section>'.format(
+        _text("适用规则集快照"),
+        _rows([(key, value) for key, value in sorted((trail.get("applicableRuleSnapshot") or {}).items())]),
+    ))
+    parts.append('<section id="adjudications"><h4>{0}</h4>'.format(_text("逐条裁定表")))
+    adjudications = trail.get("adjudications") or []
+    if adjudications:
+        parts.append('<table><thead><tr><th>{0}</th><th>{1}</th><th>{2}</th></tr></thead><tbody>'.format(
+            _text("编号"), _text("条目"), _text("裁定")))
+        for record in adjudications:
+            parts.append(_adjudication_row(record))
+        parts.append("</tbody></table>")
+    else:
+        parts.append('<p class="empty">{0}</p>'.format(_text(EMPTY_TEXT)))
+    parts.append("</section>")
+    parts.append('<section id="check-records"><h4>{0}</h4>'.format(_text("审核记录清单")))
+    check_records = trail.get("checkRecords") or []
+    if check_records:
+        parts.append('<table><thead><tr><th>{0}</th><th>{1}</th><th>{2}</th><th>{3}</th></tr></thead><tbody>'.format(
+            _text("记录编号"), _text("检查项"), _text("结论"), _text("执行模块")))
+        for record in check_records:
+            parts.append(_check_record_row(record))
+        parts.append("</tbody></table>")
+    else:
+        parts.append('<p class="empty">{0}</p>'.format(_text(EMPTY_TEXT)))
+    parts.append("</section>")
+    parts.append('<section id="comprehensive-comparison"><h4>{0}</h4><table class="kv">{1}</table></section>'.format(
+        _text("复核综合对比"),
+        _rows([(key, value) for key, value in sorted((trail.get("comprehensiveComparison") or {}).items())]),
+    ))
+    parts.append("</details>")
+
+    # 09 文件追溯信息
+    file_trace = rendered_result.get("fileTrace") or {}
+    parts.append('<footer id="file-trace">')
+    parts.append("<h2>{0}</h2>".format(_text("文件追溯信息")))
+    parts.append(
+        '<table class="kv">{0}</table>'.format(
+            _rows(
+                [
+                    ("生成时间", file_trace.get("generatedAt")),
+                    ("渲染器版本", file_trace.get("rendererVersion")),
+                    ("数据摘要", file_trace.get("sourceDigest")),
+                    ("嵌入 JSON 摘要", file_trace.get("embeddedJsonDigest")),
+                ]
+            )
+        )
+    )
+    parts.append('<p class="footer-meta">{0}</p>'.format(_text("AI 辅助审核结果，供人工三级复核与员工答复流转；合理性质疑与无依据待判事项须人工确认后方可作为结论依据。")))
+    parts.append("</footer>")
+
+    parts.append("</main>")
+    report_content = "\n".join(parts)
+    template = TEMPLATE_PATH.read_text(encoding="utf-8")
+    template_values = {
+        "document_title": _text(report_title),
+        "report_content": report_content,
+        "embedded_json": payload,
+    }
+    placeholders_seen = set()
+
+    def inject_template_value(match):
+        key = match.group(1)
+        placeholders_seen.add(key)
+        return template_values[key]
+
+    document = re.sub(
+        r"\{\{(document_title|report_content|embedded_json)\}\}",
+        inject_template_value,
+        template,
+    )
+    missing = set(template_values) - placeholders_seen
+    if missing:
+        raise ValueError("HTML 模板缺少挂载点：{0}".format("、".join(sorted(missing))))
+    return document
+
+
+# --------------------------------------------------------------------------- #
+# CLI
+# --------------------------------------------------------------------------- #
+def embedded_result_from_document(document: str) -> dict:
+    match = re.search(
+        r'<script id="audit-result" type="application/json">(.*?)</script>',
+        document,
+        re.S,
+    )
+    if not match:
+        raise ValueError("HTML 缺少内嵌 AuditResult")
+    return json.loads(match.group(1))
+
+
+def _write_render_pair(html_path: Path, json_path: Path, document: str, rendered: dict) -> None:
+    """全部校验完成后再写临时文件，避免业务校验失败留下半成品。"""
+    if html_path.resolve() == json_path.resolve():
+        raise ValueError("HTML 与配套 JSON 输出路径不得相同")
+    html_path.parent.mkdir(parents=True, exist_ok=True)
+    json_path.parent.mkdir(parents=True, exist_ok=True)
+    html_temp = html_path.with_name(html_path.name + ".tmp")
+    json_temp = json_path.with_name(json_path.name + ".tmp")
+    try:
+        html_temp.write_text(document, encoding="utf-8")
+        json_temp.write_text(canonical_json(rendered) + "\n", encoding="utf-8")
+        json_temp.replace(json_path)
+        html_temp.replace(html_path)
+    finally:
+        for path in (html_temp, json_temp):
+            if path.exists():
+                path.unlink()
+
+
+def _cmd_validate(args) -> int:
+    result = load_result(Path(args.path))
+    errors = validate(result, rendered=args.rendered, expect_renderer=args.rendered)
+    if errors:
+        for error in errors:
+            print("ERROR: {0}".format(error), file=sys.stderr)
+        print("校验失败：{0} 项".format(len(errors)), file=sys.stderr)
+        return 1
+    print("校验通过：{0}".format(args.path))
+    return 0
+
+
+def _cmd_digest(args) -> int:
+    """阶段一冻结指纹：对冻结快照做规范化序列化后取 sha256（写入 phaseControl.phase1Digest）。"""
+    result = load_result(Path(args.path))
+    print(sha256_hex(canonical_json(result)))
+    return 0
+
+
+def _cmd_render(args) -> int:
+    result = load_result(Path(args.path))
+    errors = validate(result, rendered=False)
+    if errors:
+        for error in errors:
+            print("ERROR: {0}".format(error), file=sys.stderr)
+        print("JSON 校验失败，已退回修正，未生成 HTML：{0} 项".format(len(errors)), file=sys.stderr)
+        return 1
+    document = render(result)
+    rendered = embedded_result_from_document(document)
+    post_errors = validate(rendered, rendered=True, expect_renderer=True)
+    if post_errors:
+        for error in post_errors:
+            print("ERROR: {0}".format(error), file=sys.stderr)
+        print("渲染后自检失败，未写出交付文件：{0} 项".format(len(post_errors)), file=sys.stderr)
+        return 1
+    out_path = Path(args.out)
+    json_out_path = Path(args.json_out)
+    _write_render_pair(out_path, json_out_path, document, rendered)
+    print("已渲染：{0}".format(out_path))
+    print("已归档：{0}".format(json_out_path))
+    return 0
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(description="CRWU AuditResult 校验与单文件 HTML 渲染（送达规范 v1.6）")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    validate_parser = subparsers.add_parser("validate", help="校验 AuditResult JSON")
+    validate_parser.add_argument("path", help="AuditResult JSON 路径")
+    validate_parser.add_argument("--rendered", action="store_true", help="按渲染后状态校验（要求摘要已回填）")
+    validate_parser.set_defaults(func=_cmd_validate)
+
+    digest_parser = subparsers.add_parser("digest", help="计算阶段一冻结指纹（规范化 JSON 的 sha256）")
+    digest_parser.add_argument("path", help="冻结快照 JSON 路径")
+    digest_parser.set_defaults(func=_cmd_digest)
+
+    render_parser = subparsers.add_parser("render", help="渲染自包含单文件 HTML")
+    render_parser.add_argument("path", help="AuditResult JSON 路径")
+    render_parser.add_argument("--out", required=True, help="输出 HTML 路径")
+    render_parser.add_argument("--json-out", required=True, help="输出与 HTML 内嵌对象完全一致的 AuditResult JSON")
+    render_parser.set_defaults(func=_cmd_render)
+
+    args = parser.parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())