@huicai/cli 2026.804.0 → 2026.1019.0

package/skills/docx-author/scripts/docx_check.py

@@ -0,0 +1,1306 @@
+# Word 技术文档体检与自动校正。
+#
+# 定位：Word 文档的排版事故与 PPT 不同——PPT 是「看得见的几何事故」（文字出框、元素重叠），
+# Word 是「翻过去才发现的一致性事故」：这一段首行缩进了下一段没缩、正文里混着三种字号、
+# 图表编号跳号、表格宽出版心被裁掉右边一列、通篇是「有效提升」却没有一个数字。
+# 这些在保存时都不报错，打印出来才丢人。所以本模块干三件事：
+#
+#   1. 逐段还原**实际生效的排版属性**（run → 段落样式 → 样式链 → Normal），按规范档位比对；
+#   2. 几何一律用**文档自己的页面设置**算（不是用规范里的理想值），超版心/变形/发虚都是算术题；
+#   3. 文字与 AI 味交给 zh_prose（同一套判据也能用在 Markdown 草稿上，写作中途就能预检）。
+#
+# fix=true 只修**可确定性修**的那几类，且一律另存 `-已校正.docx` 不覆盖原件。
+# 改内容才能解决的（套话太多、缺数字、章节失衡）它会如实说「需要人改」——不假装修好了。
+
+import json
+import os
+import re
+import sys
+from collections import Counter, defaultdict
+
+from docx import Document
+from docx.enum.text import WD_ALIGN_PARAGRAPH, WD_LINE_SPACING
+from docx.oxml import OxmlElement
+from docx.oxml.ns import qn
+from docx.shared import Cm, Pt, Emu
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import docx_layout as L          # noqa: E402
+import zh_prose as P             # noqa: E402
+
+EMU_PT = 12700.0
+EMU_CM = 360000.0
+
+
+def _issue(level, group, kind, loc, msg, detail='', fixable=False):
+    return {'level': level, 'group': group, 'kind': kind, 'loc': loc,
+            'msg': msg, 'detail': detail, 'fixable': fixable}
+
+
+# ── 一、解析：把 docx 还原成「实际生效属性」的段落模型 ──────────────────────
+def _style_chain(style, limit=8):
+    out, s, n = [], style, 0
+    while s is not None and n < limit:
+        out.append(s)
+        s = getattr(s, 'base_style', None)
+        n += 1
+    return out
+
+
+def _eff_size(run, para, doc):
+    """实际生效字号（磅）：run → 段落样式链 → Normal → docDefaults。"""
+    if run is not None and run.font.size is not None:
+        return run.font.size.pt
+    for s in _style_chain(para.style):
+        if s.font.size is not None:
+            return s.font.size.pt
+    try:
+        if doc.styles['Normal'].font.size is not None:
+            return doc.styles['Normal'].font.size.pt
+    except KeyError:
+        pass
+    d = doc.styles.element.find(qn('w:docDefaults'))
+    if d is not None:
+        sz = d.find('.//' + qn('w:sz'))
+        if sz is not None and sz.get(qn('w:val')):
+            return float(sz.get(qn('w:val'))) / 2.0
+    return 10.5
+
+
+def _rfonts(el):
+    rpr = getattr(el, 'rPr', None) if el is not None else None
+    return rpr.rFonts if rpr is not None and rpr.rFonts is not None else None
+
+
+def _eff_fonts(run, para, doc):
+    """实际生效的（西文名, 东亚名）。东亚名取不到=中文字体没设对，这是最高频的 Word 坑。"""
+    west = east = None
+    for el in ([run._element] if run is not None else []) + \
+              [s.element for s in _style_chain(para.style)] + \
+              [doc.styles['Normal'].element]:
+        rf = _rfonts(el)
+        if rf is None:
+            continue
+        west = west or rf.get(qn('w:ascii')) or rf.get(qn('w:hAnsi'))
+        east = east or rf.get(qn('w:eastAsia'))
+        if west and east:
+            break
+    return west, east
+
+
+def _eff_pf(para, attr, doc):
+    """实际生效的段落格式属性（直接设置 → 样式链）。"""
+    v = getattr(para.paragraph_format, attr, None)
+    if v is not None:
+        return v
+    for s in _style_chain(para.style):
+        pf = getattr(s, 'paragraph_format', None)
+        if pf is not None and getattr(pf, attr, None) is not None:
+            return getattr(pf, attr)
+    return None
+
+
+HEAD_RE = re.compile(r'^Heading\s*(\d)$|^标题\s*(\d)$')
+
+
+def _head_level(para):
+    m = HEAD_RE.match(str(para.style.name or ''))
+    if m:
+        return int(m.group(1) or m.group(2))
+    try:
+        lv = para._p.find(qn('w:pPr'))
+        if lv is not None:
+            o = lv.find(qn('w:outlineLvl'))
+            if o is not None and o.get(qn('w:val')) is not None:
+                return int(o.get(qn('w:val'))) + 1
+    except Exception:
+        pass
+    return 0
+
+
+def _fake_indent(text):
+    """假缩进：用全角/半角空格顶出来的首行缩进。改字号就会错位，是排版返工的常客。"""
+    m = re.match(r'^([　 ]{2,})', str(text or ''))
+    return len(m.group(1)) if m else 0
+
+
+# 段落「角色」识别：体检必须先分清正文与结构件，否则会对**完全合规的文档**喊狼来了——
+# 封面标题当然是小初、目录当然不缩进、列表项当然没有句号、签字栏当然右对齐。
+# 一个天天误报的体检器，用两次就没人看了，所以这一步比任何一条检查规则都重要。
+LIST_RE = re.compile(r'^\s*(?:[·•▪◦‣*+\-–—]|\(?\d+[.)、]|[（(][一二三四五六七八九十\d]+[)）]|[a-zA-Z][.)])\s+')
+SIGN_RE = re.compile(r'_{3,}|^\s*(?:编制|审核|批准|签字|签章|会签|日期|单位|负责人|项目负责人|盖章)\s*[:：]')
+NOTE_RE = re.compile(r'^\s*(?:注|说明|备注)\s*[:：]')
+
+
+def _role(rec, first_head_idx, n_total, is_toc, front_end=None):
+    """给段落定角色：front 前置件 / toc 目录 / heading 标题 / caption 题注 / list 列项 /
+    signature 签字栏 / blank 空段 / body 正文。只有 body 才吃「正文该有的样子」那套检查。
+
+    front_end = 前置件（封面/目录）的最后一段下标，由分节符定位。**必须有这条**：
+    「首个标题之前算前置件」这条规则在**没有任何标题的短文档**（决议、通知、签到表）上完全失效，
+    于是封面大标题（小初）、文号（四号）全被当成正文，报一堆「字号不统一/缩进忽有忽无」——
+    对一份完全合规的文档。"""
+    text = rec['text']
+    if is_toc:
+        return 'toc'
+    if front_end is not None and rec['index'] <= front_end:
+        return 'blank' if not text.strip() else 'front'
+    if rec['level']:
+        return 'heading'
+    if not text.strip():
+        return 'blank'
+    if rec['is_caption'] or NOTE_RE.match(text) or 'aption' in str(rec['style']) or '题注' in str(rec['style']):
+        return 'caption'
+    if first_head_idx is not None and rec['index'] < first_head_idx:
+        return 'front'
+    if SIGN_RE.search(text):
+        return 'signature'
+    if LIST_RE.match(text):
+        return 'list'
+    ind = rec['indent']
+    if ind is not None and ind < 0:                       # 悬挂缩进 = 列项排版
+        return 'list'
+    if (rec['align'] == WD_ALIGN_PARAGRAPH.RIGHT and len(text) <= 30
+            and rec['index'] >= n_total - 8):             # 文末右对齐短行 = 落款
+        return 'signature'
+    return 'body'
+
+
+class Doc:
+    """解析后的文档模型：段落、表格、插图、页面几何，全部按文档实际值还原。"""
+
+    def __init__(self, path, profile_name='auto'):
+        self.path = path
+        self.doc = Document(path)
+        self.xml = self.doc.element.body.xml
+        self._geom()
+        self.paras, self.blocks, self.tables, self.figures = [], [], [], []
+        self._walk()
+        self._section_widths()
+        self._assign_roles()
+        self.profile = L.profile(self._detect(profile_name))
+
+    def _geom(self):
+        s = self.doc.sections[0]
+        self.page_w_pt = (s.page_width or Cm(21).emu * 0 + Cm(21)) / EMU_PT if s.page_width else 21 * L.CM_PT
+        self.page_h_pt = s.page_height / EMU_PT if s.page_height else 29.7 * L.CM_PT
+        ml = (s.left_margin or 0) / EMU_PT
+        mr = (s.right_margin or 0) / EMU_PT
+        mt = (s.top_margin or 0) / EMU_PT
+        mb = (s.bottom_margin or 0) / EMU_PT
+        self.margin_pt = {'left': ml, 'right': mr, 'top': mt, 'bottom': mb}
+        self.body_w_pt = max(self.page_w_pt - ml - mr, 72.0)
+        self.body_h_pt = max(self.page_h_pt - mt - mb, 72.0)
+        self.landscape = self.page_w_pt > self.page_h_pt
+
+    def _walk(self):
+        body = self.doc.element.body
+        pmap = {p._p: p for p in self.doc.paragraphs}
+        tmap = {t._tbl: t for t in self.doc.tables}
+        chapter = 0
+        for child in body.iterchildren():
+            tag = child.tag.split('}')[-1]
+            if tag == 'p' and child in pmap:
+                para = pmap[child]
+                rec = self._para_rec(para, len(self.paras), chapter)
+                if rec['level'] == 1:
+                    chapter += 1
+                    rec['chapter'] = chapter
+                self.paras.append(rec)
+                self.blocks.append(('p', rec))
+                self._collect_figs(para, rec)
+            elif tag == 'tbl' and child in tmap:
+                t = tmap[child]
+                rec = self._table_rec(t, len(self.tables), chapter)
+                rec['after_para'] = len(self.paras) - 1
+                self.tables.append(rec)
+                self.blocks.append(('tbl', rec))
+
+    def _section_widths(self):
+        """每张图所在那一节的版心宽高（磅）。横排插图单独占一节、版心比纵向宽——按第一节判就会把它误报成超宽。
+        OOXML 里 sectPr 挂在一节的最后一段上，最后一节的挂在 body 末尾。"""
+        def dims(sp):
+            if sp is None:
+                return self.body_w_pt, self.body_h_pt
+            sz, mar = sp.find(qn('w:pgSz')), sp.find(qn('w:pgMar'))
+            try:
+                w, h = int(sz.get(qn('w:w'))) / 20.0, int(sz.get(qn('w:h'))) / 20.0
+                ml, mr = int(mar.get(qn('w:left'))) / 20.0, int(mar.get(qn('w:right'))) / 20.0
+                mt, mb = int(mar.get(qn('w:top'))) / 20.0, int(mar.get(qn('w:bottom'))) / 20.0
+                return max(w - ml - mr, 72.0), max(h - mt - mb, 72.0)
+            except (AttributeError, TypeError, ValueError):
+                return self.body_w_pt, self.body_h_pt
+        spans = []
+        for p in self.paras:
+            pPr = p['para']._p.find(qn('w:pPr'))
+            sp = pPr.find(qn('w:sectPr')) if pPr is not None else None
+            if sp is not None:
+                spans.append((p['index'], *dims(sp)))
+        spans.append((10 ** 9, *dims(self.doc.element.body.find(qn('w:sectPr')))))
+        for f in self.figures:
+            _, f['sec_w_pt'], f['sec_h_pt'] = next(x for x in spans if x[0] >= f['para_index'])
+
+    def _assign_roles(self):
+        heads = [p['index'] for p in self.paras if p['level']]
+        first = heads[0] if heads else None
+        n = len(self.paras)
+        front_end = self._front_end()
+        for p in self.paras:
+            is_toc = 'TOC' in (p['para']._p.xml or '')
+            p['role'] = _role(p, first, n, is_toc, front_end)
+            p['kind'] = {'heading': 'heading', 'caption': 'caption'}.get(p['role'],
+                        'body' if p['role'] == 'body' else p['role'])
+        self.front_end = front_end
+        for t in self.tables:
+            t['front'] = front_end is not None and t.get('after_para', 10 ** 9) <= front_end
+
+    def _front_end(self):
+        """用分节符定位前置件的末段：正式交付件把封面与目录放在第一节，正文另起一节
+        （为的是页码从第 1 页重算）。这条信号在没有标题的短文档上也成立，
+        而「首个标题之前」那条不成立——两条并用才盖得全。
+
+        三道护栏防止把正文首节误当封面：段数不多、文字很少、标题不超过一个（「目 录」）。"""
+        end = None
+        for p in self.paras:
+            pPr = p['para']._p.find(qn('w:pPr'))
+            if pPr is not None and pPr.find(qn('w:sectPr')) is not None:
+                end = p['index']
+                break
+        if end is None or end > 40:
+            return None
+        head = [p for p in self.paras[:end + 1] if p['level']]
+        chars = sum(len(p['text']) for p in self.paras[:end + 1])
+        if len(head) > 1 or chars > 400:
+            return None
+        return end
+
+    def _para_rec(self, para, idx, chapter):
+        runs = [r for r in para.runs if r.text]
+        first = runs[0] if runs else (para.runs[0] if para.runs else None)
+        size = _eff_size(first, para, self.doc)
+        west, east = _eff_fonts(first, para, self.doc)
+        sizes = {round(_eff_size(r, para, self.doc), 1) for r in runs} or {round(size, 1)}
+        text = para.text
+        level = _head_level(para)
+        cap = L.CAPTION_RE.match(text.strip()) if text.strip() else None
+        return {
+            'index': idx, 'para': para, 'text': text, 'level': level, 'chapter': chapter,
+            'style': para.style.name, 'size': size, 'sizes': sizes, 'east': east, 'west': west,
+            'bold': bool(first.bold) if first is not None else False,
+            'align': _eff_pf(para, 'alignment', self.doc),
+            'indent': _eff_pf(para, 'first_line_indent', self.doc),
+            'line': _eff_pf(para, 'line_spacing', self.doc),
+            'line_rule': _eff_pf(para, 'line_spacing_rule', self.doc),
+            'space_before': _eff_pf(para, 'space_before', self.doc),
+            'space_after': _eff_pf(para, 'space_after', self.doc),
+            'fake_indent': _fake_indent(text),
+            'n_draw': len(para._p.findall('.//' + qn('w:drawing'))),
+            'is_caption': bool(cap), 'caption': cap.groups() if cap else None,
+            'empty': not text.strip(),
+            'kind': 'heading' if level else ('caption' if cap else 'body'),
+        }
+
+    def _collect_figs(self, para, rec):
+        for dr in para._p.findall('.//' + qn('w:drawing')):
+            blip = dr.find('.//' + qn('a:blip'))
+            ext = dr.find('.//' + qn('wp:extent'))
+            w_pt = float(ext.get('cx')) / EMU_PT if ext is not None and ext.get('cx') else 0.0
+            h_pt = float(ext.get('cy')) / EMU_PT if ext is not None and ext.get('cy') else 0.0
+            px_w = px_h = dpi = 0
+            ok, err = True, ''
+            if blip is not None:
+                rid = blip.get(qn('r:embed'))
+                try:
+                    img = self.doc.part.related_parts[rid].image
+                    px_w, px_h, dpi = img.px_width, img.px_height, img.horz_dpi or 72
+                except Exception as e:      # 关系断了/图片损坏：Word 里显示成红叉
+                    ok, err = False, str(e)[:80]
+            else:
+                ok, err = False, '未找到图片引用（可能是被删除的嵌入对象）'
+            self.figures.append({'para_index': rec['index'], 'chapter': rec['chapter'],
+                                 'w_pt': w_pt, 'h_pt': h_pt, 'px_w': px_w, 'px_h': px_h,
+                                 'dpi': dpi, 'ok': ok, 'err': err,
+                                 'anchor': dr.find(qn('wp:anchor')) is not None})
+
+    def _table_rec(self, t, idx, chapter):
+        rows = []
+        for r in t.rows:
+            try:
+                rows.append([c.text for c in r.cells])
+            except Exception:
+                rows.append([])
+        # 表宽有两个来源，**必须都量**：
+        #   · tblGrid 的 gridCol —— Word 自己排版时写的列宽；
+        #   · 每个单元格的 tcW —— 代码里 `cell.width = Cm(6)` 设的那个。
+        # 只读 tblGrid 会漏掉最典型的翻车件：手写 python-docx 时只设了 cell.width，
+        # tblGrid 还留着当初自动算的窄值，于是「体检说没超宽、打印出来右边一列没了」。
+        # 取两者较大的那个来判——渲染时以更宽的那份为准。
+        widths, grid_w = [], []
+        try:
+            grid = t._tbl.tblGrid
+            if grid is not None:
+                for gc in grid.findall(qn('w:gridCol')):
+                    w = gc.get(qn('w:w'))
+                    grid_w.append(float(w) / 20.0 if w else 0.0)     # twips → 磅
+        except Exception:
+            pass
+        cell_w = []
+        try:
+            for row in t.rows:
+                cur = [(c.width / EMU_PT) if c.width else 0.0 for c in row.cells]
+                if sum(cur) > sum(cell_w):
+                    cell_w = cur
+        except Exception:
+            pass
+        widths = cell_w if sum(cell_w) > sum(grid_w) else grid_w
+        head_repeat = False
+        try:
+            tr = t.rows[0]._tr
+            trpr = tr.find(qn('w:trPr'))
+            head_repeat = trpr is not None and trpr.find(qn('w:tblHeader')) is not None
+        except Exception:
+            pass
+        head_bold = False
+        try:
+            head_bold = all(any(r.bold for p in c.paragraphs for r in p.runs if r.text)
+                            for c in t.rows[0].cells if c.text.strip())
+        except Exception:
+            pass
+        # 表单式两列表（键在左、值在右，如验收申请表/交付物清单）没有「表头行」，
+        # 它的加粗在**第一列**。按普通表判会误报「表头未加粗」，那是把表单当成了数据表。
+        form_like = False
+        try:
+            if len(rows) >= 2 and max((len(r) for r in rows), default=0) == 2:
+                left_bold = [any(r.bold for p in row.cells[0].paragraphs for r in p.runs if r.text)
+                             for row in t.rows if row.cells[0].text.strip()]
+                form_like = bool(left_bold) and all(left_bold)
+        except Exception:
+            pass
+        return {'index': idx, 'tbl': t, 'rows': rows, 'chapter': chapter,
+                'n_rows': len(rows), 'n_cols': max((len(r) for r in rows), default=0),
+                'widths_pt': widths, 'total_pt': sum(widths),
+                'head_repeat': head_repeat, 'head_bold': head_bold, 'form_like': form_like,
+                'style': t.style.name if t.style is not None else ''}
+
+    def bodies(self):
+        """真正的正文段（结构件一律排除）——所有「正文该长什么样」的检查都以它为准。"""
+        return [p for p in self.paras if p['role'] == 'body' and p['text'].strip()]
+
+    def _detect(self, name):
+        if name and name != 'auto':
+            return name
+        sizes = Counter(round(p['size']) for p in self.bodies())
+        easts = Counter(p['east'] for p in self.bodies() if p['east'])
+        body_size = sizes.most_common(1)[0][0] if sizes else 12
+        east = easts.most_common(1)[0][0] if easts else ''
+        if body_size >= 15 and ('仿宋' in str(east) or self.margin_pt['top'] / L.CM_PT > 3.2):
+            return 'gov'
+        heads = [p['text'] for p in self.paras if p['level']]
+        dec = sum(1 for h in heads if (L.parse_number(h) or ('', (), ''))[0] == 'dec')
+        if heads and dec / len(heads) > 0.5:
+            return 'report'
+        return 'tech'
+
+    # 估算总页数：所有块的高度累加 ÷ 版心高。粗但够用（用于「文档约几页」与超长提醒）。
+    def est_pages(self):
+        h = 0.0
+        for kind, b in self.blocks:
+            if kind == 'p':
+                st = {'size': b['size'], 'line': b['line'] or 1.0,
+                      'line_rule': 'exact' if b['line_rule'] == WD_LINE_SPACING.EXACTLY else 'multiple',
+                      'first_indent_chars': 0,
+                      'space_before': (b['space_before'] or 0) / EMU_PT,
+                      'space_after': (b['space_after'] or 0) / EMU_PT}
+                n = L.wrap_count(b['text'], b['size'], self.body_w_pt,
+                                 (b['indent'] or 0) / EMU_PT)
+                ln = b['line']
+                if isinstance(ln, int):
+                    # 固定值/最小值行距：python-docx 给的是 Length（EMU），不是磅——
+                    # 当磅用会把一页估成十几万页（20 磅 = 254000 EMU）
+                    lh = float(ln) / EMU_PT
+                    if b['line_rule'] != WD_LINE_SPACING.EXACTLY:
+                        lh = max(lh, b['size'] * L.LINE_H)
+                else:
+                    lh = b['size'] * L.LINE_H * float(ln or 1.0)
+                h += n * lh + st['space_before'] + st['space_after']
+                for f in self.figures:
+                    if f['para_index'] == b['index']:
+                        h += f['h_pt']
+            else:
+                h += L.est_table_height(b['rows'], self.profile,
+                                        [w / L.CM_PT for w in b['widths_pt']] or None,
+                                        self.profile['table']['size'])
+        return max(1, round(h / self.body_h_pt + 0.5))
+
+
+# ── 二、检查族 ─────────────────────────────────────────────────────────────
+def _loc(rec):
+    return f"第 {rec['index']+1} 段"
+
+
+def check_structure(D):
+    out = []
+    heads = [p for p in D.paras if p['level']]
+    if not heads:
+        out.append(_issue('warn', 'structure', 'no-heading', '全文',
+                          '全文没有使用标题样式（Heading 1/2/3）',
+                          '没有大纲级别 = 生不出目录、导航窗格空白、后续也没法自动编号'))
+        return out
+    prev = 0
+    for h in heads:
+        if prev and h['level'] > prev + 1:
+            out.append(_issue('error', 'structure', 'level-jump', _loc(h),
+                              f"标题层级跳级：上一个是 {prev} 级，这里直接到 {h['level']} 级",
+                              f"「{h['text'][:30]}」——中间缺一级标题，目录会塌一层"))
+        prev = h['level']
+
+    # 空章节：标题下面没有任何正文/表/图
+    order = D.blocks
+    for i, (kind, b) in enumerate(order):
+        if kind != 'p' or not b['level']:
+            continue
+        has = False
+        for kind2, b2 in order[i + 1:]:
+            if kind2 == 'p' and b2['level']:
+                break
+            if kind2 == 'tbl' or (kind2 == 'p' and (b2['text'].strip() or b2['n_draw'])):
+                has = True
+                break
+        if not has:
+            out.append(_issue('warn', 'structure', 'empty-section', _loc(b),
+                              f"空章节：「{b['text'][:24]}」标题下没有任何内容",
+                              '要么补内容，要么删掉这个标题——交付件里的空壳章节最扎眼'))
+
+    # 编号连续性：**同一父章节下**的同级标题才该逐一递增。
+    # 不按父节点分组会把「每章的（一）重新从一开始」误判成断号——那恰恰是正确写法。
+    groups, anc = defaultdict(list), {}
+    for h in heads:
+        lv = h['level']
+        parent = tuple(anc.get(i) for i in range(1, lv))
+        for i in list(anc):
+            if i >= lv:
+                del anc[i]
+        anc[lv] = h['index']
+        n = L.parse_number(h['text'])
+        if n:
+            groups[(lv, n[0], parent)].append((h, n[1]))
+    for (lv, kind, _parent), items in groups.items():
+        if len(items) < 2:
+            continue
+        for (h1, s1), (h2, s2) in zip(items, items[1:]):
+            a, b = s1[-1], s2[-1]
+            if len(s1) == len(s2) and b != a + 1 and s1[:-1] == s2[:-1]:
+                out.append(_issue('error', 'structure', 'number-gap', _loc(h2),
+                                  f"章节编号不连续：{'.'.join(map(str,s1))} 之后是 {'.'.join(map(str,s2))}",
+                                  f"「{h2['text'][:30]}」"))
+
+    if 'TOC' not in D.xml and 'instrText' not in D.xml:
+        out.append(_issue('info', 'structure', 'no-toc', '全文',
+                          '没有插入目录域', '正式交付件建议插入 TOC 域（Word 中 F9 更新），不要手打静态目录'))
+    sec = D.doc.sections[0]
+    has_page = any('PAGE' in (p._p.xml or '') for p in list(sec.footer.paragraphs) + list(sec.header.paragraphs))
+    if not has_page:
+        out.append(_issue('warn', 'structure', 'no-pagenum', '全文', '页脚没有页码域',
+                          '十几页以上的交付件没有页码，评审时无法引用「第几页」'))
+    return out
+
+
+def check_typography(D, strict=False):
+    out = []
+    prof, bodies = D.profile, D.bodies()
+    if not bodies:
+        return out
+
+    # 页面设置是否合规
+    want = prof['margin_cm']
+    got = {k: v / L.CM_PT for k, v in D.margin_pt.items()}
+    bad = [f"{k} {got[k]:.2f}≠{want[k]:.2f}cm" for k in ('left', 'right', 'top', 'bottom')
+           if abs(got[k] - want[k]) > 0.45]
+    if bad:
+        out.append(_issue('info', 'layout', 'margin', '页面设置',
+                          f"页边距与「{prof['label']}」不一致：{'、'.join(bad)}",
+                          '不一致本身不是错，但同一套交付件里几份文档页边距不同会很难看', fixable=True))
+
+    # 字号一致性：正文里混着几种字号
+    sizes = Counter(round(p['size'], 1) for p in bodies)
+    main_size, main_n = sizes.most_common(1)[0]
+    if len(sizes) > 1:
+        others = [f'{L.size_name(s)}×{n}' for s, n in sizes.most_common()[1:6]]
+        lvl = 'error' if (main_n / len(bodies)) < 0.9 else 'warn'
+        out.append(_issue(lvl, 'layout', 'size-mix', '全文',
+                          f'正文字号不统一：主用 {L.size_name(main_size)}×{main_n}，另有 {"、".join(others)}',
+                          '多半是从别处粘贴时把源格式带进来了', fixable=True))
+    want_size = L.pt_of(prof['body']['size'])
+    if abs(main_size - want_size) > 0.6:
+        out.append(_issue('info', 'layout', 'size-spec', '全文',
+                          f'正文字号 {L.size_name(main_size)} 与规范 {prof["body"]["size"]} 不符',
+                          f"（当前档位：{prof['label']}）", fixable=True))
+    for p in bodies:
+        if len(p['sizes']) > 1:
+            out.append(_issue('warn', 'layout', 'size-in-para', _loc(p),
+                              f"同一段里有 {len(p['sizes'])} 种字号：{'/'.join(L.size_name(s) for s in sorted(p['sizes']))}",
+                              p['text'][:40], fixable=True))
+
+    # 东亚字体：只设 font.name 中文不生效，这是 Word 生成类脚本最高频的坑
+    miss = [p for p in D.paras if p['text'].strip() and not p['east'] and p['role'] != 'toc']
+    if miss:
+        out.append(_issue('error', 'layout', 'no-eastasia', _loc(miss[0]),
+                          f'{len(miss)} 段没有设置东亚字体（w:eastAsia）',
+                          '中文会退回主题默认字体，换台电脑打开就变样', fixable=True))
+    easts = Counter(p['east'] for p in bodies if p['east'])
+    if len(easts) > 2:
+        out.append(_issue('warn', 'layout', 'font-mix', '全文',
+                          f"正文中文字体有 {len(easts)} 种：{'、'.join(f'{k}×{v}' for k, v in easts.most_common(4))}",
+                          '', fixable=True))
+
+    # 首行缩进：缺失 / 假缩进 / 忽有忽无
+    want_ind = L.indent_pt(prof)
+    indented = sum(1 for p in bodies if (p['indent'] or 0) / EMU_PT >= want_ind * 0.6)
+    fake = [p for p in bodies if p['fake_indent']]
+    if fake:
+        out.append(_issue('error', 'layout', 'fake-indent', _loc(fake[0]),
+                          f'{len(fake)} 段用空格顶出首行缩进，不是真缩进',
+                          '换字号或换设备就会错位；正确做法是段落格式→首行缩进 2 字符', fixable=True))
+    if want_ind > 0 and bodies:
+        r = indented / len(bodies)
+        if 0.15 < r < 0.85:
+            out.append(_issue('error', 'layout', 'indent-mix', '全文',
+                              f'首行缩进时有时无：{indented}/{len(bodies)} 段有缩进（{r*100:.0f}%）',
+                              '这是打印出来最刺眼的一类问题', fixable=True))
+        elif r <= 0.15:
+            out.append(_issue('warn', 'layout', 'no-indent', '全文',
+                              f'正文普遍没有首行缩进（{indented}/{len(bodies)} 段）',
+                              '中文正式文档惯例是首行缩进 2 字符', fixable=True))
+
+    # 行距一致性
+    lines = Counter((p['line_rule'], round(float(p['line']), 2) if p['line'] else None) for p in bodies)
+    if len(lines) > 2:
+        out.append(_issue('warn', 'layout', 'line-mix', '全文',
+                          f'正文行距有 {len(lines)} 种设置', '同一份文档里行距要一致', fixable=True))
+
+    # 对齐：正文两端对齐，忽左忽中最难看
+    aligns = Counter(p['align'] for p in bodies)
+    centered = aligns.get(WD_ALIGN_PARAGRAPH.CENTER, 0)
+    if centered and centered < len(bodies) * 0.5:
+        out.append(_issue('warn', 'layout', 'align-mix', '全文',
+                          f'{centered} 段正文被设成了居中', '正文应两端对齐，居中只留给标题与题注', fixable=True))
+
+    # 连续空段：用回车拉版式，改一个字全篇错位
+    run_empty, first = 0, None
+    for p in D.paras:
+        if p['role'] in ('front', 'toc') or (first and first['role'] in ('front', 'toc')):
+            run_empty, first = 0, None
+            continue
+        if p['empty'] and not p['n_draw']:
+            run_empty += 1
+            first = first or p
+        else:
+            if run_empty >= 3:
+                out.append(_issue('warn', 'layout', 'blank-runs', _loc(first),
+                                  f'连续 {run_empty} 个空段落', '用「段前/段后间距」或分页符代替连打回车', fixable=True))
+            run_empty, first = 0, None
+
+    # 段末多余空格
+    trail = [p for p in bodies if p['text'] != p['text'].rstrip()]
+    if trail:
+        out.append(_issue('info', 'layout', 'trailing-space', _loc(trail[0]),
+                          f'{len(trail)} 段结尾有多余空格', '两端对齐时会把最后一行拉散', fixable=True))
+
+    # 标题过长导致折行（会把目录撑坏）
+    for h in [p for p in D.paras if p['level']]:
+        st = prof['headings'][min(h['level'], len(prof['headings'])) - 1]
+        if L.wrap_count(h['text'], h['size'], D.body_w_pt) > 2:
+            out.append(_issue('warn', 'layout', 'heading-wrap', _loc(h),
+                              f"标题折成 {L.wrap_count(h['text'], h['size'], D.body_w_pt)} 行",
+                              f"「{h['text'][:34]}」——标题应能一行放下，长的挪到正文首句"))
+    if strict:
+        for p in bodies:
+            if p['bold'] and len(p['text']) > 60:
+                out.append(_issue('info', 'layout', 'bold-para', _loc(p),
+                                  '整段加粗（>60 字）', '加粗用于点睛，整段加粗等于没有重点'))
+    return out
+
+
+def check_tables(D):
+    out = []
+    for t in D.tables:
+        if t.get('front'):
+            continue          # 封面信息栏是排版件不是数据表：无框线、无表头、无题注都是设计
+        loc = f"第 {t['index']+1} 张表"
+        if t['n_rows'] == 0 or t['n_cols'] == 0:
+            out.append(_issue('error', 'table', 'empty-table', loc, '空表格', '', fixable=False))
+            continue
+        widths = [len(r) for r in t['rows']]
+        if len(set(widths)) > 1:
+            out.append(_issue('warn', 'table', 'ragged', loc,
+                              f'各行列数不一致：{sorted(set(widths))}', '通常是合并单元格造成，确认是否为预期'))
+        if t['total_pt'] and t['total_pt'] > D.body_w_pt * L.TOL:
+            over = t['total_pt'] - D.body_w_pt
+            out.append(_issue('error', 'table', 'over-width', loc,
+                              f"表格宽 {t['total_pt']/L.CM_PT:.2f}cm 超出版心 {D.body_w_pt/L.CM_PT:.2f}cm（超 {over/L.CM_PT:.2f}cm）",
+                              '打印时右侧列会被裁掉——这是最常见的「表格显示不正常」', fixable=True))
+        if t['n_cols'] >= 7 and not D.landscape:
+            out.append(_issue('info', 'table', 'many-cols', loc,
+                              f"{t['n_cols']} 列的表格在纵向 A4 上会很挤",
+                              '考虑本节改横向页，或拆成两张表'))
+        if not t['head_bold'] and t['n_rows'] > 1 and not t['form_like']:
+            out.append(_issue('warn', 'table', 'head-not-bold', loc, '表头未加粗', '', fixable=True))
+        if t['n_rows'] > 12 and not t['head_repeat']:
+            out.append(_issue('warn', 'table', 'no-head-repeat', loc,
+                              f"{t['n_rows']} 行的长表格未设置「跨页重复标题行」",
+                              '翻页后读者不知道每列是什么', fixable=True))
+        cells = [c for r in t['rows'] for c in r]
+        blank = sum(1 for c in cells if not str(c).strip())
+        if cells and blank / len(cells) > 0.3:
+            out.append(_issue('warn', 'table', 'many-blank', loc,
+                              f'空单元格占 {blank/len(cells)*100:.0f}%（{blank}/{len(cells)}）',
+                              '空着不如填「—」或「不适用」，评审会当成漏填'))
+        longest = max((len(str(c)) for c in cells), default=0)
+        if longest > 120:
+            out.append(_issue('info', 'table', 'long-cell', loc,
+                              f'最长单元格 {longest} 字', '表格里塞长段落会把行撑得很高，长文本应放正文'))
+        if t['style'] in ('Normal Table', 'Table Normal', ''):
+            out.append(_issue('warn', 'table', 'no-border', loc,
+                              '表格未套用带框线的样式', '默认「普通表格」是无框线的，打印出来只有文字', fixable=True))
+    out.extend(_check_captions(D, 'tbl'))
+    return out
+
+
+def check_figures(D):
+    out = []
+    for i, f in enumerate(D.figures):
+        loc = f"第 {i+1} 张图（第 {f['para_index']+1} 段）"
+        if not f['ok']:
+            out.append(_issue('error', 'figure', 'broken', loc, f"图片无法读取：{f['err']}",
+                              'Word 里会显示成红叉或空白框'))
+            continue
+        bw, bh = f.get('sec_w_pt', D.body_w_pt), f.get('sec_h_pt', D.body_h_pt)
+        if f['w_pt'] > bw * L.TOL:
+            out.append(_issue('error', 'figure', 'over-width', loc,
+                              f"图宽 {f['w_pt']/L.CM_PT:.2f}cm 超出版心 {bw/L.CM_PT:.2f}cm",
+                              '右侧会被裁掉', fixable=True))
+        if f['px_w'] and f['px_h'] and f['w_pt'] and f['h_pt']:
+            nat = f['px_w'] / f['px_h']
+            shown = f['w_pt'] / f['h_pt']
+            dev = abs(shown - nat) / nat
+            if dev > 0.03:
+                out.append(_issue('error', 'figure', 'distorted', loc,
+                                  f'图片被拉变形：原始比例 {nat:.3f}，显示比例 {shown:.3f}（偏差 {dev*100:.1f}%）',
+                                  '同时给了宽和高就会这样；只给宽度，高度让它自己算', fixable=True))
+            dpi_eff = L.effective_dpi(f['px_w'], f['w_pt'] * L.PT_CM)
+            if dpi_eff and dpi_eff < 120:
+                out.append(_issue('warn', 'figure', 'low-dpi', loc,
+                                  f'有效分辨率仅 {dpi_eff:.0f} dpi（{f["px_w"]}px 放到 {f["w_pt"]*L.PT_CM:.1f}cm）',
+                                  '打印会发虚；工程图请用 render_diagram 重出矢量再转高清 PNG'))
+            if f['w_pt'] * L.PT_CM < 4 and f['px_w'] > 1400:
+                out.append(_issue('info', 'figure', 'tiny', loc,
+                                  f"图只显示 {f['w_pt']*L.PT_CM:.1f}cm 宽，里面的字会看不清", ''))
+        if f['h_pt'] > bh:
+            out.append(_issue('warn', 'figure', 'over-height', loc,
+                              f"图高 {f['h_pt']/L.CM_PT:.1f}cm 超过版心高 {bh/L.CM_PT:.1f}cm",
+                              '会独占一页并留下大片空白', fixable=True))
+        if f['anchor']:
+            out.append(_issue('info', 'figure', 'floating', loc,
+                              '浮动图片（环绕方式非嵌入型）', '编辑正文时会乱跑；技术文档建议改成「嵌入型」'))
+    out.extend(_check_captions(D, 'fig'))
+    out.extend(_check_refs(D))
+    return out
+
+
+def _caption_paras(D, kind):
+    """找出图/表的题注段：图题在图的下一段，表题在表的上一段（中文出版惯例）。"""
+    want = D.profile['fig_prefix'] if kind == 'fig' else D.profile['tab_prefix']
+    caps = []
+    for p in D.paras:
+        m = L.CAPTION_RE.match(p['text'].strip())
+        if m and m.group(1).lower().startswith(('图', 'fig') if kind == 'fig' else ('表', 'tab')):
+            caps.append((p, m.group(2), m.group(3)))
+    return caps, want
+
+
+def _check_captions(D, kind):
+    out = []
+    caps, want = _caption_paras(D, kind)
+    n_obj = (len(D.figures) if kind == 'fig'
+             else sum(1 for t in D.tables if not t.get('front')))
+    label = '插图' if kind == 'fig' else '表格'
+    if n_obj and not caps:
+        out.append(_issue('warn', 'caption', f'{kind}-no-caption', '全文',
+                          f'{n_obj} 个{label}全部没有题注',
+                          f'技术文档的{label}必须有「{want} X  名称」，否则正文无法引用'))
+        return out
+    if n_obj and len(caps) < n_obj:
+        out.append(_issue('warn', 'caption', f'{kind}-caption-missing', '全文',
+                          f'{n_obj} 个{label}只有 {len(caps)} 条题注',
+                          '题注文字要人来写，fix 只能重排已有题注的编号'))
+    seq = []
+    for p, num, _t in caps:
+        parts = re.split(r'[-–.]', num)
+        try:
+            seq.append((p, tuple(int(x) for x in parts)))
+        except ValueError:
+            continue
+    for (p1, s1), (p2, s2) in zip(seq, seq[1:]):
+        if len(s1) != len(s2):
+            continue
+        if s1[:-1] == s2[:-1] and s2[-1] != s1[-1] + 1:
+            out.append(_issue('error', 'caption', f'{kind}-number-gap', _loc(p2),
+                              f"{label}编号不连续：{want} {'-'.join(map(str,s1))} 之后是 {want} {'-'.join(map(str,s2))}",
+                              f"「{p2['text'][:30]}」", fixable=True))
+    for p, num, title in caps:
+        if not title.strip():
+            out.append(_issue('warn', 'caption', f'{kind}-no-title', _loc(p),
+                              f'{label}题注只有编号没有名称', p['text'][:30]))
+        if p['align'] != WD_ALIGN_PARAGRAPH.CENTER and not NOTE_RE.match(p['text']):
+            out.append(_issue('info', 'caption', f'{kind}-align', _loc(p),
+                              f'{label}题注未居中', p['text'][:30], fixable=True))
+    return out
+
+
+def _check_refs(D):
+    """正文有没有引用图表——「插图精准无误」的第一层：图放了但正文一次没提，等于没放。"""
+    out = []
+    body = '\n'.join(p['text'] for p in D.paras if p['kind'] == 'body')
+    refs = {(m.group(1), m.group(2)) for m in L.REF_RE.finditer(body)}
+    for kind, label in (('fig', '图'), ('tbl', '表')):
+        caps, want = _caption_paras(D, kind)
+        nums = {c[1] for c in caps}
+        if not nums:
+            continue
+        unref = sorted(n for n in nums if (label, n) not in refs)
+        if unref and len(unref) == len(nums):
+            out.append(_issue('warn', 'caption', f'{kind}-unreferenced', '全文',
+                              f'{len(unref)} 个{label}在正文中从未被引用',
+                              f'正文应有「如{label} {unref[0]} 所示」之类的指引，'
+                              f'否则读者不知道该在哪一段看这张{label}。用 create_doc 生成时不必自己数编号：'
+                              f'题注末尾加 {{#{kind}:budget}}（标签只用英文字母、数字），正文写「如@{kind}:budget 所示」，'
+                              f'成稿时自动换成真实编号'))
+        elif unref:
+            out.append(_issue('info', 'caption', f'{kind}-unreferenced', '全文',
+                              f"正文未引用：{'、'.join(f'{label} {n}' for n in unref[:6])}", ''))
+        dangling = sorted(n for (lb, n) in refs if lb == label and n not in nums)
+        if dangling:
+            out.append(_issue('error', 'caption', f'{kind}-dangling-ref', '全文',
+                              f"正文引用了不存在的{label}：{'、'.join(f'{label} {n}' for n in dangling[:6])}",
+                              '删图/换图后忘了改正文，是改稿最常见的遗留'))
+    return out
+
+
+def check_text(D, strict=False):
+    paras = [{'text': p['text'], 'kind': p['kind'], 'loc': _loc(p), 'index': p['index']}
+             for p in D.paras if p['text'].strip() and p['role'] != 'toc']
+    for t in D.tables:
+        for r in t['rows']:
+            for c in r:
+                if str(c).strip():
+                    paras.append({'text': str(c), 'kind': 'cell',
+                                  'loc': f"第 {t['index']+1} 张表", 'index': 10_000 + t['index']})
+    return P.check(paras, strict=strict)
+
+
+# ── 报告型文档的内容硬指标（可研 / 建议书 / 立项 / 任务书 / 实施计划 / 申报书）──────────────
+# 前面几族查「做得像不像一份合格的 Word」，这一族查「评审会不会一票否决」。都是从真实翻车里来的：
+#   · 可研写于 2026 年 9 月，进度计划却是 2025-10 ～ 2026-09——计划整体落在编制日期之前，
+#     说明把「已经做完的事」当成了「打算做的事」，立项论证的前提就不成立了；
+#   · 可研里一张数据图、一个 NPV 都没有，财务评价只有一句「具有良好的经济效益」。
+# 只对「向前看」的文档判时态；总结/验收/周报本来就写过去，不判。
+FORWARD_DOC = re.compile(r'可行性研究|可研报告|项目建议书|立项申请|任务书|实施计划|实施方案|申报书|项目申请书|商业计划书')
+FEAS_DOC = re.compile(r'可行性研究|可研报告')
+YM_RE = re.compile(r'(20\d{2})\s*(?:年\s*(\d{1,2})\s*月|[-./](\d{1,2})(?!\d))')
+DOC_DATE_LABEL = re.compile(r'编制(?:时间|日期)|编写日期|报告日期|提交日期|申报日期')
+SCHED_HEAD = re.compile(r'进度|年度计划|实施计划|里程碑|计划安排|实施安排|工期安排')
+PERIOD_LABEL = re.compile(r'(建设|实施|研发|项目|执行)(周期|期限)|起止(时间|日期)')
+
+
+def _ym_all(text):
+    out = []
+    for m in YM_RE.finditer(str(text or '')):
+        mo = int(m.group(2) or m.group(3))
+        if 1 <= mo <= 12:
+            out.append((int(m.group(1)), mo))
+    return out
+
+
+def _doc_title(D):
+    texts = [p['text'].strip() for p in D.paras[:12] if p['text'].strip()]
+    return ' '.join(texts[:4]) + ' ' + os.path.basename(D.path)
+
+
+def _doc_date(D):
+    """编制日期：封面信息表「编制时间：2026-09-23」优先，其次前 60 段里的同类标签。
+    不用 core_properties.created——python-docx 生成的文件那里是模板自带的 2013 年。"""
+    for t in D.tables[:3]:
+        for r in t['rows']:
+            for i, c in enumerate(r[:-1]):
+                if DOC_DATE_LABEL.search(c or ''):
+                    ym = _ym_all(r[i + 1])
+                    if ym:
+                        return ym[0]
+    for p in D.paras[:60]:
+        m = DOC_DATE_LABEL.search(p['text'])
+        if m:
+            ym = _ym_all(p['text'][m.end():])
+            if ym:
+                return ym[0]
+    return None
+
+
+def _schedule_dates(D):
+    """进度章节（含其子节与表格）里的年月，加上封面「建设周期：…（2025 年 10 月至 2026 年 9 月）」。"""
+    dates, lvl = [], None
+    for kind, b in D.blocks:
+        if kind == 'p':
+            if b['level']:
+                if lvl is not None and b['level'] <= lvl:
+                    lvl = None
+                if lvl is None and SCHED_HEAD.search(b['text']):
+                    lvl = b['level']
+                continue
+            if lvl is not None:
+                dates += _ym_all(b['text'])
+        elif lvl is not None:
+            for r in b['rows']:
+                for c in r:
+                    dates += _ym_all(c)
+    for t in D.tables[:3]:
+        for r in t['rows']:
+            for i, c in enumerate(r[:-1]):
+                if PERIOD_LABEL.search(c or ''):
+                    dates += _ym_all(r[i + 1])
+    return dates
+
+
+REPORT_EXPECT = [
+    ('系统总体/技术架构图', 'fig', r'架构'),
+    ('功能模块图（功能结构图）', 'fig', r'功能|模块|组成'),
+    ('实施进度图或进度计划表', 'any', r'进度|甘特|里程碑|计划'),
+    ('投资估算/经费预算表', 'tbl', r'投资|经费|预算|资金'),
+    ('现金流量/财务评价表', 'any', r'现金流|财务|效益|评价指标'),
+    ('敏感性分析图表', 'any', r'敏感性'),
+    ('风险分析表或风险矩阵', 'any', r'风险'),
+    ('方案比选表', 'tbl', r'比选|对比|比较'),
+]
+FIN_TERMS = [('财务净现值（NPV）', r'净现值|NPV'), ('财务内部收益率（IRR）', r'内部收益率|IRR'),
+             ('投资回收期', r'回收期'), ('敏感性分析', r'敏感性')]
+
+
+PENDING_RE = re.compile(r'[［\[【(（][^］\]】)）]{0,8}?(?:待补|待填|待定|待确认|据实填写)[^］\]】)）]{0,40}[］\]】)）]')
+
+
+def check_pending(D):
+    """「［待补：项目负责人］」这类有意留的空：不算错，但交付时必须逐条交代给用户——
+    提示级列出来，免得它悄悄留在正式稿里。"""
+    hits = [m.group(0) for p in D.paras for m in PENDING_RE.finditer(p['text'])]
+    hits += [m.group(0) for t in D.tables for r in t['rows'] for c in r for m in PENDING_RE.finditer(str(c or ''))]
+    if not hits:
+        return []
+    uniq = list(dict.fromkeys(hits))
+    shown = '、'.join(uniq[:8]) + ('…' if len(uniq) > 8 else '')
+    return [_issue('info', 'content', 'pending-info', '全文', f'文中有 {len(hits)} 处待补信息：{shown}',
+                   '交付前由用户补齐；交付说明里逐条列出')]
+
+
+def check_report(D):
+    title = _doc_title(D)
+    if not FORWARD_DOC.search(title):
+        return []
+    out = []
+    feas = bool(FEAS_DOC.search(title))
+    # ① 时态：计划不能整体落在编制日期之前
+    doc_ym, dates = _doc_date(D), _schedule_dates(D)
+    if doc_ym and dates:
+        fmt = lambda ym: f'{ym[0]} 年 {ym[1]} 月'
+        past = [d for d in dates if d < doc_ym]
+        if max(dates) <= doc_ym:
+            out.append(_issue('error', 'content', 'plan-in-past', '进度安排',
+                              f'进度计划整体早于编制时间：编制于 {fmt(doc_ym)}，计划节点最晚 {fmt(max(dates))}',
+                              '立项论证写的是「打算怎么做」：计划从编制之后排；已经完成的工作写进「现有工作基础」，'
+                              '别把做完的事当计划写'))
+        elif len(past) >= max(2, len(dates) / 2):
+            out.append(_issue('warn', 'content', 'plan-mostly-past', '进度安排',
+                              f'半数以上计划节点（{len(past)}/{len(dates)}）早于编制时间 {fmt(doc_ym)}',
+                              '已发生的部分改写成「进展/现状」，计划部分从编制之后排'))
+    if not feas:
+        return out
+    # ② 可研该有的图表
+    fig_caps = [c[0]['text'] for c in _caption_paras(D, 'fig')[0]]
+    tbl_caps = [c[0]['text'] for c in _caption_paras(D, 'tbl')[0]]
+    miss = []
+    # 一个题注都没有的文档，按题注判「缺哪类图表」就是在瞎猜（表可能在，只是没题注）——
+    # 那种情况由题注检查（fig/tbl-no-caption）去报，这里不重复下一个站不住的结论。
+    for label, where, pat in (REPORT_EXPECT if (fig_caps or tbl_caps) else []):
+        pool = fig_caps if where == 'fig' else tbl_caps if where == 'tbl' else fig_caps + tbl_caps
+        if not any(re.search(pat, c) for c in pool):
+            miss.append(label)
+    if miss:
+        out.append(_issue('warn', 'content', 'report-visuals', '全文',
+                          f'可研报告缺少评审常看的图表：{"、".join(miss)}',
+                          '结构图用 render_diagram（架构/功能模块/部署/流程），数据图用 render_chart（甘特/投资构成/'
+                          '累计现金流/敏感性龙卷风/风险矩阵），财务表与敏感性用 fin_model 一次算出'))
+    # ③ 财务评价指标
+    full = '\n'.join(p['text'] for p in D.paras) + '\n' + '\n'.join(' '.join(map(str, r)) for t in D.tables for r in t['rows'])
+    if not re.search(r'费用效果|非经营性', full):
+        lack = [lab for lab, pat in FIN_TERMS if not re.search(pat, full)]
+        if lack:
+            out.append(_issue('warn', 'content', 'report-finance', '经济效益',
+                              f'财务评价缺少：{"、".join(lack)}',
+                              '用 fin_model 按《建设项目经济评价方法与参数》口径测算（回收期基于净现金流、含建设期），'
+                              '它会同时给出现金流量表、评价指标表、敏感性表与结论句；非经营性项目改写费用效果分析'))
+    return out
+
+
+# ── 三、自动校正 ───────────────────────────────────────────────────────────
+def _set_font(run, west, east, size=None, bold=None):
+    run.font.name = west
+    rpr = run._element.get_or_add_rPr()
+    rf = rpr.get_or_add_rFonts()
+    rf.set(qn('w:eastAsia'), east)
+    rf.set(qn('w:ascii'), west)
+    rf.set(qn('w:hAnsi'), west)
+    if size is not None:
+        run.font.size = Pt(size)
+    if bold is not None:
+        run.font.bold = bold
+
+
+def _replace_same_length(para, new_text):
+    """把整段文本替换成等长的新文本，逐 run 按偏移回填——长度相等才能保住原有格式。"""
+    if len(new_text) != len(para.text) or new_text == para.text:
+        return False
+    i = 0
+    for r in para.runs:
+        n = len(r.text)
+        if n:
+            r.text = new_text[i:i + n]
+        i += n
+    return True
+
+
+HALF2FULL = [(re.compile(rf'([{P.CJK}]),(?![\d])'), '，'), (re.compile(rf'([{P.CJK}]);'), '；'),
+             (re.compile(rf'([{P.CJK}]):(?![\d/\\])'), '：'), (re.compile(rf'([{P.CJK}])\?'), '？'),
+             (re.compile(rf'([{P.CJK}])!'), '！')]
+
+
+def fix(path, out_path=None, profile_name='auto', inplace=False):
+    """修可确定性修的那几类，另存后复检。返回 (out_path, 修复计数, 复检报告)。"""
+    D = Doc(path, profile_name)
+    prof = D.profile
+    done = Counter()
+    body_size = L.pt_of(prof['body']['size'])
+    bodies = D.bodies()
+    sizes = Counter(round(p['size'], 1) for p in bodies)
+    main_size = sizes.most_common(1)[0][0] if sizes else body_size
+    want_ind = L.indent_pt(prof)
+    indented = sum(1 for p in bodies if (p['indent'] or 0) / EMU_PT >= want_ind * 0.6)
+    unify_indent = bool(bodies) and want_ind > 0 and indented / len(bodies) > 0.15
+
+    for p in D.paras:
+        para, txt = p['para'], p['text']
+        if not txt.strip():
+            continue
+        if p['role'] in ('front', 'toc'):
+            # 封面与目录有自己的版式，不套正文规范；但**中文字体缺失是全文通病**，这里也要补。
+            if not p['east']:
+                for r in para.runs:
+                    rpr = r._element.get_or_add_rPr()
+                    rpr.get_or_add_rFonts().set(qn('w:eastAsia'), prof['body']['east'])
+                done['字体'] += 1
+            continue
+        st = (prof['headings'][min(p['level'], len(prof['headings'])) - 1] if p['level']
+              else prof['caption'] if p['role'] == 'caption' else prof['body'])
+        east = st.get('east', prof['body']['east'])
+        west = st.get('west', prof['body']['west'])
+        # 1) 东亚字体缺失 → 补齐（不改已经设对的）
+        if not p['east']:
+            for r in para.runs:
+                _set_font(r, west, east)
+            done['字体'] += 1
+        # 2) 段内字号混杂 → 归一到该段主字号
+        if len(p['sizes']) > 1:
+            target = max(p['sizes'], key=lambda s: sum(len(r.text) for r in para.runs
+                                                       if abs(_eff_size(r, para, D.doc) - s) < 0.1))
+            for r in para.runs:
+                r.font.size = Pt(target)
+            done['字号'] += 1
+        # 3) 假缩进（空格顶出来的）→ 删空格 + 设真缩进
+        if p['fake_indent'] and para.runs:
+            new = re.sub(r'^[　 ]+', '', txt)
+            for r in para.runs:
+                if r.text.strip() or re.match(r'^[　 ]+$', r.text):
+                    stripped = re.sub(r'^[　 ]+', '', r.text)
+                    if stripped != r.text:
+                        r.text = stripped
+                        break
+            done['假缩进'] += 1
+        # 4) 正文首行缩进补齐
+        if p['role'] == 'body' and unify_indent and (p['indent'] or 0) / EMU_PT < want_ind * 0.6:
+            para.paragraph_format.first_line_indent = Pt(L.pt_of(st['size']) * st.get('first_indent_chars', 2))
+            done['首行缩进'] += 1
+        # 5) 半角标点 → 全角（等长替换，格式不丢）
+        # 注意读**实时** para.text：上一步删假缩进已经改过段落内容，
+        # 再拿解析时缓存的 txt 去比长度，等长判定必然落空，标点就悄悄没修——
+        # 这类「前一步改了状态、后一步还用旧快照」的顺序坑，只有跑闭环才测得出来。
+        live = para.text
+        new = live
+        for pat, ch in HALF2FULL:
+            new = pat.sub(lambda m, c=ch: m.group(1) + c, new)
+        if new != live and _replace_same_length(para, new):
+            done['标点'] += 1
+        # 6) 段末多余空格
+        if para.runs and para.runs[-1].text != para.runs[-1].text.rstrip():
+            para.runs[-1].text = para.runs[-1].text.rstrip()
+            done['行尾空格'] += 1
+        # 7) 正文误居中 → 两端对齐
+        if p['role'] == 'body' and p['align'] == WD_ALIGN_PARAGRAPH.CENTER:
+            para.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
+            done['对齐'] += 1
+        # 8) 题注居中
+        if p['role'] == 'caption' and not NOTE_RE.match(p['text']) and p['align'] != WD_ALIGN_PARAGRAPH.CENTER:
+            para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+            done['题注居中'] += 1
+
+    # 9) 正文字号归一（只在混杂比例明显时做，避免把有意的小字注释一起改了）
+    if len(sizes) > 1 and sizes.most_common(1)[0][1] / max(sum(sizes.values()), 1) >= 0.6:
+        for p in bodies:
+            # 门槛与 check_typography 的 size-mix 保持一致：那边报了这边就得能修，
+            # 否则用户会看到「体检说不统一、修复说无可修」这种自相矛盾。
+            if abs(p['size'] - main_size) > 0.6:
+                for r in p['para'].runs:
+                    r.font.size = Pt(main_size)
+                done['字号统一'] += 1
+
+    # 10) 连续空段收成一个
+    empties, kill = [], []
+    for p in D.paras:
+        if p['role'] in ('front', 'toc'):
+            empties = []
+            continue
+        if p['empty'] and not p['n_draw']:
+            empties.append(p)
+        else:
+            if len(empties) >= 3:
+                kill.extend(empties[1:])
+            empties = []
+    if len(empties) >= 3:
+        kill.extend(empties[1:])
+    for p in kill:
+        el = p['para']._p
+        el.getparent().remove(el)
+        done['空段'] += 1
+
+    # 11) 表格：加框线样式 / 表头加粗 / 长表跨页重复标题行 / 超版心缩宽
+    for t in D.tables:
+        if t.get('front'):
+            continue
+        tb = t['tbl']
+        if t['style'] in ('Normal Table', 'Table Normal', ''):
+            try:
+                tb.style = 'Table Grid'
+                done['表格框线'] += 1
+            except Exception:
+                pass
+        if not t['head_bold'] and t['n_rows'] > 1 and not t['form_like']:
+            for c in tb.rows[0].cells:
+                for par in c.paragraphs:
+                    for r in par.runs:
+                        r.font.bold = True
+            done['表头加粗'] += 1
+        if t['n_rows'] > 12 and not t['head_repeat']:
+            tr = tb.rows[0]._tr
+            trpr = tr.get_or_add_trPr()
+            th = OxmlElement('w:tblHeader')
+            th.set(qn('w:val'), 'true')
+            trpr.append(th)
+            done['跨页表头'] += 1
+        if t['total_pt'] and t['total_pt'] > D.body_w_pt * L.TOL:
+            widths = L.fit_table_widths(t['rows'], prof, prof['table']['size'])
+            widths = [w * (D.body_w_pt * L.PT_CM) / max(sum(widths), 1e-6) for w in widths]
+            try:
+                tb.autofit = False
+                for j, w in enumerate(widths):
+                    for row in tb.rows:
+                        if j < len(row.cells):
+                            row.cells[j].width = Cm(round(w, 3))
+                grid = tb._tbl.tblGrid
+                if grid is not None:
+                    for gc, w in zip(grid.findall(qn('w:gridCol')), widths):
+                        gc.set(qn('w:w'), str(int(w * L.CM_PT * 20)))
+                done['表格缩宽'] += 1
+            except Exception:
+                pass
+
+    # 12) 插图：恢复原始比例 + 缩回版心
+    for i, f in enumerate(D.figures):
+        if not f['ok']:
+            continue
+        try:
+            sh = D.doc.inline_shapes[i]
+        except (IndexError, KeyError):
+            continue
+        w_pt, h_pt = f['w_pt'], f['h_pt']
+        if f['px_w'] and f['px_h'] and w_pt and h_pt:
+            nat = f['px_w'] / f['px_h']
+            if abs((w_pt / h_pt) - nat) / nat > 0.03:
+                h_pt = w_pt / nat
+                done['图片比例'] += 1
+        bw, bh = f.get('sec_w_pt', D.body_w_pt), f.get('sec_h_pt', D.body_h_pt)   # 横排页按横排版心算
+        if w_pt > bw:
+            scale = bw / w_pt
+            w_pt, h_pt = w_pt * scale, h_pt * scale
+            done['图片缩宽'] += 1
+        if h_pt > bh * 0.92:
+            scale = (bh * 0.92) / h_pt
+            w_pt, h_pt = w_pt * scale, h_pt * scale
+            done['图片缩高'] += 1
+        if abs(w_pt - f['w_pt']) > 0.5 or abs(h_pt - f['h_pt']) > 0.5:
+            sh.width = Emu(int(w_pt * EMU_PT))
+            sh.height = Emu(int(h_pt * EMU_PT))
+
+    # 13) 图表题注重排编号
+    done += _renumber_captions(D)
+
+    if not out_path:
+        base, ext = os.path.splitext(path)
+        out_path = path if inplace else base + '-已校正' + ext
+    D.doc.save(out_path)
+    return out_path, done
+
+
+def _renumber_captions(D):
+    done = Counter()
+    for kind in ('fig', 'tbl'):
+        caps, want = _caption_paras(D, kind)
+        by_chap = defaultdict(int)
+        n = 0
+        for p, num, title in caps:
+            if D.profile.get('caption_by_chapter'):
+                by_chap[p['chapter']] += 1
+                new_num = f"{p['chapter']}-{by_chap[p['chapter']]}"
+            else:
+                n += 1
+                new_num = str(n)
+            if new_num == num:
+                continue
+            old = p['text']
+            new = L.CAPTION_RE.sub(lambda m: f"{m.group(1)} {new_num}  {m.group(3)}".rstrip(), old.strip())
+            if p['para'].runs:
+                for r in p['para'].runs[1:]:
+                    r.text = ''
+                p['para'].runs[0].text = new
+                done['题注编号'] += 1
+    return done
+
+
+# ── 四、汇总与报告 ─────────────────────────────────────────────────────────
+LEVEL_LABEL = {'error': '必修', 'warn': '建议', 'info': '提示'}
+GROUP_LABEL = {'structure': '结构', 'layout': '排版', 'table': '表格', 'figure': '插图', 'content': '内容',
+               'caption': '图表题注', 'text': '文字', 'punct': '标点', 'ai': 'AI 味',
+               'consistency': '一致性'}
+ORDER = {'error': 0, 'warn': 1, 'info': 2}
+
+
+def inspect(path, profile_name='auto', strict=False):
+    D = Doc(path, profile_name)
+    issues = []
+    issues += check_structure(D)
+    issues += check_typography(D, strict)
+    issues += check_tables(D)
+    issues += check_figures(D)
+    issues += check_text(D, strict)
+    issues += check_report(D)
+    issues += check_pending(D)
+    counts = Counter(i['level'] for i in issues)
+    return {
+        'path': path,
+        'profile': D.profile['name'],
+        'profile_label': D.profile['label'],
+        'stats': {'paragraphs': len(D.paras), 'headings': sum(1 for p in D.paras if p['level']),
+                  'tables': len(D.tables), 'figures': len(D.figures),
+                  'chars': sum(len(p['text']) for p in D.paras), 'pages_est': D.est_pages(),
+                  'body_width_cm': round(D.body_w_pt / L.CM_PT, 2)},
+        'counts': {'error': counts.get('error', 0), 'warn': counts.get('warn', 0),
+                   'info': counts.get('info', 0)},
+        'issues': issues,
+    }
+
+
+def report(res, limit=5, show_info=True):
+    s, c = res['stats'], res['counts']
+    lines = [f"【文档体检】{os.path.basename(res['path'])} · {res['profile_label']}",
+             f"  规模：{s['paragraphs']} 段 / {s['headings']} 标题 / {s['tables']} 表 / "
+             f"{s['figures']} 图 / {s['chars']} 字 / 约 {s['pages_est']} 页（版心 {s['body_width_cm']}cm）",
+             f"  结论：必修 {c['error']} · 建议 {c['warn']} · 提示 {c['info']}"]
+    grouped = defaultdict(list)
+    for it in res['issues']:
+        grouped[(it['level'], it['group'], it['kind'])].append(it)
+    for key in sorted(grouped, key=lambda k: (ORDER[k[0]], k[1])):
+        lvl, grp, _ = key
+        if lvl == 'info' and not show_info:
+            continue
+        items = grouped[key]
+        head = f"  [{LEVEL_LABEL[lvl]}·{GROUP_LABEL.get(grp, grp)}] {items[0]['msg']}"
+        if len(items) > 1:
+            head += f'（{len(items)} 处）'
+        if items[0].get('fixable'):
+            head += ' ⟨可自动修⟩'
+        lines.append(head)
+        for it in items[:limit]:
+            d = f" — {it['detail']}" if it.get('detail') else ''
+            if it['loc'] and it['loc'] != '全文':
+                lines.append(f"      · {it['loc']}{d}")
+            elif d:
+                lines.append(f"      ·{d}")
+        if len(items) > limit:
+            lines.append(f'      · …另有 {len(items)-limit} 处')
+    if not res['issues']:
+        lines.append('  未发现问题。')
+    return '\n'.join(lines)
+
+
+def main(argv):
+    args = [a for a in argv if not a.startswith('--')]
+    if not args:
+        print('用法：python docx_check.py 文档.docx [--fix] [--inplace] [--strict] '
+              '[--profile tech|gov|report] [--json]')
+        return 2
+    path = args[0]
+    prof = 'auto'
+    for a in argv:
+        if a.startswith('--profile'):
+            prof = a.split('=', 1)[1] if '=' in a else (args[1] if len(args) > 1 else 'auto')
+    strict = '--strict' in argv
+    if not os.path.exists(path):
+        print(f'文件不存在：{path}')
+        return 2
+    if os.path.isdir(path):
+        print('目录不是单份文档：整套项目文档的档案体检请用 tech-doc/scripts/archive_check.py，或 docx_inspect 直接传目录')
+        return 2
+    if path.lower().endswith('.doc'):
+        # 排版体检要的是 docx 里的字体、缩进、列宽这些**格式事实**，
+        # 旧版 .doc 是另一种二进制容器，取不到——甩一个 python-docx 的
+        # 「is not a Word file」堆栈只会让人以为文件坏了。
+        print(f'{os.path.basename(path)} 是旧版二进制 .doc，排版体检需要 .docx：\n'
+              '  · 用 Word/WPS 另存为 .docx 后重跑，可拿到完整的七类排版体检；\n'
+              '  · 只想查文字与 AI 味的话，先转成纯文本再传（.md/.txt 也支持）；\n'
+              '  · 整套归档体检（archive_check）已能读 .doc 的正文，不受此限。')
+        return 2
+    res = inspect(path, prof, strict)
+    if '--json' in argv:
+        print(json.dumps(res, ensure_ascii=False, default=str))
+        return 0
+    print(report(res))
+    if '--fix' in argv:
+        out, done = fix(path, None, prof, inplace='--inplace' in argv)
+        print('\n【自动校正】' + ('、'.join(f'{k} {v} 处' for k, v in done.items()) if done else '无可自动修复项'))
+        print(f'  已另存：{out}' if not '--inplace' in argv else f'  已就地修改：{out}')
+        res2 = inspect(out, prof, strict)
+        print('\n' + report(res2))
+        rest = [i for i in res2['issues'] if i['level'] == 'error']
+        if rest:
+            print(f"\n  仍有 {len(rest)} 项必修需要人来定：" +
+                  '、'.join(sorted({i['msg'][:20] for i in rest})[:4]))
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv[1:]))